From 550e2d352daf201373c1ba231cf87dce4ebc8f08 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 19:55:39 -0700
Subject: [PATCH 1/7] fix(engine): motion blur works over video by holding each
 video frame across samples

Each output frame's injected video frame is now held for every sub-frame
sample and probe of that frame, so footage stays as shot and only the
layers over it blur. The refusal for sessions with a before-capture hook
is removed.

Fixes #5144
---
 .../frameCapture-gpuCompletion.test.ts        |   4 +-
 .../services/frameCapture-motionBlur.test.ts  |  63 ++++++-
 packages/engine/src/services/frameCapture.ts  |  42 +++--
 .../producer/scripts/test-classification.mjs  |   1 +
 .../motionBlurVideo.integration.test.ts       | 167 ++++++++++++++++++
 5 files changed, 259 insertions(+), 18 deletions(-)
 create mode 100644 packages/producer/src/services/render/motionBlurVideo.integration.test.ts

diff --git a/packages/engine/src/services/frameCapture-gpuCompletion.test.ts b/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
index 0145762781..3f65e781c1 100644
--- a/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
+++ b/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
@@ -33,7 +33,9 @@ describe("WebGPU frame completion", () => {
 
   it("runs the completion wait after video injection and before screenshot capture", () => {
     const source = readFileSync(new URL("./frameCapture.ts", import.meta.url), "utf8");
-    const injection = source.indexOf("await session.onBeforeCapture(page, quantizedTime)");
+    const injection = source.indexOf(
+      "await session.onBeforeCapture(page, videoTime ?? quantizedTime)",
+    );
     const completion = source.indexOf("await waitForPendingSeekCompletion(page)");
     const screenshot = source.indexOf("async function captureFrameCore");
     expect(injection).toBeGreaterThan(-1);
diff --git a/packages/engine/src/services/frameCapture-motionBlur.test.ts b/packages/engine/src/services/frameCapture-motionBlur.test.ts
index 320d6c3204..00cdd7732f 100644
--- a/packages/engine/src/services/frameCapture-motionBlur.test.ts
+++ b/packages/engine/src/services/frameCapture-motionBlur.test.ts
@@ -317,10 +317,65 @@ describe("resolveSessionMotionBlur rejects what accumulation cannot render", ()
     expect(() => resolveSessionMotionBlur(session)).toThrow(/format "png"/);
   });
 
-  it("rejects injected video frames, which cannot follow a sub-frame seek", () => {
-    expect(() =>
-      resolveSessionMotionBlur(withOptions({ onBeforeCapture: async () => {} })),
-    ).toThrow(/video/);
+  it("accepts a session that injects video frames (#5144)", () => {
+    const plan = resolveSessionMotionBlur(withOptions({ onBeforeCapture: async () => {} }));
+    expect(plan).not.toBeUndefined();
+  });
+});
+
+describe("injected video is held for the whole shutter window (#5144)", () => {
+  /** Records each injector call's time and how many page seeks had run before it. */
+  function recordInjections(): {
+    calls: Array<{ time: number; seeksBefore: number }>;
+    hook: CaptureSession["onBeforeCapture"];
+  } {
+    const calls: Array<{ time: number; seeksBefore: number }> = [];
+    return {
+      calls,
+      hook: async (_page, time) => {
+        calls.push({ time, seeksBefore: seeks.length });
+      },
+    };
+  }
+
+  it("injects at the frame time before any sample, then gives every sample that same time", async () => {
+    const { calls, hook } = recordInjections();
+
+    await captureFrameToBuffer(makeSession({ onBeforeCapture: hook }), 10, 10 / 30);
+
+    // One injection right after the eventful seek, then one per sample, all at frame 10.
+    expect(calls).toHaveLength(1 + 16);
+    expect(calls.every((call) => call.time === 10 / 30)).toBe(true);
+    expect(calls[0]?.seeksBefore).toBe(1);
+    // The samples themselves still seek 16 distinct sub-frame times.
+    const samples = seeks.filter((s) => s.subFrameDivisions !== undefined);
+    expect(new Set(samples.map((s) => s.time)).size).toBe(16);
+  });
+
+  it("holds the frame time for the adaptive probes too", async () => {
+    const { calls, hook } = recordInjections();
+
+    await captureFrameToBuffer(
+      makeSession({ onBeforeCapture: hook, motionBlur: resolveMotionBlurPlan({}) ?? undefined }),
+      10,
+      10 / 30,
+    );
+
+    const sampleCount = seeks.filter((s) => s.subFrameDivisions !== undefined).length;
+    expect(calls).toHaveLength(1 + sampleCount);
+    expect(calls.every((call) => call.time === 10 / 30)).toBe(true);
+  });
+
+  it("still gives a frame without blur its own time", async () => {
+    const { calls, hook } = recordInjections();
+
+    await captureFrameToBuffer(
+      makeSession({ onBeforeCapture: hook, motionBlur: undefined }),
+      10,
+      10 / 30,
+    );
+
+    expect(calls.map((call) => call.time)).toEqual([10 / 30]);
   });
 });
 
diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index c87c29933e..c22d3b5491 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -2805,6 +2805,7 @@ async function prepareFrameForCapture(
   frameIndex: number,
   time: number,
   seekOptions?: HfSeekOptions,
+  videoTime?: number,
 ): Promise<{
   quantizedTime: number;
   seekMs: number;
@@ -2832,10 +2833,11 @@ async function prepareFrameForCapture(
 
   // Before-capture hook (e.g. video frame injection) — runs before
   // page-side compositor clones so cloneNode picks up injected <img>
-  // replacements for <video> elements.
+  // replacements for <video> elements. Motion-blur samples pass the output
+  // frame's time as `videoTime`, so every sample shows the same video frame.
   const beforeCaptureStart = Date.now();
   if (session.onBeforeCapture) {
-    await session.onBeforeCapture(page, quantizedTime);
+    await session.onBeforeCapture(page, videoTime ?? quantizedTime);
   }
   await waitForPendingSeekCompletion(page);
   await page.evaluate(async () => {
@@ -3867,9 +3869,8 @@ export async function withFrameDeadline<T>(
  *
  * Called once initialization has settled the capture mode. `format: "png"` is required
  * because samples are averaged pixel by pixel: JPEG samples would be averaged after
- * lossy quantization and the blended frame is re-encoded as PNG. `<video>` content is
- * out of scope because it is supplied by the before-capture frame-injection hook rather
- * than by the timeline seek, so it cannot follow a sub-frame time.
+ * lossy quantization and the blended frame is re-encoded as PNG. Injected `<video>`
+ * frames are held for the whole frame (see `captureAccumulatedFrame`), so video is allowed.
  */
 export function resolveSessionMotionBlur(session: CaptureSession): MotionBlurPlan | undefined {
   const plan = resolveMotionBlurPlan(session.options.motionBlur);
@@ -3884,11 +3885,6 @@ export function resolveSessionMotionBlur(session: CaptureSession): MotionBlurPla
       `[MotionBlur] sub-frame motion blur requires format "png", got "${session.options.format ?? "jpeg"}"`,
     );
   }
-  if (session.onBeforeCapture) {
-    throw new Error(
-      "[MotionBlur] sub-frame motion blur cannot run with injected video frames: video content is extracted per output frame and does not follow a sub-frame seek",
-    );
-  }
   return plan;
 }
 
@@ -3907,6 +3903,7 @@ async function captureFrameSurface(
   frameIndex: number,
   time: number,
   seekOptions?: HfSeekOptions,
+  videoTime?: number,
 ): Promise<CapturedSurface> {
   const { page, options } = session;
   const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
@@ -3914,6 +3911,7 @@ async function captureFrameSurface(
     frameIndex,
     time,
     seekOptions,
+    videoTime,
   );
 
   const screenshotStart = Date.now();
@@ -4100,6 +4098,7 @@ async function resolveAdaptiveSampleCount(
   plan: MotionBlurPlan,
   fps: number,
   sampleSeek: HfSeekOptions,
+  frameTime: number,
 ): Promise<{
   samplesPerFrame: number;
   seekMs: number;
@@ -4115,8 +4114,8 @@ async function resolveAdaptiveSampleCount(
     };
   }
   const { windowStart, windowEnd } = motionBlurProbeTimes(plan, absFrameIndex, fps);
-  const probeA = await captureFrameSurface(session, frameIndex, windowStart, sampleSeek);
-  const probeB = await captureFrameSurface(session, frameIndex, windowEnd, sampleSeek);
+  const probeA = await captureFrameSurface(session, frameIndex, windowStart, sampleSeek, frameTime);
+  const probeB = await captureFrameSurface(session, frameIndex, windowEnd, sampleSeek, frameTime);
   return {
     samplesPerFrame: adaptiveSampleCount(probeDiffMagnitude(probeA.buffer, probeB.buffer)),
     seekMs: probeA.seekMs + probeB.seekMs,
@@ -4135,6 +4134,9 @@ async function resolveAdaptiveSampleCount(
  * suppresses events and the playhead is restored to the frame time afterwards, so a
  * composition's own onUpdate/onComplete fire on the same interval boundaries as a
  * render with blur off.
+ *
+ * Injected `<video>` frames are held: every sample and probe shows the video frame for
+ * `frameTime`, so footage stays as shot and only the layers over it blur.
  */
 async function captureAccumulatedFrame(
   session: CaptureSession,
@@ -4148,6 +4150,13 @@ async function captureAccumulatedFrame(
   const eventfulSeekStart = Date.now();
   await seekPageTimeline(session.page, frameTime, undefined);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
+  if (session.onBeforeCapture) {
+    // Inject while the page is still at frameTime: the injector re-renders GPU layers at
+    // the time it is given, which must be the page's time.
+    const injectStart = Date.now();
+    await session.onBeforeCapture(session.page, frameTime);
+    totals.beforeCaptureMs += Date.now() - injectStart;
+  }
 
   const sampleSeek: HfSeekOptions = {
     suppressEvents: true,
@@ -4163,6 +4172,7 @@ async function captureAccumulatedFrame(
       plan,
       fps,
       sampleSeek,
+      frameTime,
     );
     samplesPerFrame = chosen.samplesPerFrame;
     totals.seekMs += chosen.seekMs;
@@ -4172,7 +4182,13 @@ async function captureAccumulatedFrame(
 
   const accumulator = new MotionBlurAccumulator(plan.blend);
   for (const sampleTime of motionBlurSampleTimes(plan, absFrameIndex, fps, samplesPerFrame)) {
-    const sample = await captureFrameSurface(session, frameIndex, sampleTime, sampleSeek);
+    const sample = await captureFrameSurface(
+      session,
+      frameIndex,
+      sampleTime,
+      sampleSeek,
+      frameTime,
+    );
     totals.seekMs += sample.seekMs;
     totals.beforeCaptureMs += sample.beforeCaptureMs;
     totals.screenshotMs += sample.screenshotMs;
diff --git a/packages/producer/scripts/test-classification.mjs b/packages/producer/scripts/test-classification.mjs
index 195af79243..903bfdf2ed 100644
--- a/packages/producer/scripts/test-classification.mjs
+++ b/packages/producer/scripts/test-classification.mjs
@@ -30,6 +30,7 @@ const INTEGRATION_TEST_FILES = new Set([
   "src/services/htmlCompiler.mediaType.test.ts",
   "src/services/htmlCompiler.naturalDuration.test.ts",
   "src/services/render/hlsRender.integration.test.ts",
+  "src/services/render/motionBlurVideo.integration.test.ts",
   "src/services/render/renderCancel.integration.test.ts",
   "src/services/render/stages/compileStage.mediaType.test.ts",
   "src/services/render/stages/gifEncodeArgs.test.ts",
diff --git a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
new file mode 100644
index 0000000000..361e4ce653
--- /dev/null
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -0,0 +1,167 @@
+/**
+ * Motion blur over a `<video>`, rendered for real (#5144).
+ *
+ * The footage fills the frame; a white bar slides across its bottom third. With blur on,
+ * the video rows must match the unblurred render byte for byte (each injected video
+ * frame is held for the whole shutter window), while the bar's rows must differ (the
+ * bar is smeared). Needs Chrome + ffmpeg, so it lives in the integration lane.
+ */
+
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+  decodePng,
+  getFfmpegBinary,
+  resolveConfig,
+  type MotionBlurOptions,
+} from "@hyperframes/engine";
+import { createRenderJob, executeRenderJob } from "../renderOrchestrator.js";
+
+const FFMPEG = getFfmpegBinary();
+const HAS_FFMPEG = spawnSync(FFMPEG, ["-version"], { encoding: "utf-8" }).status === 0;
+
+const WIDTH = 160;
+const HEIGHT = 90;
+const FPS = 30;
+const DURATION_SECONDS = 0.5;
+const FRAME_COUNT = DURATION_SECONDS * FPS;
+// The bar covers rows BAR_TOP..HEIGHT; every row above it is video only.
+const BAR_TOP = 60;
+
+const COMPOSITION = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { overflow: hidden; }
+    #clip { position: absolute; left: 0; top: 0; width: ${WIDTH}px; height: ${HEIGHT}px; }
+    #bar {
+      position: absolute; left: 0; top: ${BAR_TOP}px; width: 20px; height: ${HEIGHT - BAR_TOP}px;
+      background: #fff; animation: slide ${DURATION_SECONDS}s linear both;
+    }
+    @keyframes slide { from { transform: translateX(0); } to { transform: translateX(140px); } }
+  </style>
+</head>
+<body>
+  <div
+    id="root"
+    data-composition-id="motion-blur-video"
+    data-start="0"
+    data-duration="${DURATION_SECONDS}"
+    data-width="${WIDTH}"
+    data-height="${HEIGHT}"
+    data-fps="${FPS}"
+    data-no-timeline
+  >
+    <video id="clip" class="clip" src="assets/clip.mp4" data-start="0" data-duration="${DURATION_SECONDS}" data-track-index="0" muted playsinline></video>
+    <div id="bar"></div>
+  </div>
+</body>
+</html>
+`;
+
+let root: string;
+
+async function renderFrames(name: string, motionBlur?: MotionBlurOptions): Promise<Buffer[]> {
+  const outputDir = join(root, name);
+  const job = createRenderJob({
+    fps: FPS,
+    quality: "draft",
+    format: "png-sequence",
+    hdrMode: "force-sdr",
+    workers: 1,
+    motionBlur,
+    logger: { info() {}, warn() {}, error() {}, debug() {} },
+    producerConfig: resolveConfig({ browserGpuMode: "software" }),
+  });
+  await executeRenderJob(job, root, outputDir);
+  return readdirSync(outputDir)
+    .filter((file) => file.endsWith(".png"))
+    .sort()
+    .map((file) => readFileSync(join(outputDir, file)));
+}
+
+/** The RGBA bytes of rows [top, bottom) of a PNG frame. */
+function rows(png: Buffer, top: number, bottom: number): Buffer {
+  const { width, data } = decodePng(png);
+  return Buffer.from(data.subarray(top * width * 4, bottom * width * 4));
+}
+
+describe.skipIf(!HAS_FFMPEG)("motion blur over video — real render (#5144)", () => {
+  let plain: Buffer[];
+  let blurred: Buffer[];
+  let blurredAgain: Buffer[];
+
+  beforeAll(async () => {
+    root = mkdtempSync(join(tmpdir(), "hf-motion-blur-video-"));
+    mkdirSync(join(root, "assets"), { recursive: true });
+    writeFileSync(join(root, "index.html"), COMPOSITION);
+    // testsrc2 changes every frame, so a sample that picked a neighbouring video frame
+    // would change the video rows.
+    const clip = spawnSync(
+      FFMPEG,
+      [
+        "-v",
+        "error",
+        "-f",
+        "lavfi",
+        "-i",
+        `testsrc2=size=${WIDTH}x${HEIGHT}:rate=${FPS}:duration=1`,
+        "-pix_fmt",
+        "yuv420p",
+        "-c:v",
+        "libx264",
+        "-g",
+        "1",
+        "-y",
+        join(root, "assets", "clip.mp4"),
+      ],
+      { encoding: "utf-8" },
+    );
+    if (clip.status !== 0) throw new Error(`clip fixture failed: ${clip.stderr}`);
+
+    const blur: MotionBlurOptions = { samplesPerFrame: 8 };
+    plain = await renderFrames("plain");
+    blurred = await renderFrames("blurred", blur);
+    blurredAgain = await renderFrames("blurred-again", blur);
+  }, 600_000);
+
+  afterAll(() => {
+    if (root) rmSync(root, { recursive: true, force: true });
+  });
+
+  it("renders every frame with blur on", () => {
+    expect(plain).toHaveLength(FRAME_COUNT);
+    expect(blurred).toHaveLength(FRAME_COUNT);
+  });
+
+  it("keeps the video rows identical to the unblurred render on every frame", () => {
+    // Non-vacuous only if the footage actually moves between frames.
+    expect(rows(plain[6]!, 0, BAR_TOP).equals(rows(plain[7]!, 0, BAR_TOP))).toBe(false);
+    for (let i = 0; i < FRAME_COUNT; i++) {
+      expect(rows(blurred[i]!, 0, BAR_TOP).equals(rows(plain[i]!, 0, BAR_TOP)), `frame ${i}`).toBe(
+        true,
+      );
+    }
+  });
+
+  it("smears the moving bar", () => {
+    for (const i of [4, 7, 10]) {
+      expect(
+        rows(blurred[i]!, BAR_TOP, HEIGHT).equals(rows(plain[i]!, BAR_TOP, HEIGHT)),
+        `frame ${i}`,
+      ).toBe(false);
+    }
+  });
+
+  it("is deterministic", () => {
+    expect(blurredAgain).toHaveLength(FRAME_COUNT);
+    for (let i = 0; i < FRAME_COUNT; i++) {
+      expect(blurredAgain[i]!.equals(blurred[i]!), `frame ${i}`).toBe(true);
+    }
+  });
+});

From b33e3cde41316be0851f34a26b9547079b5c12e4 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 20:14:11 -0700
Subject: [PATCH 2/7] fix(engine): trim held-video comments, pin the new
 test-classification hash

---
 .../services/frameCapture-motionBlur.test.ts  | 19 ++++++-------------
 packages/engine/src/services/frameCapture.ts  | 13 ++++---------
 scripts/test-reachability.json                |  2 +-
 3 files changed, 11 insertions(+), 23 deletions(-)

diff --git a/packages/engine/src/services/frameCapture-motionBlur.test.ts b/packages/engine/src/services/frameCapture-motionBlur.test.ts
index 00cdd7732f..5938635da1 100644
--- a/packages/engine/src/services/frameCapture-motionBlur.test.ts
+++ b/packages/engine/src/services/frameCapture-motionBlur.test.ts
@@ -325,17 +325,12 @@ describe("resolveSessionMotionBlur rejects what accumulation cannot render", ()
 
 describe("injected video is held for the whole shutter window (#5144)", () => {
   /** Records each injector call's time and how many page seeks had run before it. */
-  function recordInjections(): {
-    calls: Array<{ time: number; seeksBefore: number }>;
-    hook: CaptureSession["onBeforeCapture"];
-  } {
+  function recordInjections() {
     const calls: Array<{ time: number; seeksBefore: number }> = [];
-    return {
-      calls,
-      hook: async (_page, time) => {
-        calls.push({ time, seeksBefore: seeks.length });
-      },
+    const hook: CaptureSession["onBeforeCapture"] = async (_page, time) => {
+      calls.push({ time, seeksBefore: seeks.length });
     };
+    return { calls, hook };
   }
 
   it("injects at the frame time before any sample, then gives every sample that same time", async () => {
@@ -344,8 +339,7 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
     await captureFrameToBuffer(makeSession({ onBeforeCapture: hook }), 10, 10 / 30);
 
     // One injection right after the eventful seek, then one per sample, all at frame 10.
-    expect(calls).toHaveLength(1 + 16);
-    expect(calls.every((call) => call.time === 10 / 30)).toBe(true);
+    expect(calls.map((call) => call.time)).toEqual(Array(1 + 16).fill(10 / 30));
     expect(calls[0]?.seeksBefore).toBe(1);
     // The samples themselves still seek 16 distinct sub-frame times.
     const samples = seeks.filter((s) => s.subFrameDivisions !== undefined);
@@ -362,8 +356,7 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
     );
 
     const sampleCount = seeks.filter((s) => s.subFrameDivisions !== undefined).length;
-    expect(calls).toHaveLength(1 + sampleCount);
-    expect(calls.every((call) => call.time === 10 / 30)).toBe(true);
+    expect(calls.map((call) => call.time)).toEqual(Array(1 + sampleCount).fill(10 / 30));
   });
 
   it("still gives a frame without blur its own time", async () => {
diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index c22d3b5491..00aed3ec9f 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -2833,8 +2833,7 @@ async function prepareFrameForCapture(
 
   // Before-capture hook (e.g. video frame injection) — runs before
   // page-side compositor clones so cloneNode picks up injected <img>
-  // replacements for <video> elements. Motion-blur samples pass the output
-  // frame's time as `videoTime`, so every sample shows the same video frame.
+  // replacements for <video> elements.
   const beforeCaptureStart = Date.now();
   if (session.onBeforeCapture) {
     await session.onBeforeCapture(page, videoTime ?? quantizedTime);
@@ -3869,8 +3868,7 @@ export async function withFrameDeadline<T>(
  *
  * Called once initialization has settled the capture mode. `format: "png"` is required
  * because samples are averaged pixel by pixel: JPEG samples would be averaged after
- * lossy quantization and the blended frame is re-encoded as PNG. Injected `<video>`
- * frames are held for the whole frame (see `captureAccumulatedFrame`), so video is allowed.
+ * lossy quantization and the blended frame is re-encoded as PNG.
  */
 export function resolveSessionMotionBlur(session: CaptureSession): MotionBlurPlan | undefined {
   const plan = resolveMotionBlurPlan(session.options.motionBlur);
@@ -4134,9 +4132,6 @@ async function resolveAdaptiveSampleCount(
  * suppresses events and the playhead is restored to the frame time afterwards, so a
  * composition's own onUpdate/onComplete fire on the same interval boundaries as a
  * render with blur off.
- *
- * Injected `<video>` frames are held: every sample and probe shows the video frame for
- * `frameTime`, so footage stays as shot and only the layers over it blur.
  */
 async function captureAccumulatedFrame(
   session: CaptureSession,
@@ -4151,8 +4146,8 @@ async function captureAccumulatedFrame(
   await seekPageTimeline(session.page, frameTime, undefined);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
   if (session.onBeforeCapture) {
-    // Inject while the page is still at frameTime: the injector re-renders GPU layers at
-    // the time it is given, which must be the page's time.
+    // Every sample and probe reuses frameTime's video frame. Inject it now, at the page's own
+    // time, because the injector re-renders GPU layers at the time it is given.
     const injectStart = Date.now();
     await session.onBeforeCapture(session.page, frameTime);
     totals.beforeCaptureMs += Date.now() - injectStart;
diff --git a/scripts/test-reachability.json b/scripts/test-reachability.json
index 3ed418ade2..72d41c1242 100644
--- a/scripts/test-reachability.json
+++ b/scripts/test-reachability.json
@@ -61,7 +61,7 @@
       ],
       "sources": {
         "packages/producer/scripts/run-test-lane.mjs": "638885e14480d03290803389325a655f3749442167d784e07bb3af3404598af7",
-        "packages/producer/scripts/test-classification.mjs": "ae0cd9e09bf93df932d41649855f86ebb2230b25aabf3e56355fed8f101a0322",
+        "packages/producer/scripts/test-classification.mjs": "d7ca46d663bfa7012147d1eff63a9e599f44393d7d65fd910d5b96cceb2b2f44",
         ".github/workflows/ci.yml#job#producer-source-tests": "45da72aa6cf08cdfd5bcf5311e89f12af4842f9eebc6735df19da8c02f4d4864",
         "packages/producer/package.json#script#test:unit": "ae6beda8319d166774be958ea5593cd27dbf7f6c9bce1d787a3fe28dfc3477b1",
         "packages/producer/package.json#script#test:integration": "008589f37d026877595a13501cbb66abd5cbe50e21fdcac6904f45466c3f475d",

From 7bb85436df83836d0eb120455819f1af9d10f9dd Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 20:51:28 -0700
Subject: [PATCH 3/7] fix(engine): a blurred frame at a sub-composition cut
 keeps its video

Each sample now decides which videos show at its own time, like every other
layer, and only a video on screen at the output frame's time keeps that
frame's picture. Before, the visible set was taken at the frame's time while
sub-composition hosts were hidden at the sample's time, so the samples just
before a cut showed no video and the cut frame dipped toward black. The
before-capture hook takes the held time as an optional third argument, and
the early injection is gone: the GPU re-render now always runs at the page's
own time.
---
 .../frameCapture-gpuCompletion.test.ts        |  2 +-
 .../services/frameCapture-motionBlur.test.ts  | 28 +++----
 packages/engine/src/services/frameCapture.ts  | 23 +++--
 .../src/services/videoFrameInjector.test.ts   | 54 ++++++++++++
 .../engine/src/services/videoFrameInjector.ts |  7 +-
 .../motionBlurVideo.integration.test.ts       | 84 +++++++++++++++++--
 6 files changed, 164 insertions(+), 34 deletions(-)

diff --git a/packages/engine/src/services/frameCapture-gpuCompletion.test.ts b/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
index 3f65e781c1..ab566d3a7e 100644
--- a/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
+++ b/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
@@ -34,7 +34,7 @@ describe("WebGPU frame completion", () => {
   it("runs the completion wait after video injection and before screenshot capture", () => {
     const source = readFileSync(new URL("./frameCapture.ts", import.meta.url), "utf8");
     const injection = source.indexOf(
-      "await session.onBeforeCapture(page, videoTime ?? quantizedTime)",
+      "await session.onBeforeCapture(page, quantizedTime, heldVideoTime)",
     );
     const completion = source.indexOf("await waitForPendingSeekCompletion(page)");
     const screenshot = source.indexOf("async function captureFrameCore");
diff --git a/packages/engine/src/services/frameCapture-motionBlur.test.ts b/packages/engine/src/services/frameCapture-motionBlur.test.ts
index 5938635da1..04f0767d5b 100644
--- a/packages/engine/src/services/frameCapture-motionBlur.test.ts
+++ b/packages/engine/src/services/frameCapture-motionBlur.test.ts
@@ -324,26 +324,24 @@ describe("resolveSessionMotionBlur rejects what accumulation cannot render", ()
 });
 
 describe("injected video is held for the whole shutter window (#5144)", () => {
-  /** Records each injector call's time and how many page seeks had run before it. */
   function recordInjections() {
-    const calls: Array<{ time: number; seeksBefore: number }> = [];
-    const hook: CaptureSession["onBeforeCapture"] = async (_page, time) => {
-      calls.push({ time, seeksBefore: seeks.length });
+    const calls: Array<{ time: number; held: number | undefined }> = [];
+    const hook: CaptureSession["onBeforeCapture"] = async (_page, time, held) => {
+      calls.push({ time, held });
     };
     return { calls, hook };
   }
+  const sampleSeekTimes = () =>
+    seeks.filter((s) => s.subFrameDivisions !== undefined).map((s) => s.time);
 
-  it("injects at the frame time before any sample, then gives every sample that same time", async () => {
+  it("injects each sample at its own time, holding the frame time for the video", async () => {
     const { calls, hook } = recordInjections();
 
     await captureFrameToBuffer(makeSession({ onBeforeCapture: hook }), 10, 10 / 30);
 
-    // One injection right after the eventful seek, then one per sample, all at frame 10.
-    expect(calls.map((call) => call.time)).toEqual(Array(1 + 16).fill(10 / 30));
-    expect(calls[0]?.seeksBefore).toBe(1);
-    // The samples themselves still seek 16 distinct sub-frame times.
-    const samples = seeks.filter((s) => s.subFrameDivisions !== undefined);
-    expect(new Set(samples.map((s) => s.time)).size).toBe(16);
+    expect(calls.map((call) => call.time)).toEqual(sampleSeekTimes());
+    expect(new Set(calls.map((call) => call.time)).size).toBe(16);
+    expect(calls.map((call) => call.held)).toEqual(Array(16).fill(10 / 30));
   });
 
   it("holds the frame time for the adaptive probes too", async () => {
@@ -355,11 +353,11 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
       10 / 30,
     );
 
-    const sampleCount = seeks.filter((s) => s.subFrameDivisions !== undefined).length;
-    expect(calls.map((call) => call.time)).toEqual(Array(1 + sampleCount).fill(10 / 30));
+    expect(calls.map((call) => call.time)).toEqual(sampleSeekTimes());
+    expect(calls.map((call) => call.held)).toEqual(Array(calls.length).fill(10 / 30));
   });
 
-  it("still gives a frame without blur its own time", async () => {
+  it("holds nothing on a frame without blur", async () => {
     const { calls, hook } = recordInjections();
 
     await captureFrameToBuffer(
@@ -368,7 +366,7 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
       10 / 30,
     );
 
-    expect(calls.map((call) => call.time)).toEqual([10 / 30]);
+    expect(calls).toEqual([{ time: 10 / 30, held: undefined }]);
   });
 });
 
diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index 00aed3ec9f..2e2513dee9 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -103,7 +103,13 @@ export { isMemoryExhaustionError, isTransientBrowserError } from "./captureFailu
 export type { CaptureOptions, CaptureResult, CaptureBufferResult, CapturePerfSummary };
 
 /** Called after seeking, before screenshot. Use for video frame injection or other pre-capture work. */
-export type BeforeCaptureHook = (page: Page, time: number) => Promise<void>;
+/** `heldVideoTime` (motion-blur samples only) is the output frame's time: a video on screen at
+ * both times shows its frame for `heldVideoTime`, so footage does not smear. */
+export type BeforeCaptureHook = (
+  page: Page,
+  time: number,
+  heldVideoTime?: number,
+) => Promise<void>;
 
 export interface CaptureSession {
   browser: Browser;
@@ -2805,7 +2811,7 @@ async function prepareFrameForCapture(
   frameIndex: number,
   time: number,
   seekOptions?: HfSeekOptions,
-  videoTime?: number,
+  heldVideoTime?: number,
 ): Promise<{
   quantizedTime: number;
   seekMs: number;
@@ -2836,7 +2842,7 @@ async function prepareFrameForCapture(
   // replacements for <video> elements.
   const beforeCaptureStart = Date.now();
   if (session.onBeforeCapture) {
-    await session.onBeforeCapture(page, videoTime ?? quantizedTime);
+    await session.onBeforeCapture(page, quantizedTime, heldVideoTime);
   }
   await waitForPendingSeekCompletion(page);
   await page.evaluate(async () => {
@@ -3901,7 +3907,7 @@ async function captureFrameSurface(
   frameIndex: number,
   time: number,
   seekOptions?: HfSeekOptions,
-  videoTime?: number,
+  heldVideoTime?: number,
 ): Promise<CapturedSurface> {
   const { page, options } = session;
   const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
@@ -3909,7 +3915,7 @@ async function captureFrameSurface(
     frameIndex,
     time,
     seekOptions,
-    videoTime,
+    heldVideoTime,
   );
 
   const screenshotStart = Date.now();
@@ -4145,13 +4151,6 @@ async function captureAccumulatedFrame(
   const eventfulSeekStart = Date.now();
   await seekPageTimeline(session.page, frameTime, undefined);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
-  if (session.onBeforeCapture) {
-    // Every sample and probe reuses frameTime's video frame. Inject it now, at the page's own
-    // time, because the injector re-renders GPU layers at the time it is given.
-    const injectStart = Date.now();
-    await session.onBeforeCapture(session.page, frameTime);
-    totals.beforeCaptureMs += Date.now() - injectStart;
-  }
 
   const sampleSeek: HfSeekOptions = {
     suppressEvents: true,
diff --git a/packages/engine/src/services/videoFrameInjector.test.ts b/packages/engine/src/services/videoFrameInjector.test.ts
index cda432c312..e34ae99f52 100644
--- a/packages/engine/src/services/videoFrameInjector.test.ts
+++ b/packages/engine/src/services/videoFrameInjector.test.ts
@@ -322,6 +322,60 @@ describe("createVideoFrameInjector cache hygiene against page-side skips", () =>
   });
 });
 
+describe("createVideoFrameInjector holds video frames for motion blur (#5144)", () => {
+  // Scene A's video plays until 1 s, scene B's from 1 s; frame index = 10 × time.
+  const clips = [
+    { videoId: "a", start: 0, end: 1 },
+    { videoId: "b", start: 1, end: 2 },
+  ];
+  const table = {
+    frameDirs: () => [],
+    getActiveFramePayloads: (time: number) =>
+      new Map(
+        clips
+          .filter((clip) => time >= clip.start && time < clip.end)
+          .map((clip) => {
+            const frameIndex = Math.floor(time * 10);
+            return [clip.videoId, { framePath: `/${clip.videoId}/${frameIndex}`, frameIndex }];
+          }),
+      ),
+  } as unknown as FrameLookupTable;
+  const page = { evaluate: vi.fn(async () => undefined) } as unknown as Page;
+
+  beforeEach(() => {
+    injectVideoFramesBatchMock.mockReset();
+    injectVideoFramesBatchMock.mockImplementation(async (_page, updates) =>
+      updates.map((u) => u.videoId),
+    );
+    syncVideoFrameVisibilityMock.mockReset();
+    syncVideoFrameVisibilityMock.mockResolvedValue(undefined);
+  });
+
+  it("shows the held frame of a video on screen at both times", async () => {
+    const hook = createVideoFrameInjector(table, { frameSrcResolver: inlineResolver });
+
+    // The sample alone would pick frame 14; the held frame time picks 15.
+    await hook!(page, 1.42, 1.5);
+
+    expect(syncVideoFrameVisibilityMock).toHaveBeenLastCalledWith(page, ["b"]);
+    expect(injectVideoFramesBatchMock.mock.calls[0]?.[1]).toEqual([
+      { videoId: "b", dataUri: inlineResolver("/b/15") },
+    ]);
+  });
+
+  it("follows the sample time across a cut, so neither scene's video drops out", async () => {
+    const hook = createVideoFrameInjector(table, { frameSrcResolver: inlineResolver });
+
+    // Frame 1.0 is scene B's first frame; a sample just before it still shows scene A.
+    await hook!(page, 0.98, 1.0);
+
+    expect(syncVideoFrameVisibilityMock).toHaveBeenLastCalledWith(page, ["a"]);
+    expect(injectVideoFramesBatchMock.mock.calls[0]?.[1]).toEqual([
+      { videoId: "a", dataUri: inlineResolver("/a/9") },
+    ]);
+  });
+});
+
 describe("createVideoFrameInjector extraction-cache lease renewal", () => {
   // Regression: a render can hold a compiled-dir symlink into a shared
   // extraction-cache entry far longer than the entry's one-time cache-hit
diff --git a/packages/engine/src/services/videoFrameInjector.ts b/packages/engine/src/services/videoFrameInjector.ts
index f90225ed05..f6457e03e6 100644
--- a/packages/engine/src/services/videoFrameInjector.ts
+++ b/packages/engine/src/services/videoFrameInjector.ts
@@ -204,9 +204,14 @@ export function createVideoFrameInjector(
   }
 
   // fallow-ignore-next-line complexity
-  return async (page: Page, time: number) => {
+  return async (page: Page, time: number, heldVideoTime?: number) => {
     for (const cacheDir of frameLookup.frameDirs()) renewCacheLease(cacheDir);
     const activePayloads = frameLookup.getActiveFramePayloads(time);
+    if (heldVideoTime !== undefined) {
+      for (const [videoId, payload] of frameLookup.getActiveFramePayloads(heldVideoTime)) {
+        if (activePayloads.has(videoId)) activePayloads.set(videoId, payload);
+      }
+    }
 
     const updates: Array<{ videoId: string; dataUri: string; frameIndex: number }> = [];
     const activeIds = new Set<string>();
diff --git a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
index 361e4ce653..b97271c38e 100644
--- a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -4,13 +4,24 @@
  * The footage fills the frame; a white bar slides across its bottom third. With blur on,
  * the video rows must match the unblurred render byte for byte (each injected video
  * frame is held for the whole shutter window), while the bar's rows must differ (the
- * bar is smeared). Needs Chrome + ffmpeg, so it lives in the integration lane.
+ * bar is smeared). A second project, a repo fixture, cuts between two sub-composition
+ * scenes, each a full-frame video: the blurred cut frame must not lose its video.
+ * Needs Chrome + ffmpeg, so it lives in the integration lane.
  */
 
 import { spawnSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  cpSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import {
   decodePng,
@@ -64,12 +75,26 @@ const COMPOSITION = `<!DOCTYPE html>
 </html>
 `;
 
+// The repo's two-scene fixture: two sub-composition hosts, each a full-frame video, cut at
+// 1 s. Its media is swapped for a generated clip.
+const CUT_FIXTURE = fileURLToPath(
+  new URL("../../../tests/nested-sequential-video-local-start/src", import.meta.url),
+);
+const CUT_FPS = 24;
+const CUT_FRAME = 24;
+const CUT_FRAME_COUNT = 48;
+
 let root: string;
 
-async function renderFrames(name: string, motionBlur?: MotionBlurOptions): Promise<Buffer[]> {
+async function renderFrames(
+  name: string,
+  motionBlur?: MotionBlurOptions,
+  projectDir = root,
+  fps = FPS,
+): Promise<Buffer[]> {
   const outputDir = join(root, name);
   const job = createRenderJob({
-    fps: FPS,
+    fps,
     quality: "draft",
     format: "png-sequence",
     hdrMode: "force-sdr",
@@ -78,13 +103,21 @@ async function renderFrames(name: string, motionBlur?: MotionBlurOptions): Promi
     logger: { info() {}, warn() {}, error() {}, debug() {} },
     producerConfig: resolveConfig({ browserGpuMode: "software" }),
   });
-  await executeRenderJob(job, root, outputDir);
+  await executeRenderJob(job, projectDir, outputDir);
   return readdirSync(outputDir)
     .filter((file) => file.endsWith(".png"))
     .sort()
     .map((file) => readFileSync(join(outputDir, file)));
 }
 
+/** Mean of a PNG frame's RGB channels, 0-255. */
+function meanLevel(png: Buffer): number {
+  const { data } = decodePng(png);
+  let sum = 0;
+  for (let i = 0; i < data.length; i += 4) sum += data[i]! + data[i + 1]! + data[i + 2]!;
+  return sum / ((data.length / 4) * 3);
+}
+
 /** The RGBA bytes of rows [top, bottom) of a PNG frame. */
 function rows(png: Buffer, top: number, bottom: number): Buffer {
   const { width, data } = decodePng(png);
@@ -95,6 +128,8 @@ describe.skipIf(!HAS_FFMPEG)("motion blur over video — real render (#5144)", (
   let plain: Buffer[];
   let blurred: Buffer[];
   let blurredAgain: Buffer[];
+  let cutPlain: Buffer[];
+  let cutBlurred: Buffer[];
 
   beforeAll(async () => {
     root = mkdtempSync(join(tmpdir(), "hf-motion-blur-video-"));
@@ -124,10 +159,37 @@ describe.skipIf(!HAS_FFMPEG)("motion blur over video — real render (#5144)", (
     );
     if (clip.status !== 0) throw new Error(`clip fixture failed: ${clip.stderr}`);
 
+    const cutDir = join(root, "cut");
+    cpSync(CUT_FIXTURE, cutDir, { recursive: true, filter: (src) => !src.endsWith(".mp4") });
+    mkdirSync(join(cutDir, "media"), { recursive: true });
+    const cutClip = spawnSync(
+      FFMPEG,
+      [
+        "-v",
+        "error",
+        "-f",
+        "lavfi",
+        "-i",
+        `testsrc2=size=${WIDTH}x${HEIGHT}:rate=${CUT_FPS}:duration=2`,
+        "-pix_fmt",
+        "yuv420p",
+        "-c:v",
+        "libx264",
+        "-g",
+        "1",
+        "-y",
+        join(cutDir, "media", "source.mp4"),
+      ],
+      { encoding: "utf-8" },
+    );
+    if (cutClip.status !== 0) throw new Error(`cut clip fixture failed: ${cutClip.stderr}`);
+
     const blur: MotionBlurOptions = { samplesPerFrame: 8 };
     plain = await renderFrames("plain");
     blurred = await renderFrames("blurred", blur);
     blurredAgain = await renderFrames("blurred-again", blur);
+    cutPlain = await renderFrames("cut-plain", undefined, cutDir, CUT_FPS);
+    cutBlurred = await renderFrames("cut-blurred", blur, cutDir, CUT_FPS);
   }, 600_000);
 
   afterAll(() => {
@@ -158,6 +220,18 @@ describe.skipIf(!HAS_FFMPEG)("motion blur over video — real render (#5144)", (
     }
   });
 
+  it("keeps both scenes' video through a sub-composition cut", () => {
+    expect(cutBlurred).toHaveLength(CUT_FRAME_COUNT);
+    for (let i = 0; i < CUT_FRAME_COUNT; i++) {
+      if (i === CUT_FRAME) continue;
+      const blurredPixels = rows(cutBlurred[i]!, 0, HEIGHT);
+      expect(blurredPixels.equals(rows(cutPlain[i]!, 0, HEIGHT)), `frame ${i}`).toBe(true);
+    }
+    // The cut frame blends scene A's last frame into scene B's first; it must not dim.
+    const plainLevel = meanLevel(cutPlain[CUT_FRAME]!);
+    expect(Math.abs(meanLevel(cutBlurred[CUT_FRAME]!) - plainLevel)).toBeLessThan(plainLevel * 0.1);
+  });
+
   it("is deterministic", () => {
     expect(blurredAgain).toHaveLength(FRAME_COUNT);
     for (let i = 0; i < FRAME_COUNT; i++) {

From ffe94aa28bb7ac70b9c1dba864c3174ae249add2 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 21:30:06 -0700
Subject: [PATCH 4/7] style(engine): one doc comment for the before-capture
 hook

---
 packages/engine/src/services/frameCapture.ts | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index 2e2513dee9..1dfe594611 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -102,14 +102,10 @@ export { isMemoryExhaustionError, isTransientBrowserError } from "./captureFailu
 
 export type { CaptureOptions, CaptureResult, CaptureBufferResult, CapturePerfSummary };
 
-/** Called after seeking, before screenshot. Use for video frame injection or other pre-capture work. */
-/** `heldVideoTime` (motion-blur samples only) is the output frame's time: a video on screen at
+/** Called after seeking, before screenshot. Use for video frame injection or other pre-capture work.
+ * `heldVideoTime` (motion-blur samples only) is the output frame's time: a video on screen at
  * both times shows its frame for `heldVideoTime`, so footage does not smear. */
-export type BeforeCaptureHook = (
-  page: Page,
-  time: number,
-  heldVideoTime?: number,
-) => Promise<void>;
+export type BeforeCaptureHook = (page: Page, time: number, heldVideoTime?: number) => Promise<void>;
 
 export interface CaptureSession {
   browser: Browser;

From 07a68566feb39e51a78984a4fb2475edf13f83ea Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 21:54:22 -0700
Subject: [PATCH 5/7] fix(engine): a video animating its own style stays in
 step when blurred

The injector copies a video's own style only when its frame changes, so the
first injection of each blurred frame now runs at the frame's own time
before the samples. A video sliding by its own transform no longer sits a
quarter frame behind with blur on.
---
 .../services/frameCapture-motionBlur.test.ts  | 19 +++++++++++--------
 packages/engine/src/services/frameCapture.ts  |  7 +++++++
 .../motionBlurVideo.integration.test.ts       | 15 ++++++++++-----
 3 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/packages/engine/src/services/frameCapture-motionBlur.test.ts b/packages/engine/src/services/frameCapture-motionBlur.test.ts
index 04f0767d5b..1a6f3fa1d2 100644
--- a/packages/engine/src/services/frameCapture-motionBlur.test.ts
+++ b/packages/engine/src/services/frameCapture-motionBlur.test.ts
@@ -325,23 +325,26 @@ describe("resolveSessionMotionBlur rejects what accumulation cannot render", ()
 
 describe("injected video is held for the whole shutter window (#5144)", () => {
   function recordInjections() {
-    const calls: Array<{ time: number; held: number | undefined }> = [];
+    const calls: Array<{ time: number; held: number | undefined; seeksBefore: number }> = [];
     const hook: CaptureSession["onBeforeCapture"] = async (_page, time, held) => {
-      calls.push({ time, held });
+      calls.push({ time, held, seeksBefore: seeks.length });
     };
     return { calls, hook };
   }
   const sampleSeekTimes = () =>
     seeks.filter((s) => s.subFrameDivisions !== undefined).map((s) => s.time);
 
-  it("injects each sample at its own time, holding the frame time for the video", async () => {
+  it("injects at the frame time first, then each sample at its own time holding the frame", async () => {
     const { calls, hook } = recordInjections();
 
     await captureFrameToBuffer(makeSession({ onBeforeCapture: hook }), 10, 10 / 30);
 
-    expect(calls.map((call) => call.time)).toEqual(sampleSeekTimes());
-    expect(new Set(calls.map((call) => call.time)).size).toBe(16);
-    expect(calls.map((call) => call.held)).toEqual(Array(16).fill(10 / 30));
+    // The first call comes right after the eventful seek, before any sample seek.
+    expect(calls[0]).toEqual({ time: 10 / 30, held: 10 / 30, seeksBefore: 1 });
+    const sampleCalls = calls.slice(1);
+    expect(sampleCalls.map((call) => call.time)).toEqual(sampleSeekTimes());
+    expect(new Set(sampleCalls.map((call) => call.time)).size).toBe(16);
+    expect(sampleCalls.map((call) => call.held)).toEqual(Array(16).fill(10 / 30));
   });
 
   it("holds the frame time for the adaptive probes too", async () => {
@@ -353,7 +356,7 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
       10 / 30,
     );
 
-    expect(calls.map((call) => call.time)).toEqual(sampleSeekTimes());
+    expect(calls.map((call) => call.time)).toEqual([10 / 30, ...sampleSeekTimes()]);
     expect(calls.map((call) => call.held)).toEqual(Array(calls.length).fill(10 / 30));
   });
 
@@ -366,7 +369,7 @@ describe("injected video is held for the whole shutter window (#5144)", () => {
       10 / 30,
     );
 
-    expect(calls).toEqual([{ time: 10 / 30, held: undefined }]);
+    expect(calls).toEqual([{ time: 10 / 30, held: undefined, seeksBefore: 1 }]);
   });
 });
 
diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index 1dfe594611..198fb3130c 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -4147,6 +4147,13 @@ async function captureAccumulatedFrame(
   const eventfulSeekStart = Date.now();
   await seekPageTimeline(session.page, frameTime, undefined);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
+  if (session.onBeforeCapture) {
+    // The injector copies a video's own style only when its frame changes: inject at frameTime
+    // first so the held frame carries frameTime's style, not the first sample's.
+    const injectStart = Date.now();
+    await session.onBeforeCapture(session.page, frameTime, frameTime);
+    totals.beforeCaptureMs += Date.now() - injectStart;
+  }
 
   const sampleSeek: HfSeekOptions = {
     suppressEvents: true,
diff --git a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
index b97271c38e..c9e3f4a745 100644
--- a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -1,10 +1,10 @@
 /**
  * Motion blur over a `<video>`, rendered for real (#5144).
  *
- * The footage fills the frame; a white bar slides across its bottom third. With blur on,
- * the video rows must match the unblurred render byte for byte (each injected video
- * frame is held for the whole shutter window), while the bar's rows must differ (the
- * bar is smeared). A second project, a repo fixture, cuts between two sub-composition
+ * The footage fills the frame and drifts left; a white bar slides across its bottom third.
+ * With blur on, the video rows must match the unblurred render byte for byte (each injected
+ * video frame, with the video's own style, is held for the whole shutter window), while the
+ * bar's rows must differ (the bar is smeared). A second project, a repo fixture, cuts between two sub-composition
  * scenes, each a full-frame video: the blurred cut frame must not lose its video.
  * Needs Chrome + ffmpeg, so it lives in the integration lane.
  */
@@ -49,7 +49,11 @@ const COMPOSITION = `<!DOCTYPE html>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body { overflow: hidden; }
-    #clip { position: absolute; left: 0; top: 0; width: ${WIDTH}px; height: ${HEIGHT}px; }
+    #clip {
+      position: absolute; left: 0; top: 0; width: ${WIDTH}px; height: ${HEIGHT}px;
+      animation: drift ${DURATION_SECONDS}s linear both;
+    }
+    @keyframes drift { from { transform: translateX(0); } to { transform: translateX(-30px); } }
     #bar {
       position: absolute; left: 0; top: ${BAR_TOP}px; width: 20px; height: ${HEIGHT - BAR_TOP}px;
       background: #fff; animation: slide ${DURATION_SECONDS}s linear both;
@@ -229,6 +233,7 @@ describe.skipIf(!HAS_FFMPEG)("motion blur over video — real render (#5144)", (
     }
     // The cut frame blends scene A's last frame into scene B's first; it must not dim.
     const plainLevel = meanLevel(cutPlain[CUT_FRAME]!);
+    expect(plainLevel).toBeGreaterThan(50);
     expect(Math.abs(meanLevel(cutBlurred[CUT_FRAME]!) - plainLevel)).toBeLessThan(plainLevel * 0.1);
   });
 

From eda1e7aafdc26f9b85be0620db99e824093c2db6 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 22:03:57 -0700
Subject: [PATCH 6/7] test(producer): a two-line header for the motion blur
 over video test

---
 .../render/motionBlurVideo.integration.test.ts       | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
index c9e3f4a745..4d4a3c573c 100644
--- a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -1,13 +1,5 @@
-/**
- * Motion blur over a `<video>`, rendered for real (#5144).
- *
- * The footage fills the frame and drifts left; a white bar slides across its bottom third.
- * With blur on, the video rows must match the unblurred render byte for byte (each injected
- * video frame, with the video's own style, is held for the whole shutter window), while the
- * bar's rows must differ (the bar is smeared). A second project, a repo fixture, cuts between two sub-composition
- * scenes, each a full-frame video: the blurred cut frame must not lose its video.
- * Needs Chrome + ffmpeg, so it lives in the integration lane.
- */
+// Motion blur over a <video>, rendered for real (#5144): held video rows match blur-off, the
+// bar smears, and a sub-composition cut keeps its video. Needs Chrome + ffmpeg: integration lane.
 
 import { spawnSync } from "node:child_process";
 import {

From 593c5ef536852e93fc40d14c1ef230216b6f3a93 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Tue, 6 Oct 2026 22:11:04 -0700
Subject: [PATCH 7/7] test(producer): reach the cut fixture by path, not a URL
 fallow reads as an import

---
 .../services/render/motionBlurVideo.integration.test.ts    | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
index 4d4a3c573c..cb9089235b 100644
--- a/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -12,7 +12,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import {
@@ -73,8 +73,9 @@ const COMPOSITION = `<!DOCTYPE html>
 
 // The repo's two-scene fixture: two sub-composition hosts, each a full-frame video, cut at
 // 1 s. Its media is swapped for a generated clip.
-const CUT_FIXTURE = fileURLToPath(
-  new URL("../../../tests/nested-sequential-video-local-start/src", import.meta.url),
+const CUT_FIXTURE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../../tests/nested-sequential-video-local-start/src",
 );
 const CUT_FPS = 24;
 const CUT_FRAME = 24;