diff --git a/packages/core/src/compiler/timingCompiler.test.ts b/packages/core/src/compiler/timingCompiler.test.ts
index b9ec7bcc02..30f5bbc01c 100644
--- a/packages/core/src/compiler/timingCompiler.test.ts
+++ b/packages/core/src/compiler/timingCompiler.test.ts
@@ -468,3 +468,29 @@ describe("shouldClampResolvedMediaDuration", () => {
     expect(shouldClampResolvedMediaDuration("audio", 5, 1)).toBe(true);
   });
 });
+
+describe("rate lane in compiled media", () => {
+  const lane = {
+    version: 1,
+    lanes: [
+      {
+        target: "rate",
+        points: [
+          { t: 0, v: 1 },
+          { t: 2, v: 3 },
+        ],
+      },
+    ],
+  };
+  const encodings = [
+    ["single-quoted JSON", `data-automation='${JSON.stringify(lane)}'`],
+    ["entity-encoded JSON", `data-automation="${JSON.stringify(lane).replace(/"/g, """)}"`],
+  ];
+
+  it.each(encodings)("hands a %s rate lane to the unresolved element", (_name, attr) => {
+    const { unresolved } = compileTimingAttrs(
+      `<video id="v" src="a.mp4" data-start="0" ${attr}></video>`,
+    );
+    expect(unresolved[0]?.playbackRate).toMatchObject({ target: "rate" });
+  });
+});
diff --git a/packages/core/src/compiler/timingCompiler.ts b/packages/core/src/compiler/timingCompiler.ts
index 30c0525cc3..2874a45190 100644
--- a/packages/core/src/compiler/timingCompiler.ts
+++ b/packages/core/src/compiler/timingCompiler.ts
@@ -21,9 +21,10 @@
 import { parseNumeric } from "@hyperframes/parsers/composition-contract";
 import {
   parseStrictFiniteTimingNumber,
-  readElementPlaybackRate,
+  readElementRateSpec,
   readMediaStart,
 } from "../runtime/playbackRate.js";
+import type { RateSpec } from "../speedRamp.js";
 // ── Types ────────────────────────────────────────────────────────────────
 
 export interface UnresolvedElement {
@@ -34,7 +35,7 @@ export interface UnresolvedElement {
   end?: number;
   duration?: number;
   mediaStart: number;
-  playbackRate: number;
+  playbackRate: RateSpec;
   compositionSrc?: string;
 }
 
@@ -50,7 +51,7 @@ export interface ResolvedMediaElement {
   start: number;
   duration: number;
   mediaStart: number;
-  playbackRate: number;
+  playbackRate: RateSpec;
   loop: boolean;
 }
 
@@ -91,8 +92,25 @@ function getAttr(tag: string, attr: string): string | null {
   // made compileTag believe a Studio-stamped `data-hf-id`-only element already
   // had an `id`, so it skipped its `hf-video-N` injection — leaving the element
   // with no real `el.id`, which the render pipeline keys off of (blank wash).
-  const match = tag.match(new RegExp(`(?<![\\w-])${attr}=["']([^"']+)["']`));
-  return match ? (match[1] ?? null) : null;
+  const match = tag.match(new RegExp(`(?<![\\w-])${attr}=(?:"([^"]+)"|'([^']+)')`));
+  return match ? (match[1] ?? match[2] ?? null) : null;
+}
+
+/** An attribute reader over tag source that decodes the entities the DOM would, for JSON-valued attributes. */
+function tagAttrReader(tag: string): Pick<Element, "getAttribute"> {
+  return {
+    getAttribute: (name) => {
+      const raw = getAttr(tag, name);
+      return raw && name === "data-automation"
+        ? raw
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&amp;/g, "&")
+        : raw;
+    },
+  };
 }
 
 function hasAttr(tag: string, attr: string): boolean {
@@ -228,9 +246,9 @@ function compileTag(
     startStr = "0";
   }
   const start = parseNumeric(startStr);
-  const attrReader = { getAttribute: (name: string) => getAttr(result, name) };
+  const attrReader = tagAttrReader(result);
   const mediaStart = readMediaStart(attrReader);
-  const playbackRate = readElementPlaybackRate(attrReader);
+  const playbackRate = readElementRateSpec(attrReader);
 
   // 1. Compute data-end from data-start + data-duration. Skip relative id-refs.
   if (!hasAttr(result, "data-end")) {
@@ -374,7 +392,7 @@ export function extractResolvedMedia(html: string): ResolvedMediaElement[] {
 
     const isVideo = /^<video/i.test(tag);
     const startStr = getAttr(tag, "data-start");
-    const attrReader = { getAttribute: (name: string) => getAttr(tag, name) };
+    const attrReader = tagAttrReader(tag);
 
     resolved.push({
       id,
@@ -383,7 +401,7 @@ export function extractResolvedMedia(html: string): ResolvedMediaElement[] {
       start: parseNumeric(startStr) ?? 0,
       duration,
       mediaStart: readMediaStart(attrReader),
-      playbackRate: readElementPlaybackRate(attrReader),
+      playbackRate: readElementRateSpec(attrReader),
       loop: hasAttr(tag, "loop"),
     });
   }
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 835a038dcb..577d5d9735 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -321,12 +321,15 @@ export {
 export { createRuntimeStartTimeResolver } from "./runtime/startResolver.js";
 export {
   normalizePlaybackRate,
+  normalizeRateSpec,
   parseStrictFiniteTimingNumber,
   readElementPlaybackRate,
+  readElementRateSpec,
   readMediaStart,
   resolveNaturalMediaTimelineDuration,
   resolveNaturalMediaTimelineDurationFromValues,
 } from "./runtime/playbackRate.js";
+export { shiftRateLane, sourceTimeAt, timeAtSourceTime, type RateSpec } from "./speedRamp.js";
 
 // Variable validation (CLI / tooling-side)
 export {
diff --git a/packages/core/src/runtime/media.test.ts b/packages/core/src/runtime/media.test.ts
index 7ad12fc255..7e85d8dd8f 100644
--- a/packages/core/src/runtime/media.test.ts
+++ b/packages/core/src/runtime/media.test.ts
@@ -380,7 +380,6 @@ describe("syncRuntimeMedia", () => {
       expect(clip.el.currentTime).toBeCloseTo(3.641, 2);
       syncRuntimeMedia({ clips: [clip], timeSeconds: 3, playing: true, playbackRate: 1 });
       expect(clip.el.playbackRate).toBeCloseTo(3, 5);
-      expect(clip.el.preservesPitch).toBe(true);
     });
   });
 
diff --git a/packages/core/src/runtime/media.ts b/packages/core/src/runtime/media.ts
index d535000c89..04157c47d2 100644
--- a/packages/core/src/runtime/media.ts
+++ b/packages/core/src/runtime/media.ts
@@ -2,13 +2,7 @@ import { swallow } from "./diagnostics";
 import { interpolateVolumeGain, type VolumeKeyframe } from "./mediaVolumeEnvelope.js";
 import { elementVolumeLaneGain } from "./audioAutomationVolume.js";
 import { readElementPlaybackRate, readElementRateSpec, readMediaStart } from "./playbackRate.js";
-import {
-  rateAt,
-  readPreservePitch,
-  sourceTimeAt,
-  timeAtSourceTime,
-  type RateSpec,
-} from "../speedRamp.js";
+import { rateAt, sourceTimeAt, timeAtSourceTime, type RateSpec } from "../speedRamp.js";
 import { clampAudioGain } from "../audioGain.js";
 import { isMemberGroupHidden } from "../audioGroups.js";
 import { findInjectedRenderFrame } from "./renderFrameSibling.js";
@@ -386,7 +380,6 @@ export function syncRuntimeMedia(params: {
       try {
         // Per-element rate × global transport rate
         el.playbackRate = rateAt(clipRate, params.timeSeconds - clip.start) * params.playbackRate;
-        el.preservesPitch = readPreservePitch(el);
       } catch (err) {
         // ignore unsupported playbackRate
         swallow("runtime.media.site1", err);
diff --git a/packages/core/src/runtime/playbackRate.ts b/packages/core/src/runtime/playbackRate.ts
index 82df1e9cc6..f10ebbf396 100644
--- a/packages/core/src/runtime/playbackRate.ts
+++ b/packages/core/src/runtime/playbackRate.ts
@@ -24,6 +24,11 @@ export function readElementPlaybackRate(el: Pick<Element, "getAttribute">): numb
   return normalizePlaybackRate(raw);
 }
 
+/** A constant rate clamped to the shared range; a lane is already normalised by its parser. */
+export function normalizeRateSpec(spec: RateSpec | undefined): RateSpec {
+  return typeof spec === "object" ? spec : normalizePlaybackRate(spec ?? 1);
+}
+
 /** The clip's rate: its `rate` lane when present, otherwise the constant rate. */
 export function readElementRateSpec(el: Pick<Element, "getAttribute">): RateSpec {
   return resolveRateSpec(el.getAttribute("data-automation"), readElementPlaybackRate(el));
diff --git a/packages/core/src/speedRamp.test.ts b/packages/core/src/speedRamp.test.ts
index b25e9be07c..be3e89242b 100644
--- a/packages/core/src/speedRamp.test.ts
+++ b/packages/core/src/speedRamp.test.ts
@@ -4,8 +4,8 @@ import {
   SPEED_PRESETS,
   parseRateLane,
   rateAt,
-  readPreservePitch,
   resolveRateSpec,
+  shiftRateLane,
   sourceTimeAt,
   speedPresetLane,
   timeAtSourceTime,
@@ -71,6 +71,31 @@ describe("rateAt", () => {
   });
 });
 
+describe("shiftRateLane", () => {
+  it("sees the lane from dt seconds in: integrating from 1s of a 4s 1x to 3x ramp", () => {
+    const lane = ramp([
+      [0, 1],
+      [4, 3],
+    ]);
+    // source(3) - source(1) = 4.6586 - 1.1508
+    expect(sourceTimeAt(shiftRateLane(lane, 1), 2)).toBeCloseTo(3.5078, 2);
+  });
+});
+
+describe("shiftRateLane with a shaped segment", () => {
+  it("keeps the curve of a segment cut in the middle: shifted integral equals the original's difference", () => {
+    const lane: HfAutomationLane = {
+      target: RATE_TARGET,
+      points: [
+        { t: 0, v: 1, curve: 0.8 },
+        { t: 4, v: 3 },
+      ],
+    };
+    const expected = sourceTimeAt(lane, 4) - sourceTimeAt(lane, 1);
+    expect(sourceTimeAt(shiftRateLane(lane, 1), 3)).toBeCloseTo(expected, 2);
+  });
+});
+
 describe("lane parsing", () => {
   const attr = JSON.stringify({
     version: 1,
@@ -88,7 +113,7 @@ describe("lane parsing", () => {
   });
 });
 
-describe("presets and pitch", () => {
+describe("presets", () => {
   it("stretches every preset over the clip and keeps it in range", () => {
     for (const { id } of SPEED_PRESETS) {
       const lane = speedPresetLane(id, 8);
@@ -96,10 +121,4 @@ describe("presets and pitch", () => {
       for (const p of lane.points) expect(p.v).toBeGreaterThanOrEqual(0.1);
     }
   });
-
-  it("preserves pitch unless the clip opts out", () => {
-    const el = (v: string | null) => ({ getAttribute: () => v });
-    expect(readPreservePitch(el(null))).toBe(true);
-    expect(readPreservePitch(el("false"))).toBe(false);
-  });
 });
diff --git a/packages/core/src/speedRamp.ts b/packages/core/src/speedRamp.ts
index a9b684a915..7d26df419c 100644
--- a/packages/core/src/speedRamp.ts
+++ b/packages/core/src/speedRamp.ts
@@ -7,7 +7,25 @@ import { MAX_PLAYBACK_RATE, MIN_PLAYBACK_RATE } from "./playbackRateBounds.js";
 /** A constant multiplier, or a lane whose `v` is the multiplier over clip-local time. */
 export type RateSpec = number | HfAutomationLane;
 
-const PRESERVE_PITCH_ATTR = "data-preserve-pitch";
+const SHIFT_RESAMPLES = 16;
+
+/**
+ * The lane as seen from `dt` seconds into the clip: what a renderer sees after it trims the clip's start.
+ * A shaped segment (`curve`, `viaX`) cut in the middle is resampled, since its shape belongs to its left point.
+ */
+export function shiftRateLane(spec: RateSpec, dt: number): RateSpec {
+  if (typeof spec === "number" || dt === 0) return spec;
+  const next = spec.points.findIndex((p) => p.t > dt);
+  const later = next < 0 ? [] : spec.points.slice(next).map((p) => ({ ...p, t: p.t - dt }));
+  const left = next > 0 ? spec.points[next - 1] : undefined;
+  const shaped = left !== undefined && (left.curve || left.viaX !== undefined);
+  const cut = shaped && next > 0 ? spec.points[next]!.t - dt : 0;
+  const samples = Array.from({ length: shaped ? SHIFT_RESAMPLES - 1 : 0 }, (_, k) => {
+    const t = ((k + 1) * cut) / SHIFT_RESAMPLES;
+    return { t, v: rateAt(spec, dt + t) };
+  });
+  return { ...spec, points: [{ t: 0, v: rateAt(spec, dt) }, ...samples, ...later] };
+}
 
 const CELLS_PER_SEGMENT = 48;
 
@@ -114,11 +132,6 @@ export function resolveRateSpec(
   return parseRateLane(automationAttr) ?? constant;
 }
 
-/** Pitch is preserved unless the clip opts out with `data-preserve-pitch="false"`. */
-export function readPreservePitch(el: Pick<Element, "getAttribute">): boolean {
-  return el.getAttribute(PRESERVE_PITCH_ATTR) !== "false";
-}
-
 interface RatePreset {
   id: string;
   label: string;
diff --git a/packages/engine/src/services/audioMixer.test.ts b/packages/engine/src/services/audioMixer.test.ts
index 6837d35972..ca328a3add 100644
--- a/packages/engine/src/services/audioMixer.test.ts
+++ b/packages/engine/src/services/audioMixer.test.ts
@@ -390,6 +390,95 @@ describe("processCompositionAudio", () => {
     expect(runFfmpegMock.mock.calls[0]?.[0]).toEqual(expect.arrayContaining(["-af", filter]));
   });
 
+  it("bakes a rate lane as concatenated source slices whose tempo is the mean rate over each slice", async () => {
+    const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
+    const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
+    tempDirs.push(baseDir, workDir);
+    writeFileSync(join(baseDir, "timecode.wav"), "stub");
+    const rate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 2 },
+        { t: 1, v: 2 },
+      ],
+    };
+
+    await processCompositionAudio(
+      [
+        {
+          id: "timecode",
+          src: "timecode.wav",
+          start: 0,
+          end: 1,
+          mediaStart: 0,
+          playbackRate: rate,
+          layer: 0,
+          volume: 1,
+          type: "audio",
+        },
+      ],
+      baseDir,
+      workDir,
+      join(baseDir, "out.m4a"),
+      1,
+    );
+
+    const args: string[] = runFfmpegMock.mock.calls[0]?.[0] ?? [];
+    const graph = args[args.indexOf("-filter_complex") + 1] ?? "";
+    // a constant 2x lane: 1s of composition consumes 2s of source, in 4 quarter-second slices
+    expect(args).toEqual(expect.arrayContaining(["-t", "2", "-map", "[out]"]));
+    expect(graph).toContain("asplit=4");
+    expect(graph).toContain(
+      "[s0]atrim=start=0:end=0.5,asetpts=PTS-STARTPTS,atempo=2,apad,asetpts=N/SR/TB,atrim=0:0.25[t0]",
+    );
+    expect(graph).toContain(
+      "[s3]atrim=start=1.5:end=2,asetpts=PTS-STARTPTS,atempo=2,apad,asetpts=N/SR/TB,atrim=0:0.25[t3]",
+    );
+    expect(graph).toContain("concat=n=4:v=0:a=1");
+  });
+
+  it("stretches each slice of a non-constant lane by its mean rate, and trims a video's audio to the consumed span", async () => {
+    const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
+    const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
+    tempDirs.push(baseDir, workDir);
+    writeFileSync(join(baseDir, "clip.mp4"), "stub");
+    const rate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 1, v: 3 },
+      ],
+    };
+
+    await processCompositionAudio(
+      [
+        {
+          id: "clip",
+          src: "clip.mp4",
+          start: 0,
+          end: 1,
+          mediaStart: 0,
+          playbackRate: rate,
+          layer: 0,
+          volume: 1,
+          type: "video",
+        },
+      ],
+      baseDir,
+      workDir,
+      join(baseDir, "out.m4a"),
+      1,
+    );
+
+    const args: string[] = runFfmpegMock.mock.calls[0]?.[0] ?? [];
+    const graph = args[args.indexOf("-filter_complex") + 1] ?? "";
+    // geometric 1x to 3x over 1s consumes (3-1)/ln 3 = 1.8205 source seconds; quarter-second 0 has mean tempo 1.1508
+    expect(Number(args[args.indexOf("-t") + 1])).toBeCloseTo(1.8205, 2);
+    expect(
+      Number(graph.match(/\[s0\]atrim=[^,]*,asetpts=PTS-STARTPTS,atempo=([\d.]+)/)?.[1]),
+    ).toBeCloseTo(1.1508, 2);
+  });
+
   it("keeps automation on authored timeline time after constant retiming", async () => {
     const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
     const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
diff --git a/packages/engine/src/services/audioMixer.ts b/packages/engine/src/services/audioMixer.ts
index 2c2b8c6884..d4cc17aa4c 100644
--- a/packages/engine/src/services/audioMixer.ts
+++ b/packages/engine/src/services/audioMixer.ts
@@ -44,8 +44,13 @@ import { chainTailSeconds } from "@hyperframes/core/audio-fx-tail";
 import {
   MEDIA_RENDER_ID_ATTR,
   normalizePlaybackRate,
+  normalizeRateSpec,
   parseStrictFiniteTimingNumber,
+  readElementRateSpec,
   readMediaStart,
+  sourceTimeAt,
+  timeAtSourceTime,
+  type RateSpec,
 } from "@hyperframes/core";
 import { HF_AUDIO_GROUP_ATTR, resolveAudioGroups } from "@hyperframes/core/audio-groups";
 import { AUDIO_GROUP_RENDER_ID_ATTR } from "@hyperframes/core";
@@ -129,7 +134,45 @@ function buildAtempoFilter(playbackRate: number): string | null {
   return stages.map((stage) => `atempo=${formatFilterNumber(stage)}`).join(",");
 }
 
-function preparedAudioOutputArgs(srcPath: string, playbackRate: number): Promise<string[]> {
+/** Composition seconds per constant-tempo slice when a rate lane is baked into audio. */
+const RAMP_SLICE_SECONDS = 0.25;
+const MAX_RAMP_SLICES = 240;
+
+/** Bake a rate lane as consecutive source slices, each stretched by its mean `sourceTimeAt` rate, keeping pitch. */
+function buildRampFilterComplex(
+  lane: RateSpec & object,
+  duration: number,
+  tailFilter: string | null,
+): string {
+  const slices = Math.min(MAX_RAMP_SLICES, Math.max(1, Math.ceil(duration / RAMP_SLICE_SECONDS)));
+  const step = duration / slices;
+  const split = Array.from({ length: slices }, (_, i) => `[s${i}]`).join("");
+  const parts = [`[0:a]asplit=${slices}${split}`];
+  for (let i = 0; i < slices; i += 1) {
+    const from = sourceTimeAt(lane, i * step);
+    const to = sourceTimeAt(lane, (i + 1) * step);
+    const tempo = buildAtempoFilter((to - from) / step);
+    const chain = [
+      `atrim=start=${formatFilterNumber(from)}:end=${formatFilterNumber(to)}`,
+      "asetpts=PTS-STARTPTS",
+      ...(tempo ? [tempo] : []),
+      "apad",
+      "asetpts=N/SR/TB",
+      `atrim=0:${formatFilterNumber(step)}`,
+    ].join(",");
+    parts.push(`[s${i}]${chain}[t${i}]`);
+  }
+  const joined = Array.from({ length: slices }, (_, i) => `[t${i}]`).join("");
+  parts.push(`${joined}concat=n=${slices}:v=0:a=1${tailFilter ? "[cat]" : "[out]"}`);
+  if (tailFilter) parts.push(`[cat]${tailFilter}[out]`);
+  return parts.join(";");
+}
+
+function preparedAudioOutputArgs(
+  srcPath: string,
+  playbackRate: RateSpec,
+  duration = 0,
+): Promise<string[]> {
   return stereoOutputArgs(srcPath).then((channelArgs) => {
     const filters: string[] = [];
     const outputArgs: string[] = [];
@@ -138,6 +181,10 @@ function preparedAudioOutputArgs(srcPath: string, playbackRate: number): Promise
     } else {
       outputArgs.push(...channelArgs);
     }
+    if (typeof playbackRate === "object") {
+      const graph = buildRampFilterComplex(playbackRate, duration, filters.join(",") || null);
+      return ["-filter_complex", graph, "-map", "[out]", ...outputArgs];
+    }
     const atempo = buildAtempoFilter(playbackRate);
     if (atempo) filters.push(atempo);
     if (filters.length > 0) outputArgs.push("-af", filters.join(","));
@@ -521,7 +568,6 @@ export function parseAudioElements(html: string): AudioElement[] {
     src: string,
     type: AudioElement["type"],
   ): AudioElement => {
-    const playbackRateAttr = el.getAttribute("data-playback-rate");
     const layerAttr = el.getAttribute("data-layer");
     const volumeAttr = el.getAttribute("data-volume");
     const fxChain = el.getAttribute(HF_AUDIO_FX_ATTR);
@@ -536,9 +582,7 @@ export function parseAudioElements(html: string): AudioElement[] {
       start: resolveStart(el),
       end: parseEnd(el.getAttribute("data-end")),
       mediaStart: readMediaStart(el),
-      playbackRate: normalizePlaybackRate(
-        playbackRateAttr ? parseFloat(playbackRateAttr) : Number.NaN,
-      ),
+      playbackRate: readElementRateSpec(el),
       layer: layerAttr ? parseInt(layerAttr) : 0,
       volume: volumeAttr ? parseFloat(volumeAttr) : 1.0,
       ...(fxChain ? { fxChain } : {}),
@@ -585,7 +629,7 @@ export function parseAudioElements(html: string): AudioElement[] {
 async function extractAudioFromVideo(
   videoPath: string,
   outputPath: string,
-  options?: { startTime?: number; duration?: number; playbackRate?: number },
+  options?: { startTime?: number; duration?: number; playbackRate?: RateSpec },
   signal?: AbortSignal,
   config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout">>,
 ): Promise<ExtractResult> {
@@ -593,12 +637,14 @@ async function extractAudioFromVideo(
   const outputDir = dirname(outputPath);
   if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true });
 
-  const playbackRate = normalizePlaybackRate(options?.playbackRate ?? 1);
+  const playbackRate = normalizeRateSpec(options?.playbackRate);
   const args: string[] = [];
   if (options?.startTime !== undefined) args.push("-ss", String(options.startTime));
-  if (options?.duration !== undefined) args.push("-t", String(options.duration * playbackRate));
+  if (options?.duration !== undefined) {
+    args.push("-t", String(sourceTimeAt(playbackRate, options.duration)));
+  }
   args.push("-i", videoPath);
-  const outputArgs = await preparedAudioOutputArgs(videoPath, playbackRate);
+  const outputArgs = await preparedAudioOutputArgs(videoPath, playbackRate, options?.duration);
   args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
   if (playbackRate !== 1 && options?.duration !== undefined) {
     args.push("-t", String(options.duration));
@@ -641,21 +687,21 @@ async function prepareAudioTrack(
   outputPath: string,
   mediaStart: number,
   duration: number,
-  playbackRate = 1,
+  playbackRate: RateSpec = 1,
   signal?: AbortSignal,
   config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout">>,
 ): Promise<ExtractResult> {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname(outputPath);
   if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true });
-  const normalizedPlaybackRate = normalizePlaybackRate(playbackRate);
-  const outputArgs = await preparedAudioOutputArgs(srcPath, normalizedPlaybackRate);
+  const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
+  const outputArgs = await preparedAudioOutputArgs(srcPath, normalizedPlaybackRate, duration);
 
   const args = [
     "-ss",
     String(mediaStart),
     "-t",
-    String(duration * normalizedPlaybackRate),
+    String(sourceTimeAt(normalizedPlaybackRate, duration)),
     "-i",
     srcPath,
     "-acodec",
@@ -1184,9 +1230,10 @@ export async function processCompositionAudio(
             );
             return;
           }
-          const effectiveDuration =
-            (metadata.durationSeconds - element.mediaStart) /
-            normalizePlaybackRate(element.playbackRate ?? 1);
+          const effectiveDuration = timeAtSourceTime(
+            normalizeRateSpec(element.playbackRate),
+            metadata.durationSeconds - element.mediaStart,
+          );
           element.end =
             element.start + (effectiveDuration > 0 ? effectiveDuration : metadata.durationSeconds);
         }
diff --git a/packages/engine/src/services/audioMixer.types.ts b/packages/engine/src/services/audioMixer.types.ts
index 9097045c6c..d3e9bc535f 100644
--- a/packages/engine/src/services/audioMixer.types.ts
+++ b/packages/engine/src/services/audioMixer.types.ts
@@ -1,3 +1,5 @@
+import type { RateSpec } from "@hyperframes/core";
+
 export interface AudioVolumeKeyframe {
   time: number;
   volume: number;
@@ -9,8 +11,8 @@ export interface AudioElement {
   start: number;
   end: number;
   mediaStart: number;
-  /** Constant normalized source-time multiplier (0.1..5). */
-  playbackRate?: number;
+  /** Normalized source-time multiplier: a constant, or the clip's `rate` lane. */
+  playbackRate?: RateSpec;
   layer: number;
   volume?: number;
   volumeKeyframes?: AudioVolumeKeyframe[];
diff --git a/packages/engine/src/services/videoFrameExtractor.test.ts b/packages/engine/src/services/videoFrameExtractor.test.ts
index 6e9408696e..5527c88ac5 100644
--- a/packages/engine/src/services/videoFrameExtractor.test.ts
+++ b/packages/engine/src/services/videoFrameExtractor.test.ts
@@ -21,6 +21,8 @@ import {
   extractVideoFramesRange,
   extractionFrameCountForDuration,
   createFrameLookupTable,
+  FrameLookupTable,
+  rebaseVideoToWindow,
   resolveProjectRelativeSrc,
   resolveFrameFormat,
   codecMayHaveAlpha,
@@ -57,7 +59,7 @@ import {
 import { runFfmpeg } from "../utils/runFfmpeg.js";
 import { COMPLETE_SENTINEL, GC_MARKER, SCHEMA_PREFIX } from "./extractionCache.js";
 import { resolveRuntimeMediaClipDuration } from "../../../core/src/runtime/media.js";
-import { compileTimingAttrs } from "@hyperframes/core";
+import { compileTimingAttrs, sourceTimeAt } from "@hyperframes/core";
 import { RATE_RANGE } from "@hyperframes/core/audio-automation";
 
 // ffmpeg is not preinstalled on GitHub's ubuntu-24.04 runners. The producer
@@ -129,6 +131,72 @@ describe("resolveVideoExtractionDuration", () => {
     });
   });
 
+  it("extracts the source span a ramped slot consumes: 2s of 1x to 3x reads 2*(3-1)/ln 3 source seconds", () => {
+    const rate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 2, v: 3 },
+      ],
+    };
+    expect(
+      resolveVideoExtractionWindow(video({ end: 2, playbackRate: rate }), metadata(8), 2),
+    ).toMatchObject({ compositionStart: 0, mediaStart: 0, timelineDurationSeconds: 2 });
+    const { durationSeconds } = resolveVideoExtractionWindow(
+      video({ end: 2, playbackRate: rate }),
+      metadata(8),
+      2,
+    );
+    expect(durationSeconds).toBeCloseTo(3.6411, 3);
+  });
+
+  const RAMP = {
+    target: "rate",
+    points: [
+      { t: 0, v: 1 },
+      { t: 4, v: 3 },
+    ],
+  };
+
+  it("starts a ramped clip that begins before the timeline at the integrated source time of the trimmed part", () => {
+    // geometric 1x to 3x over 4s: source(t) = 4(3^(t/4)-1)/ln 3; 1s trimmed reads 1.1508, all 4s read 7.2819
+    const window = resolveVideoExtractionWindow(
+      video({ start: -1, end: 3, playbackRate: RAMP }),
+      metadata(20),
+      3,
+    );
+    expect(window.mediaStart).toBeCloseTo(1.1508, 3);
+    expect(window.durationSeconds).toBeCloseTo(6.1311, 3);
+  });
+
+  it("rebases a ramped clip so lookup reads the same source second the untrimmed lane would", () => {
+    const clip = video({ start: -1, end: 3, playbackRate: RAMP });
+    rebaseVideoToWindow(clip, resolveVideoExtractionWindow(clip, metadata(20), 3));
+    // composition second 2 is 3s into the authored lane: source 4.6586
+    const seconds = clip.mediaStart + sourceTimeAt(clip.playbackRate ?? 1, 2 - clip.start);
+    expect(seconds).toBeCloseTo(4.6586, 3);
+  });
+
+  it("snaps a float-noise composition start to the timeline origin so the first frame is kept", () => {
+    const clip = video({ start: -1, end: 8, playbackRate: 0.7 });
+    rebaseVideoToWindow(clip, { compositionStart: 2.2e-16, mediaStart: 0.7, durationSeconds: 5 });
+    expect(clip.start).toBe(0);
+  });
+
+  it("reports the natural timeline duration of a ramped clip through the lane", () => {
+    const flat = {
+      target: "rate",
+      points: [
+        { t: 0, v: 2 },
+        { t: 1, v: 2 },
+      ],
+    };
+    expect(resolveVideoExtractionWindow(video({ playbackRate: flat }), metadata(4))).toMatchObject({
+      durationSeconds: 4,
+      timelineDurationSeconds: 2,
+    });
+  });
+
   it("reports natural timeline duration after constant playback-rate retiming", () => {
     expect(
       resolveVideoExtractionWindow(video({ mediaStart: 1, playbackRate: 2 }), metadata(5), 10),
@@ -777,6 +845,26 @@ describe("parseVideoElements", () => {
     expect(invalid?.playbackRate).toBe(1);
   });
 
+  it("parses a rate lane from data-automation into the clip's rate", () => {
+    const automation = JSON.stringify({
+      version: 1,
+      lanes: [
+        {
+          target: "rate",
+          points: [
+            { t: 0, v: 1 },
+            { t: 2, v: 3 },
+          ],
+        },
+      ],
+    });
+    const [ramped] = parseVideoElements(
+      `<video id="ramped" src="clip.mp4" data-automation='${automation}'></video>`,
+    );
+
+    expect(ramped?.playbackRate).toMatchObject({ target: "rate" });
+  });
+
   it("parses videos without an id or data-start attribute", () => {
     const videos = parseVideoElements('<video src="clip.mp4"></video>');
 
@@ -2838,6 +2926,37 @@ describe("getFrameAtTime — IEEE 754 boundary precision", () => {
     } as ExtractedFrames;
   }
 
+  it("indexes frames by integrated source time for a rate lane", () => {
+    const extracted = { ...makeExtracted(25, 351), videoId: "ramped" } as ExtractedFrames;
+    const rate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 2, v: 3 },
+      ],
+    };
+    const table = new FrameLookupTable();
+    table.addVideo(extracted, 0, 10, 0, false, rate);
+    // 2s * (3-1)/ln 3 = 3.6411 source seconds * 25 fps = frame 91
+    expect(table.getFrame("ramped", 2)).toBe("frame-91.jpg");
+    expect(table.getFrame("ramped", 0)).toBe("frame-0.jpg");
+  });
+
+  it("wraps a ramped loop in source space so the lane keeps running across cycles", () => {
+    const extracted = { ...makeExtracted(25, 100), videoId: "looped" } as ExtractedFrames;
+    const rate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 4, v: 3 },
+      ],
+    };
+    const table = new FrameLookupTable();
+    table.addVideo(extracted, 0, 10, 0, true, rate);
+    // source(3) = 4.6586 on a 4s source wraps to 0.6586 * 25 fps = frame 16
+    expect(table.getFrame("looped", 3)).toBe("frame-16.jpg");
+  });
+
   it("does not produce duplicate frames when data-start is grid-aligned", () => {
     const extracted = makeExtracted(25, 351);
     const videoStart = 0;
diff --git a/packages/engine/src/services/videoFrameExtractor.ts b/packages/engine/src/services/videoFrameExtractor.ts
index b42c1f1015..04ece12c52 100644
--- a/packages/engine/src/services/videoFrameExtractor.ts
+++ b/packages/engine/src/services/videoFrameExtractor.ts
@@ -15,7 +15,12 @@ import {
   fpsToFfmpegArg,
   fpsToNumber,
   MEDIA_DURATION_CLAMP_EPSILON_SECONDS,
-  normalizePlaybackRate,
+  normalizeRateSpec,
+  readElementRateSpec,
+  shiftRateLane,
+  sourceTimeAt,
+  timeAtSourceTime,
+  type RateSpec,
   parseStrictFiniteTimingNumber,
   readMediaStart,
   toFps,
@@ -64,7 +69,7 @@ export interface VideoElement {
   start: number;
   end: number;
   mediaStart: number;
-  playbackRate?: number;
+  playbackRate?: RateSpec;
   loop: boolean;
   hasAudio: boolean;
 }
@@ -651,7 +656,6 @@ export function parseVideoElements(html: string): VideoElement[] {
     const startAttr = el.getAttribute("data-start");
     const endAttr = el.getAttribute("data-end");
     const durationAttr = el.getAttribute("data-duration");
-    const playbackRateAttr = el.getAttribute("data-playback-rate");
     const hasAudioAttr = el.getAttribute("data-has-audio");
 
     // Resolve data-start, including relative references ("intro", "intro + 2")
@@ -683,9 +687,7 @@ export function parseVideoElements(html: string): VideoElement[] {
       start,
       end,
       mediaStart: readMediaStart(el),
-      playbackRate: normalizePlaybackRate(
-        playbackRateAttr ? parseFloat(playbackRateAttr) : Number.NaN,
-      ),
+      playbackRate: readElementRateSpec(el),
       loop: el.hasAttribute("loop"),
       hasAudio: hasAudioAttr === "true",
     });
@@ -1031,6 +1033,19 @@ function canHoldFinalFramePastEof(video: TimelineWindowVideo): boolean {
 // one frame, while FFmpeg seeks to the separately probed real frame timestamp.
 const FINAL_FRAME_LOGICAL_DURATION_SECONDS = 1e-6;
 
+/** Move a clip to its extraction window; a rate lane is shifted so it keeps integrating from the new origin. */
+export function rebaseVideoToWindow(video: VideoElement, window: TimelineExtractionWindow): void {
+  if (window.preserveTimelinePhase) return;
+  // A trim landing on the timeline origin can come out as 1e-16 and drop the first frame.
+  const start = Math.abs(window.compositionStart) < 1e-9 ? 0 : window.compositionStart;
+  video.playbackRate = shiftRateLane(normalizeRateSpec(video.playbackRate), start - video.start);
+  video.start = start;
+  if (!window.preserveTimelineEnd) {
+    video.end = start + (window.timelineDurationSeconds ?? window.durationSeconds);
+  }
+  video.mediaStart = window.mediaStart;
+}
+
 /**
  * Intersect an authored slot with the render timeline, then select the
  * smallest playable source range that preserves timeline lookup semantics.
@@ -1047,7 +1062,7 @@ export function resolveTimelineExtractionWindow(
   timelineEnd?: number,
   sourceDuration?: number,
 ): TimelineExtractionWindow {
-  const playbackRate = normalizePlaybackRate(video.playbackRate ?? 1);
+  const playbackRate = normalizeRateSpec(video.playbackRate);
   const withTimelineDuration = (
     window: TimelineExtractionWindow,
     timelineDurationSeconds: number,
@@ -1058,7 +1073,7 @@ export function resolveTimelineExtractionWindow(
       {
         compositionStart: video.start,
         mediaStart: video.mediaStart,
-        durationSeconds: resolvedDuration * playbackRate,
+        durationSeconds: sourceTimeAt(playbackRate, resolvedDuration),
       },
       resolvedDuration,
     );
@@ -1068,14 +1083,17 @@ export function resolveTimelineExtractionWindow(
   }
   const compositionStart = Math.max(0, video.start);
   const trimmedPreroll = compositionStart - video.start;
-  const trimmedSourcePreroll = trimmedPreroll * playbackRate;
+  const trimmedSourcePreroll = sourceTimeAt(playbackRate, trimmedPreroll);
   const timelineDuration = Math.max(0, timelineEnd - compositionStart);
   // Infinity means "natural source duration", not an authored infinite slot.
   // Explicit finite slots may outlive the source (loop or held tail), while an
   // omitted duration remains source-bounded exactly like the browser runtime.
   const resolvedVisibleDuration = resolvedDuration - trimmedPreroll;
   const visibleDuration = Math.max(0, Math.min(resolvedVisibleDuration, timelineDuration));
-  const visibleSourceDuration = visibleDuration * playbackRate;
+  const visibleSourceDuration =
+    typeof playbackRate === "number"
+      ? visibleDuration * playbackRate
+      : sourceTimeAt(playbackRate, trimmedPreroll + visibleDuration) - trimmedSourcePreroll;
   let mediaStart = video.mediaStart + trimmedSourcePreroll;
   if (visibleDuration > 0 && sourceDuration !== undefined) {
     const sourceRemaining = Math.max(0, sourceDuration - video.mediaStart);
@@ -1121,7 +1139,7 @@ export function resolveTimelineExtractionWindow(
       const extractionOffset = sourceRemaining - extractionDuration;
       return withTimelineDuration(
         {
-          compositionStart: video.start + extractionOffset / playbackRate,
+          compositionStart: video.start + timeAtSourceTime(playbackRate, extractionOffset),
           mediaStart: video.mediaStart + extractionOffset,
           durationSeconds: extractionDuration,
           preserveTimelineEnd: true,
@@ -1220,12 +1238,14 @@ export function resolveVideoExtractionWindow(
       `Video media start ${video.mediaStart}s is outside playable video duration ${playableDuration}s`,
     );
   }
-  const playbackRate = normalizePlaybackRate(video.playbackRate ?? 1);
+  const playbackRate = normalizeRateSpec(video.playbackRate);
   const resolvedDuration =
     Number.isFinite(requestedTimelineDuration) && requestedTimelineDuration > 0
       ? requestedTimelineDuration
-      : resolveSegmentDuration(requestedTimelineDuration, video.mediaStart, playableDuration) /
-        playbackRate;
+      : timeAtSourceTime(
+          playbackRate,
+          resolveSegmentDuration(requestedTimelineDuration, video.mediaStart, playableDuration),
+        );
   return resolveTimelineExtractionWindow(
     video,
     resolvedDuration,
@@ -2079,13 +2099,7 @@ export async function extractAllVideoFrames(
         if (videoDuration <= 0) {
           return { skipped: true };
         }
-        if (!window.preserveTimelinePhase) {
-          video.start = window.compositionStart;
-          if (!window.preserveTimelineEnd) {
-            video.end = window.compositionStart + (window.timelineDurationSeconds ?? videoDuration);
-          }
-          video.mediaStart = window.mediaStart;
-        }
+        rebaseVideoToWindow(video, window);
         const keyInput = cacheKeyInputs[index];
         const extractionMediaStart = window.extractionMediaStart ?? window.mediaStart;
         if (keyInput) keyInput.mediaStart = extractionMediaStart;
@@ -2231,20 +2245,32 @@ function getFrameIndexAtTime(
   loop = false,
   mediaStart = 0,
   holdLastFrame = false,
-  playbackRate = 1,
+  playbackRate: RateSpec = 1,
 ): number | null {
   let localTime = globalTime - videoStart;
   if (localTime < 0) return null;
-  const normalizedPlaybackRate = normalizePlaybackRate(playbackRate);
-  const loopDuration =
-    Math.max(0, resolvePlayableVideoDuration(extracted.metadata) - mediaStart) /
-    normalizedPlaybackRate;
-  if (loop && loopDuration > 0 && localTime >= loopDuration) {
+  const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
+  const loopDuration = timeAtSourceTime(
+    normalizedPlaybackRate,
+    Math.max(0, resolvePlayableVideoDuration(extracted.metadata) - mediaStart),
+  );
+  if (
+    typeof normalizedPlaybackRate === "number" &&
+    loop &&
+    loopDuration > 0 &&
+    localTime >= loopDuration
+  ) {
     localTime %= loopDuration;
   }
+  let sourceTime = sourceTimeAt(normalizedPlaybackRate, localTime);
+  if (typeof normalizedPlaybackRate === "object" && loop) {
+    // A ramped loop wraps in source space, so the lane keeps running across cycles as in the preview.
+    const cycle = Math.max(0, resolvePlayableVideoDuration(extracted.metadata) - mediaStart);
+    if (cycle > 0 && sourceTime >= cycle) sourceTime %= cycle;
+  }
   // Add epsilon before flooring to avoid IEEE 754 boundary errors where
   // e.g. 0.28 * 25 === 6.999999999999999 instead of 7.
-  const frameIndex = Math.floor(localTime * normalizedPlaybackRate * extracted.fps + 1e-9);
+  const frameIndex = Math.floor(sourceTime * extracted.fps + 1e-9);
   if (frameIndex < 0 || extracted.totalFrames <= 0) return null;
   if (frameIndex >= extracted.totalFrames) {
     return loop || holdLastFrame ? extracted.totalFrames - 1 : null;
@@ -2295,7 +2321,7 @@ export class FrameLookupTable {
       end: number;
       mediaStart: number;
       loop: boolean;
-      playbackRate: number;
+      playbackRate: RateSpec;
     }
   > = new Map();
   private orderedVideos: Array<{
@@ -2305,7 +2331,7 @@ export class FrameLookupTable {
     end: number;
     mediaStart: number;
     loop: boolean;
-    playbackRate: number;
+    playbackRate: RateSpec;
   }> = [];
   private activeVideoIds: Set<string> = new Set();
   private startCursor = 0;
@@ -2317,7 +2343,7 @@ export class FrameLookupTable {
     end: number,
     mediaStart: number,
     loop = false,
-    playbackRate = 1,
+    playbackRate: RateSpec = 1,
   ): void {
     this.videos.set(extracted.videoId, {
       extracted,
@@ -2325,7 +2351,7 @@ export class FrameLookupTable {
       end,
       mediaStart,
       loop,
-      playbackRate: normalizePlaybackRate(playbackRate),
+      playbackRate: normalizeRateSpec(playbackRate),
     });
     this.orderedVideos = Array.from(this.videos.entries())
       .map(([videoId, video]) => ({ videoId, ...video }))
diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index 4bc79688d5..5d5e7ee424 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -29,6 +29,7 @@ import {
   rewriteAssetPaths,
   rewriteCssAssetUrls,
   rewriteInlineStyleAssetUrls,
+  type RateSpec,
   type ResolvedDuration,
   type UnresolvedElement,
 } from "@hyperframes/core";
@@ -425,7 +426,7 @@ export function detectShaderTransitionUsage(html: string): boolean {
 async function resolveMediaDuration(
   src: string,
   mediaStart: number,
-  playbackRate: number,
+  playbackRate: RateSpec,
   baseDir: string,
   downloadDir: string,
   tagName: string,
diff --git a/packages/producer/src/services/render/videoFrameCoverage.ts b/packages/producer/src/services/render/videoFrameCoverage.ts
index d31e5aa9db..abdc646585 100644
--- a/packages/producer/src/services/render/videoFrameCoverage.ts
+++ b/packages/producer/src/services/render/videoFrameCoverage.ts
@@ -45,7 +45,13 @@
  */
 
 import { parseHTML } from "linkedom";
-import { fpsToNumber, normalizePlaybackRate, toFps, type FpsInput } from "@hyperframes/core";
+import {
+  fpsToNumber,
+  normalizeRateSpec,
+  sourceTimeAt,
+  toFps,
+  type FpsInput,
+} from "@hyperframes/core";
 import {
   extractionFrameCountForDuration,
   resolvePlayableVideoDuration,
@@ -166,8 +172,10 @@ function expectedFramesForVideo(
   fps: FpsInput,
 ): number {
   const rounding = entry && !entry.metadata.isVFR ? "nearest" : "ceil";
-  const playbackRate = normalizePlaybackRate(video.playbackRate ?? 1);
-  const slotSourceDuration = Math.max(0, video.end - video.start) * playbackRate;
+  const slotSourceDuration = sourceTimeAt(
+    normalizeRateSpec(video.playbackRate),
+    Math.max(0, video.end - video.start),
+  );
   const slotFrames = expectedFramesForClip(0, slotSourceDuration, fps, rounding);
   if (!entry) return slotFrames;
 
diff --git a/packages/producer/tests/shard-schedule.json b/packages/producer/tests/shard-schedule.json
index 16cc22f035..01a87918cb 100644
--- a/packages/producer/tests/shard-schedule.json
+++ b/packages/producer/tests/shard-schedule.json
@@ -35,6 +35,7 @@
     "raf-ball-render-compat": 22,
     "render-symlinked-assets": 6,
     "static-volume-future-set": 120,
+    "speed-ramp": 20,
     "static-dedup-nested-visibility": 8,
     "style-1-prod": 156,
     "style-10-prod": 232,
diff --git a/packages/producer/tests/speed-ramp/meta.json b/packages/producer/tests/speed-ramp/meta.json
new file mode 100644
index 0000000000..5f823518fd
--- /dev/null
+++ b/packages/producer/tests/speed-ramp/meta.json
@@ -0,0 +1,15 @@
+{
+  "name": "Speed ramp",
+  "description": "A video and an audio clip carry the same rate lane (1x to 4x to 0.5x). Frames and audio must follow the integrated source time, not a constant rate.",
+  "tags": ["speed-ramp", "video", "audio", "regression"],
+
+  "minPsnr": 30,
+  "maxFrameFailures": 0,
+
+  "minAudioCorrelation": 0.9,
+  "maxAudioLagWindows": 120,
+
+  "renderConfig": {
+    "fps": 30
+  }
+}
diff --git a/packages/producer/tests/speed-ramp/output/compiled.html b/packages/producer/tests/speed-ramp/output/compiled.html
new file mode 100644
index 0000000000..c8603efc37
--- /dev/null
+++ b/packages/producer/tests/speed-ramp/output/compiled.html
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a57005fa99beb428b604d59d460e42751b0b693dda9e5c9919939456799c4e56
+size 1538
diff --git a/packages/producer/tests/speed-ramp/output/output.mp4 b/packages/producer/tests/speed-ramp/output/output.mp4
new file mode 100644
index 0000000000..9372ed20ae
--- /dev/null
+++ b/packages/producer/tests/speed-ramp/output/output.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffc894beb65de635d6e19a083af3937bab55864ddfb6746edabe4272ae12f68b
+size 283643
diff --git a/packages/producer/tests/speed-ramp/src/assets/counter.mp4 b/packages/producer/tests/speed-ramp/src/assets/counter.mp4
new file mode 100644
index 0000000000..456257083b
--- /dev/null
+++ b/packages/producer/tests/speed-ramp/src/assets/counter.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1467134ba4c95ed21541c4fc50ead4755e39f6c25292b8bc1976e19e21b67829
+size 69954
diff --git a/packages/producer/tests/speed-ramp/src/assets/sweep.wav b/packages/producer/tests/speed-ramp/src/assets/sweep.wav
new file mode 100644
index 0000000000..3b9356af98
Binary files /dev/null and b/packages/producer/tests/speed-ramp/src/assets/sweep.wav differ
diff --git a/packages/producer/tests/speed-ramp/src/index.html b/packages/producer/tests/speed-ramp/src/index.html
new file mode 100644
index 0000000000..9de37fdf0e
--- /dev/null
+++ b/packages/producer/tests/speed-ramp/src/index.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=640, height=360" />
+  <title>Speed ramp</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { overflow: hidden; background: #111; }
+    #counter { position: absolute; inset: 0; width: 640px; height: 360px; object-fit: cover; }
+  </style>
+</head>
+<body>
+  <div id="root" data-composition-id="speed-ramp" data-start="0" data-duration="4" data-width="640" data-height="360" data-fps="30">
+    <video id="counter" src="assets/counter.mp4" data-start="0" data-duration="4" muted playsinline
+      data-automation='{"version":1,"lanes":[{"target":"rate","points":[{"t":0,"v":1},{"t":2,"v":4},{"t":4,"v":0.5}]}]}'></video>
+    <audio id="sweep" src="assets/sweep.wav" data-start="0" data-duration="4" data-volume="1"
+      data-automation='{"version":1,"lanes":[{"target":"rate","points":[{"t":0,"v":1},{"t":2,"v":4},{"t":4,"v":0.5}]}]}'></audio>
+  </div>
+  <script>window.__timelines = window.__timelines || {}; window.__timelines["speed-ramp"] = { duration: () => 4, time: () => 0, seek() {}, pause() {}, paused: () => true };</script>
+</body>
+</html>