@@ -36,6 +36,7 @@ describe("discoverMediaFromBrowser", () => {
     currentSrcById: Record<string, string>,
     serializeCallback = false,
     intrinsicDurationById: Record<string, number> = {},
+    defaultPlaybackRateById: Record<string, number> = {},
   ) {
     const { document } = parseHTML(html);
     for (const [id, currentSrc] of Object.entries(currentSrcById)) {
@@ -46,6 +47,13 @@ describe("discoverMediaFromBrowser", () => {
       const element = document.getElementById(id);
       if (element) Object.defineProperty(element, "duration", { value: duration });
     }
+    for (const [id, defaultPlaybackRate] of Object.entries(defaultPlaybackRateById)) {
+      const element = document.getElementById(id);
+      if (element) {
+        Object.defineProperty(element, "defaultPlaybackRate", { value: defaultPlaybackRate });
+        Object.defineProperty(element, "playbackRate", { value: defaultPlaybackRate * 2 });
+      }
+    }
     const previousDocument = Reflect.get(globalThis, "document");
     Reflect.set(globalThis, "document", document);
     try {
@@ -129,6 +137,22 @@ describe("discoverMediaFromBrowser", () => {
     expect(media[0]).toMatchObject({ start: 0, end: 2, duration: 2, mediaStart: 1 });
   });
 
+  it("reads authored rates and native defaults after the browser callback is serialized", async () => {
+    const media = await discover(
+      `<video id="authored" src="clip.mp4" data-start="0" data-duration="2" data-playback-rate="1.5"></video>
+       <audio id="native" src="clip.wav" data-start="0" data-duration="2"></audio>
+       <video id="invalid" src="clip.mp4" data-start="0" data-duration="2" data-playback-rate="0"></video>
+       <audio id="bounded" src="clip.wav" data-start="0" data-duration="2" data-playback-rate="20"></audio>
+       <video id="default" src="clip.mp4" data-start="0" data-duration="2"></video>`,
+      {},
+      true,
+      {},
+      { authored: 0.5, native: 0.5, invalid: 1.25 },
+    );
+
+    expect(media.map((element) => element.playbackRate)).toEqual([1.5, 0.5, 1.25, 10, 1]);
+  });
+
   it("reports colliding empty-src videos by render id, not author id", async () => {
     const media = await discover(
       `<video id="clip" data-hf-render-id="clip" src="" data-start="0" data-end="4" data-media-start="10"></video>` +
 
@@ -36,6 +36,7 @@ import {
   type UnresolvedElement,
 } from "@hyperframes/core";
 import { MAX_AUDIO_GAIN } from "@hyperframes/core/audio-gain";
+import { readPlaybackRate } from "@hyperframes/parsers/media-duration";
 import { gsapCdnDist } from "@hyperframes/core/gsap-cdn";
 import {
   assignBundledRuntimeCompositionIds,
@@ -2235,6 +2236,7 @@ export interface BrowserMediaElement {
   /** True when compilation inferred duration from the fallback source. */
   durationInferred: boolean;
   mediaStart: number;
+  playbackRate: number;
   loop: boolean;
   hasAudio: boolean;
   volume: number;
@@ -2260,6 +2262,8 @@ export async function discoverMediaFromBrowser(page: Page): Promise<BrowserMedia
       durationInferred: boolean;
       playbackStartRaw: string | null;
       mediaStartRaw: string | null;
+      playbackRateRaw: string | null;
+      defaultPlaybackRate: number;
       loop: boolean;
       hasAudio: boolean;
       volume: number;
@@ -2310,6 +2314,11 @@ export async function discoverMediaFromBrowser(page: Page): Promise<BrowserMedia
         : (htmlEl as HTMLVideoElement | HTMLAudioElement).duration;
       const playbackStartRaw = htmlEl.getAttribute("data-playback-start");
       const mediaStartRaw = htmlEl.getAttribute("data-media-start");
+      const playbackRateRaw = htmlEl.getAttribute("data-playback-rate");
+      // playbackRate can include the transport speed; defaultPlaybackRate is the clip's own rate.
+      const defaultPlaybackRate = isImage
+        ? 1
+        : (htmlEl as HTMLVideoElement | HTMLAudioElement).defaultPlaybackRate;
       const loop = htmlEl.hasAttribute("loop");
       const hasAudio = htmlEl.getAttribute("data-has-audio") === "true";
       const volume = parseFloat(htmlEl.getAttribute("data-volume") || "1");
@@ -2328,6 +2337,8 @@ export async function discoverMediaFromBrowser(page: Page): Promise<BrowserMedia
         durationInferred,
         playbackStartRaw,
         mediaStartRaw,
+        playbackRateRaw,
+        defaultPlaybackRate,
         loop,
         hasAudio,
         volume,
@@ -2339,7 +2350,16 @@ export async function discoverMediaFromBrowser(page: Page): Promise<BrowserMedia
   });
 
   return elements.map(
-    ({ endRaw, durationRaw, intrinsicDuration, playbackStartRaw, mediaStartRaw, ...element }) => ({
+    ({
+      endRaw,
+      durationRaw,
+      intrinsicDuration,
+      playbackStartRaw,
+      mediaStartRaw,
+      playbackRateRaw,
+      defaultPlaybackRate,
+      ...element
+    }) => ({
       ...element,
       end: parseStrictFiniteTimingNumber(endRaw) ?? 0,
       duration:
@@ -2353,6 +2373,10 @@ export async function discoverMediaFromBrowser(page: Page): Promise<BrowserMedia
           return null;
         },
       }),
+      playbackRate: readPlaybackRate(
+        (name) => (name === "data-playback-rate" ? playbackRateRaw : null),
+        defaultPlaybackRate,
+      ),
     }),
   );
 }
 
@@ -105,6 +105,34 @@ describe("appendAutoDetectedVideoAudio", () => {
     });
   });
 
+  it.each([
+    1.5,
+    {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 3, v: 2 },
+      ],
+    },
+  ] satisfies NonNullable<VideoElement["playbackRate"]>[])(
+    "keeps the video's rate and trim in its detected audio (%j)",
+    (playbackRate) => {
+      const composition: Parameters<typeof appendAutoDetectedVideoAudio>[0] = {
+        videos: [makeVideo({ start: 2, end: 5, mediaStart: 0.5, playbackRate })],
+        audios: [],
+      };
+
+      appendAutoDetectedVideoAudio(composition, [makeExtracted("v1", true)]);
+
+      expect(composition.audios[0]).toMatchObject({
+        start: 2,
+        end: 5,
+        mediaStart: 0.5,
+        playbackRate,
+      });
+    },
+  );
+
   it("skips a muted video even when the source file has audio", () => {
     const composition = {
       videos: [makeVideo({ hasAudio: false })],
 
@@ -578,6 +578,7 @@ export function appendAutoDetectedVideoAudio(
       start: video.start,
       end: video.end,
       mediaStart: video.mediaStart,
+      playbackRate: video.playbackRate,
       layer: 0,
       volume: 1.0,
       type: "video",
 
@@ -2,6 +2,7 @@ import { afterAll, describe, expect, it, mock } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { RateSpec } from "@hyperframes/core";
 
 const workDir = mkdtempSync(join(tmpdir(), "hf-stage-test-"));
 afterAll(() => rmSync(workDir, { recursive: true, force: true }));
@@ -413,6 +414,99 @@ describe("runProbeStage — forceScreenshot threading", () => {
   });
 
   // Scene in-point 5 and clip trim 1: the collector starts picture and sound at source 6.
+  it.each([
+    { tagName: "video", existing: false },
+    { tagName: "audio", existing: false },
+    { tagName: "video", existing: true },
+    { tagName: "audio", existing: true },
+  ])("retains a runtime $tagName rate (existing: $existing)", async ({ tagName, existing }) => {
+    resetRetryMocks();
+    browserMediaResults = [
+      {
+        id: "clip",
+        tagName,
+        src: "clip.mp4",
+        start: 0,
+        end: 3,
+        duration: 3,
+        mediaStart: 0.5,
+        playbackRate: 1.5,
+        loop: false,
+        hasAudio: true,
+        volume: 1,
+        muted: false,
+      },
+    ];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    const clip = {
+      id: "clip",
+      src: "clip.mp4",
+      start: 0,
+      end: 3,
+      mediaStart: 0.5,
+      playbackRate: 1,
+    };
+    if (existing && tagName === "video") {
+      input.composition.videos.push({ ...clip, loop: false, hasAudio: true });
+      input.composition.audios.push({ ...clip, id: "clip-audio", layer: 0, type: "video" });
+    }
+    if (existing && tagName === "audio") {
+      input.composition.audios.push({ ...clip, layer: 0, type: "audio" });
+    }
+
+    await runProbeStage(input);
+
+    const media = tagName === "video" ? input.composition.videos : input.composition.audios;
+    expect(media[0]).toMatchObject({ playbackRate: 1.5, mediaStart: 0.5 });
+    if (existing && tagName === "video") {
+      expect(input.composition.audios[0]).toMatchObject({ playbackRate: 1.5, mediaStart: 0.5 });
+    }
+  });
+
+  it("preserves a collected speed ramp during scalar browser reconciliation", async () => {
+    resetRetryMocks();
+    browserMediaResults = [
+      {
+        id: "clip",
+        tagName: "video",
+        src: "clip.mp4",
+        start: 0,
+        end: 3,
+        duration: 3,
+        mediaStart: 0,
+        playbackRate: 1,
+        loop: false,
+        hasAudio: false,
+        volume: 1,
+        muted: false,
+      },
+    ];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    const playbackRate = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 3, v: 2 },
+      ],
+    } satisfies RateSpec;
+    input.composition.videos.push({
+      id: "clip",
+      src: "clip.mp4",
+      start: 0,
+      end: 3,
+      mediaStart: 0,
+      playbackRate,
+      loop: false,
+      hasAudio: false,
+    });
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]?.playbackRate).toEqual(playbackRate);
+  });
+
   it.each([
     { pageStart: 1, expected: 6 },
     { pageStart: 3, expected: 8 },
 
@@ -599,6 +599,19 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart,
                 );
+                // A collected rate lane already includes scene trimming; retain its phase.
+                if (typeof existing.playbackRate !== "object") {
+                  existing.playbackRate = el.playbackRate;
+                  for (const audio of composition.audios) {
+                    if (
+                      audio.type === "video" &&
+                      audio.id === `${el.id}-audio` &&
+                      typeof audio.playbackRate !== "object"
+                    ) {
+                      audio.playbackRate = el.playbackRate;
+                    }
+                  }
+                }
                 if (el.hasAudio && !el.muted && !existing.hasAudio) {
                   existing.hasAudio = true;
                 }
@@ -614,6 +627,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                 start: el.start,
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
+                playbackRate: el.playbackRate,
                 loop: el.loop,
                 hasAudio: el.hasAudio && !el.muted,
               });
@@ -644,6 +658,9 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart,
                 );
+                if (typeof existing.playbackRate !== "object") {
+                  existing.playbackRate = el.playbackRate;
+                }
                 if (
                   el.volume > 0 &&
                   Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON
@@ -658,6 +675,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                 start: el.start,
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
+                playbackRate: el.playbackRate,
                 layer: 0,
                 volume: el.volume,
                 type: "audio",