diff --git a/packages/core/src/compiler/index.ts b/packages/core/src/compiler/index.ts
index ca49e97f073..8cfa872eb4d 100644
--- a/packages/core/src/compiler/index.ts
+++ b/packages/core/src/compiler/index.ts
@@ -16,12 +16,14 @@ export {
   injectDurations,
   extractResolvedMedia,
   clampDurations,
+  extendVideoSlotEnds,
   shouldClampMediaDuration,
   shouldClampResolvedMediaDuration,
   type UnresolvedElement,
   type ResolvedDuration,
   type ResolvedMediaElement,
   type CompilationResult,
+  type VideoSlotEnd,
 } from "./timingCompiler";
 
 // HTML compiler (Node.js — requires fs)
diff --git a/packages/core/src/compiler/timingCompiler.test.ts b/packages/core/src/compiler/timingCompiler.test.ts
index 13f73fe0c8b..aae133f2e69 100644
--- a/packages/core/src/compiler/timingCompiler.test.ts
+++ b/packages/core/src/compiler/timingCompiler.test.ts
@@ -7,6 +7,7 @@ import {
   injectDurations,
   extractResolvedMedia,
   clampDurations,
+  extendVideoSlotEnds,
   shouldClampResolvedMediaDuration,
 } from "./timingCompiler.js";
 
@@ -474,6 +475,28 @@ describe("extractResolvedMedia", () => {
   });
 });
 
+describe("extendVideoSlotEnds", () => {
+  it("keeps data-start and stretches a file-bounded data-duration past source EOF", () => {
+    const html = extendVideoSlotEnds(
+      `<video id="wrap" src="wrap.mp4" data-start="13" data-end="18.2" data-duration="5.2" data-hf-auto-start=""></video>`,
+      [{ id: "wrap", end: 19, duration: 6 }],
+    );
+    expect(html).toContain('data-start="13"');
+    expect(html).toContain('data-end="19"');
+    expect(html).toContain('data-duration="6"');
+    expect(html).not.toContain("data-media-start");
+  });
+
+  it("does not rewrite a video mentioned only in a comment", () => {
+    const html = extendVideoSlotEnds(
+      `<!-- <video id="wrap" data-duration="5.2" data-end="18.2"> --><video id="wrap" data-start="13" data-end="18.2" data-duration="5.2"></video>`,
+      [{ id: "wrap", end: 19, duration: 6 }],
+    );
+    expect(html).toContain(`<!-- <video id="wrap" data-duration="5.2" data-end="18.2"> -->`);
+    expect(html).toContain('data-duration="6"');
+  });
+});
+
 describe("clampDurations", () => {
   it("replaces data-duration and recomputes data-end", () => {
     const html = '<video id="v1" src="a.mp4" data-start="2" data-duration="10" data-end="12">';
diff --git a/packages/core/src/compiler/timingCompiler.ts b/packages/core/src/compiler/timingCompiler.ts
index 5150ec8bdf0..94dfd4f85da 100644
--- a/packages/core/src/compiler/timingCompiler.ts
+++ b/packages/core/src/compiler/timingCompiler.ts
@@ -26,6 +26,7 @@ import {
   readMediaStart,
 } from "../runtime/playbackRate.js";
 import type { RateSpec } from "../speedRamp.js";
+import { MEDIA_RENDER_ID_ATTR } from "./mediaRenderIds.js";
 // ── Types ────────────────────────────────────────────────────────────────
 
 export interface UnresolvedElement {
@@ -337,6 +338,32 @@ export function extractResolvedMedia(html: string): ResolvedMediaElement[] {
   return resolved;
 }
 
+export type VideoSlotEnd = {
+  id: string;
+  end: number;
+  duration: number;
+};
+
+/**
+ * Stretch a compiled video's `data-end` / `data-duration` to an out-point
+ * past the source file (opacity hold). Leaves `data-start` / `data-media-start`.
+ */
+export function extendVideoSlotEnds(html: string, slots: readonly VideoSlotEnd[]): string {
+  if (slots.length === 0) return html;
+  const byId = new Map(slots.map((slot) => [slot.id, slot]));
+  return replaceOpeningTags(html, ["video"], (tag) => {
+    const id = getAttr(tag, MEDIA_RENDER_ID_ATTR) ?? getAttr(tag, "id");
+    if (!id) return tag;
+    const slot = byId.get(id);
+    if (!slot || !Number.isFinite(slot.end) || !(slot.duration > 0)) return tag;
+    return setAttr(
+      setAttr(tag, "data-end", String(slot.end)),
+      "data-duration",
+      String(slot.duration),
+    );
+  });
+}
+
 /**
  * Clamp existing data-duration and data-end on media elements.
  * For each resolution, replaces the declared duration with the clamped value
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 9fc953aa89a..f69de69c310 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -149,9 +149,11 @@ export {
   injectDurations,
   extractResolvedMedia,
   clampDurations,
+  extendVideoSlotEnds,
   shouldClampMediaDuration,
   shouldClampResolvedMediaDuration,
   MEDIA_DURATION_CLAMP_EPSILON_SECONDS,
+  type VideoSlotEnd,
 } from "./compiler/timingCompiler";
 
 export {
diff --git a/packages/producer/src/services/htmlCompiler.test.ts b/packages/producer/src/services/htmlCompiler.test.ts
index 29d2334bdc0..9c63ca24408 100644
--- a/packages/producer/src/services/htmlCompiler.test.ts
+++ b/packages/producer/src/services/htmlCompiler.test.ts
@@ -2686,25 +2686,29 @@ describe("resolveCompositionDurations strict literal timing", () => {
 });
 
 describe("discoverVideoVisibilityFromTimeline", () => {
-  it("returns scene visibility windows for auto-start videos", async () => {
-    const duration = 2;
-    const sampleStep = 0.1;
-    const windows = [
-      { id: "v0", start: 0.2, end: 0.7 },
-      { id: "v1", start: 0.5, end: 1.2 },
-      { id: "v2", start: 1.0, end: 1.8 },
-      { id: "v3", start: 0.0, end: 0.4 },
-    ];
-
-    type SceneEl = { opacityAt: (t: number) => number };
+  type OpacityEl = {
+    id?: string;
+    opacityAt: (t: number) => number;
+    parentElement: OpacityEl | null;
+  };
+
+  async function runVisibilityProbe(
+    windows: { id: string; start: number; end: number }[],
+    duration: number,
+    sceneOpacity = 1,
+    hfSeek?: (t: number) => void,
+  ) {
     const videos = windows.map((win) => {
-      const sceneEl: SceneEl = {
-        opacityAt: (t) => (t >= win.start && t <= win.end ? 1 : 0),
+      const sceneEl: OpacityEl = {
+        opacityAt: () => sceneOpacity,
+        parentElement: null,
       };
-      return {
+      const videoEl: OpacityEl = {
         id: win.id,
-        closest: (selector: string) => (selector === ".scene" ? sceneEl : null),
+        opacityAt: (t) => (t >= win.start && t <= win.end ? 1 : 0),
+        parentElement: sceneEl,
       };
+      return videoEl;
     });
 
     let currentTime = 0;
@@ -2712,6 +2716,16 @@ describe("discoverVideoVisibilityFromTimeline", () => {
     const previousDocument = globalThis.document;
 
     globalThis.window = {
+      ...(hfSeek
+        ? {
+            __hf: {
+              seek: (time: number) => {
+                currentTime = time;
+                hfSeek(time);
+              },
+            },
+          }
+        : {}),
       __timelines: {
         root: {
           totalTime: (time: number) => {
@@ -2719,7 +2733,7 @@ describe("discoverVideoVisibilityFromTimeline", () => {
           },
         },
       },
-      getComputedStyle: (el: SceneEl) => ({
+      getComputedStyle: (el: OpacityEl) => ({
         opacity: String(el.opacityAt(currentTime)),
       }),
     } as typeof globalThis.window;
@@ -2736,22 +2750,52 @@ describe("discoverVideoVisibilityFromTimeline", () => {
       const page = {
         evaluate: async (fn: (arg: number) => unknown, arg: number) => fn(arg),
       };
-
-      const result = await discoverVideoVisibilityFromTimeline(page as never, duration);
-
-      expect(result).toHaveLength(windows.length);
-      for (const win of windows) {
-        const found = result.find((entry) => entry.videoId === win.id);
-        expect(found).toBeDefined();
-        expect(found!.visibleStart).toBeGreaterThanOrEqual(win.start - sampleStep);
-        expect(found!.visibleStart).toBeLessThanOrEqual(win.start + sampleStep);
-        expect(found!.visibleEnd).toBeGreaterThanOrEqual(win.end - sampleStep);
-        expect(found!.visibleEnd).toBeLessThanOrEqual(win.end + sampleStep);
-      }
+      return await discoverVideoVisibilityFromTimeline(page as never, duration);
     } finally {
       globalThis.window = previousWindow;
       globalThis.document = previousDocument;
     }
+  }
+
+  it("returns video effective-opacity windows for auto-start videos", async () => {
+    const duration = 2;
+    const sampleStep = 0.1;
+    const windows = [
+      { id: "v0", start: 0.2, end: 0.7 },
+      { id: "v1", start: 0.5, end: 1.2 },
+      { id: "v2", start: 1.0, end: 1.8 },
+      { id: "v3", start: 0.0, end: 0.4 },
+    ];
+
+    const result = await runVisibilityProbe(windows, duration);
+
+    expect(result).toHaveLength(windows.length);
+    for (const win of windows) {
+      const found = result.find((entry) => entry.videoId === win.id);
+      expect(found).toBeDefined();
+      expect(found!.visibleStart).toBeGreaterThanOrEqual(win.start - sampleStep);
+      expect(found!.visibleStart).toBeLessThanOrEqual(win.start + sampleStep);
+      expect(found!.visibleEnd).toBeGreaterThanOrEqual(win.end - sampleStep);
+      expect(found!.visibleEnd).toBeLessThanOrEqual(win.end + sampleStep);
+    }
+  });
+
+  it("does not treat a fully-opaque .scene as the video window", async () => {
+    const result = await runVisibilityProbe([{ id: "clip", start: 0.8, end: 1.4 }], 2, 1);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.videoId).toBe("clip");
+    expect(result[0]!.visibleStart).toBeGreaterThan(0.6);
+    expect(result[0]!.visibleStart).toBeLessThanOrEqual(0.9);
+    expect(result[0]!.visibleEnd).toBeGreaterThanOrEqual(1.3);
+    expect(result[0]!.visibleEnd).toBeLessThanOrEqual(1.5);
+  });
+
+  it("prefers window.__hf.seek so nested GSAP updates", async () => {
+    const sought: number[] = [];
+    await runVisibilityProbe([{ id: "clip", start: 0.5, end: 1.2 }], 2, 1, (t) => {
+      sought.push(t);
+    });
+    expect(sought.length).toBeGreaterThan(0);
   });
 });
 describe("sub-composition variable injection (render path, #2064)", () => {
diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index 1dbc2d211fa..10f5bf76bff 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -2606,8 +2606,10 @@ export interface VideoVisibilityWindow {
 }
 
 /**
- * Seek the GSAP timeline to discover when each video's parent scene is visible.
- * Only processes videos with the data-hf-auto-start sentinel (auto-injected timing).
+ * Seek the composition and discover when each auto-start video is visible.
+ * Visibility is the video's effective opacity (element × ancestors), not `.scene`.
+ * Prefers `window.__hf.seek` so nested scene GSAP (paused sibling timelines)
+ * actually updates — root `totalTime` does not propagate to them.
  */
 export async function discoverVideoVisibilityFromTimeline(
   page: Page,
@@ -2620,6 +2622,11 @@ export async function discoverVideoVisibilityFromTimeline(
     const videos = document.querySelectorAll("video[data-hf-auto-start]");
     if (videos.length === 0) return results;
 
+    const hfSeek = (
+      window as unknown as {
+        __hf?: { seek?: (t: number, o?: { suppressEvents?: boolean }) => void };
+      }
+    ).__hf?.seek;
     const timelines = (window as unknown as { __timelines?: Record<string, unknown> }).__timelines;
     if (!timelines) return results;
 
@@ -2643,14 +2650,35 @@ export async function discoverVideoVisibilityFromTimeline(
       }
     };
 
+    const seekComposition = (t: number) => {
+      if (typeof hfSeek === "function") {
+        try {
+          hfSeek(t, { suppressEvents: true });
+        } catch {}
+        return;
+      }
+      seekTl(t);
+    };
+
+    // Same walk as videoFrameInjector: GSAP often animates a wrapper, not the
+    // <video>. `val || 1` would turn opacity:0 into 1.
+    const getEffectiveOpacity = (node: Element): number => {
+      let opacity = 1;
+      let current: Element | null = node;
+      while (current) {
+        const val = parseFloat(window.getComputedStyle(current).opacity);
+        opacity *= Number.isNaN(val) ? 1 : val;
+        current = current.parentElement;
+      }
+      return opacity;
+    };
+
     const SAMPLE_STEP = 0.1;
     const BINARY_PRECISION = 1 / 60;
 
-    // Seek once per timestep and sample every video — seeking dominates and is
-    // independent of which element we read.
     const entries: {
       id: string;
-      sceneEl: Element;
+      videoEl: Element;
       firstVisible: number | null;
       lastVisible: number | null;
     }[] = [];
@@ -2659,7 +2687,7 @@ export async function discoverVideoVisibilityFromTimeline(
       if (!id) continue;
       entries.push({
         id,
-        sceneEl: videoEl.closest(".scene") || videoEl,
+        videoEl,
         firstVisible: null,
         lastVisible: null,
       });
@@ -2667,41 +2695,35 @@ export async function discoverVideoVisibilityFromTimeline(
     if (entries.length === 0) return results;
 
     for (let t = 0; t <= duration; t += SAMPLE_STEP) {
-      seekTl(t);
+      seekComposition(t);
       for (const entry of entries) {
-        const opacity = parseFloat(window.getComputedStyle(entry.sceneEl).opacity);
-        if (opacity > 0) {
+        if (getEffectiveOpacity(entry.videoEl) > 0) {
           if (entry.firstVisible === null) entry.firstVisible = t;
           entry.lastVisible = t;
         }
       }
     }
 
-    // Per-video boundary refinement (cheap: O(log(step)) seeks each).
     for (const entry of entries) {
-      const { id, sceneEl, firstVisible, lastVisible } = entry;
+      const { id, videoEl, firstVisible, lastVisible } = entry;
       if (firstVisible === null || lastVisible === null) continue;
 
-      // Binary search left boundary
       let lo = Math.max(0, firstVisible - SAMPLE_STEP);
       let hi = firstVisible;
       while (hi - lo > BINARY_PRECISION) {
         const mid = (lo + hi) / 2;
-        seekTl(mid);
-        const opacity = parseFloat(window.getComputedStyle(sceneEl).opacity);
-        if (opacity > 0) hi = mid;
+        seekComposition(mid);
+        if (getEffectiveOpacity(videoEl) > 0) hi = mid;
         else lo = mid;
       }
       const exactStart = hi;
 
-      // Binary search right boundary
       lo = lastVisible;
       hi = Math.min(duration, lastVisible + SAMPLE_STEP);
       while (hi - lo > BINARY_PRECISION) {
         const mid = (lo + hi) / 2;
-        seekTl(mid);
-        const opacity = parseFloat(window.getComputedStyle(sceneEl).opacity);
-        if (opacity > 0) lo = mid;
+        seekComposition(mid);
+        if (getEffectiveOpacity(videoEl) > 0) lo = mid;
         else hi = mid;
       }
       const exactEnd = lo;
@@ -2713,7 +2735,7 @@ export async function discoverVideoVisibilityFromTimeline(
       });
     }
 
-    seekTl(0);
+    seekComposition(0);
     return results;
   }, compositionDuration);
 }
diff --git a/packages/producer/src/services/render/stages/probeStage.test.ts b/packages/producer/src/services/render/stages/probeStage.test.ts
index cbd1a105d0e..25af34fb0c3 100644
--- a/packages/producer/src/services/render/stages/probeStage.test.ts
+++ b/packages/producer/src/services/render/stages/probeStage.test.ts
@@ -14,6 +14,7 @@ import { collectRenderMedia } from "../../renderMediaCollector.js";
 const workDir = mkdtempSync(join(tmpdir(), "hf-stage-test-"));
 afterAll(() => rmSync(workDir, { recursive: true, force: true }));
 import { createHash } from "node:crypto";
+import { shiftRateLane, sourceTimeAt } from "@hyperframes/core";
 import {
   hasAutoStartVideos,
   hasScriptedAudioVolumeAutomation,
@@ -33,6 +34,7 @@ let mediaPreflightComposition: unknown;
 let afterMediaPreflight: (() => void) | null = null;
 let fileServerCloseCallCount = 0;
 let browserMediaResults: unknown[] = [];
+let visibilityWindows: { videoId: string; visibleStart: number; visibleEnd: number }[] = [];
 
 type MockSession = {
   id: number;
@@ -91,6 +93,7 @@ function resetRetryMocks() {
   afterMediaPreflight = null;
   fileServerCloseCallCount = 0;
   browserMediaResults = [];
+  visibilityWindows = [];
 }
 
 mock.module("../../assetMediaType.js", () => ({
@@ -200,7 +203,7 @@ mock.module("../../fileServer.js", () => ({
 mock.module("../../htmlCompiler.js", () => ({
   discoverMediaFromBrowser: async () => browserMediaResults,
   discoverAudioVolumeAutomationFromTimeline: async () => [],
-  discoverVideoVisibilityFromTimeline: async () => [],
+  discoverVideoVisibilityFromTimeline: async () => visibilityWindows,
   recompileWithResolutions: async (c: unknown) => c,
   resolveCompositionDurations: async () => [],
 }));
@@ -923,6 +926,205 @@ describe("runProbeStage — forceScreenshot threading", () => {
     },
   );
 
+  it("binds authored mediaStart to the visibility window, not scene start", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3.5, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 3,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({
+        id: "clip",
+        start: 3.5,
+        end: 6,
+        mediaStart: 3,
+      }),
+    );
+  });
+
+  it("shifts auto-start mediaStart when visibility raises start", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3.5, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 0,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({
+        id: "clip",
+        start: 3.5,
+        end: 6,
+        mediaStart: 1.5,
+      }),
+    );
+  });
+
+  it("shifts auto-start mediaStart by the source time a sped-up clip played", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3.5, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 0,
+      playbackRate: 2,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({ id: "clip", start: 3.5, end: 6, mediaStart: 3, playbackRate: 2 }),
+    );
+  });
+
+  it("shifts a rate lane to the raised start", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    const lane = {
+      target: "rate",
+      points: [
+        { t: 0, v: 1 },
+        { t: 2, v: 3 },
+      ],
+    } satisfies RateSpec;
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 0,
+      playbackRate: lane,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    const video = input.composition.videos[0]!;
+    expect(video.start).toBe(3);
+    expect(video.mediaStart).toBeCloseTo(sourceTimeAt(lane, 1), 9);
+    expect(video.playbackRate).toEqual(shiftRateLane(lane, 1));
+  });
+
+  it("leaves mediaStart at 0 when visibility raises start on an empty-src video", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3.5, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 0,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({
+        id: "clip",
+        start: 3.5,
+        end: 6,
+        mediaStart: 0,
+      }),
+    );
+  });
+
+  it("keeps the visibility out-point so a short overlay holds after host+fileLen", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 3.5, visibleEnd: 6 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 4,
+      mediaStart: 0,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-start="2" data-end="4" data-duration="2" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({
+        id: "clip",
+        start: 3.5,
+        end: 6,
+        mediaStart: 1.5,
+      }),
+    );
+    expect(input.compiled.html).toContain('data-start="2"');
+    expect(input.compiled.html).toContain('data-end="6"');
+    expect(input.compiled.html).toContain('data-duration="4"');
+  });
+
+  it("does not let visibility pull start earlier than the host-mapped start", async () => {
+    resetRetryMocks();
+    visibilityWindows = [{ videoId: "clip", visibleStart: 0, visibleEnd: 4 }];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.videos.push({
+      id: "clip",
+      src: "runtime.mp4",
+      start: 2,
+      end: 6,
+      mediaStart: 0,
+      loop: false,
+      hasAudio: false,
+    });
+    input.compiled.html = `<video id="clip" src="runtime.mp4" data-hf-auto-start=""></video>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.videos[0]).toEqual(
+      expect.objectContaining({
+        id: "clip",
+        start: 2,
+        end: 4,
+        mediaStart: 0,
+      }),
+    );
+  });
+
   it("launches a probe when a static-duration composition inserts video at runtime", async () => {
     capturedCfgs.length = 0;
     const { runProbeStage } = await import("./probeStage.js");
diff --git a/packages/producer/src/services/render/stages/probeStage.ts b/packages/producer/src/services/render/stages/probeStage.ts
index 9ddf7843246..8db28033308 100644
--- a/packages/producer/src/services/render/stages/probeStage.ts
+++ b/packages/producer/src/services/render/stages/probeStage.ts
@@ -47,12 +47,14 @@ import {
 } from "@hyperframes/engine";
 import {
   MEDIA_RENDER_ID_ATTR,
+  extendVideoSlotEnds,
   fpsToNumber,
   normalizeRateSpec,
   readMediaStart,
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime,
+  type VideoSlotEnd,
 } from "@hyperframes/core";
 import { extractMediaSrcMutations } from "@hyperframes/parsers";
 import type { BrowserMediaElement, CompiledComposition } from "../../htmlCompiler.js";
@@ -169,6 +171,30 @@ export function hasAutoStartVideos(html: string): boolean {
   return document.querySelector("video[data-hf-auto-start]") !== null;
 }
 
+function applyVideoSlotEnds(compiled: CompiledComposition, slots: readonly VideoSlotEnd[]): void {
+  if (slots.length === 0) return;
+  compiled.html = extendVideoSlotEnds(compiled.html, slots);
+  for (const [path, html] of compiled.subCompositions) {
+    compiled.subCompositions.set(path, extendVideoSlotEnds(html, slots));
+  }
+}
+
+/** Videos whose file was in the HTML at compile time — the player already ran the host clock. */
+function staticSrcVideoIds(html: string): Set<string> {
+  const { document } = parseHTML(html);
+  const ids = new Set<string>();
+  for (const el of document.querySelectorAll("video")) {
+    const ownSrc = el.getAttribute("src")?.trim();
+    const childSrc = [...el.querySelectorAll("source")].some((source) =>
+      Boolean(source.getAttribute("src")?.trim()),
+    );
+    if (!ownSrc && !childSrc) continue;
+    const id = el.getAttribute("data-hf-render-id") || el.id;
+    if (id) ids.add(id);
+  }
+  return ids;
+}
+
 /**
  * Variable-bound image/audio/video sources are resolved by the browser runtime, not
  * the static compiler. Probe them whenever the current render overrides the
@@ -762,17 +788,47 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
         );
         assertNotAborted();
 
+        const hostClockIds = staticSrcVideoIds(compiled.html);
+        const slotEnds: VideoSlotEnd[] = [];
         for (const win of visibilityWindows) {
           const video = composition.videos.find((v) => v.id === win.videoId);
           if (!video) continue;
           if (win.visibleStart >= 0 && win.visibleEnd > win.visibleStart) {
-            video.start = win.visibleStart;
+            const prevStart = video.start;
+            // Host-window maps origin; never pull start earlier than that floor.
+            video.start = Math.max(video.start, win.visibleStart);
             video.end = win.visibleEnd;
+            const raised = video.start - prevStart;
+            if (raised > 0 && video.mediaStart <= 0 && hostClockIds.has(video.id)) {
+              const rate = normalizeRateSpec(video.playbackRate);
+              video.mediaStart += sourceTimeAt(rate, raised);
+              if (video.playbackRate !== undefined)
+                video.playbackRate = shiftRateLane(rate, raised);
+            }
+            const duration = video.end - prevStart;
+            if (duration > 0) {
+              slotEnds.push({ id: video.id, end: video.end, duration });
+            }
             log.info(
-              `[Probe] Runtime video discovery: ${video.id} visible ${win.visibleStart.toFixed(2)}s to ${win.visibleEnd.toFixed(2)}s`,
+              `[Probe] Runtime video discovery: ${video.id} visible ${win.visibleStart.toFixed(2)}s to ${win.visibleEnd.toFixed(2)}s, placed ${video.start.toFixed(2)}s to ${video.end.toFixed(2)}s`,
             );
           }
         }
+        if (slotEnds.length > 0) {
+          applyVideoSlotEnds(compiled, slotEnds);
+          writeCompiledArtifacts(compiled, workDir, Boolean(job.config.debug));
+          await session.page.evaluate((rows: VideoSlotEnd[]) => {
+            for (const row of rows) {
+              const el = ((
+                window as unknown as { __hfMediaEl?: (id: string) => Element | null }
+              ).__hfMediaEl?.(row.id) ??
+                document.getElementById(row.id)) as HTMLVideoElement | null;
+              if (!el) continue;
+              el.setAttribute("data-end", String(row.end));
+              el.setAttribute("data-duration", String(row.duration));
+            }
+          }, slotEnds);
+        }
       }
     }