From 77b7646b5ee374639b7d047736fdc33ad95de334 Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 07:00:02 +0000
Subject: [PATCH 1/6] fix(engine): auto-normalize VFR video inputs to CFR
 before frame extraction
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Screen recordings (macOS ScreenCaptureKit, QuickTime, phone videos) are
commonly variable-frame-rate. When such inputs hit the extractor's
`-ss <start> -i <video> -t <dur> -vf fps=N` pipeline, the fps filter
can emit fewer frames than requested — for a 4-second 30fps segment
starting mid-file, the output was ~90 frames instead of 120.

`FrameLookupTable.getFrameAtTime` returns null for out-of-range indices,
so the compositor held the last valid frame and the user perceived the
video as freezing. This matches the bug report from an X community post
where a user said "all of them freezes" on their screen recording scenes.

The engine already detects VFR via `metadata.isVFR` in ffprobe.ts but
never acted on it — the compiler only logged a warning. This change
mirrors the existing SDR→HDR normalization pattern: when a source is
detected as VFR, re-encode only the used segment with
`-fps_mode cfr -r <fps> -preset fast -crf 18` before extraction.

Scoping the re-encode to `[mediaStart, mediaStart+duration]` means a
30-second clip cut from a 60-minute screen recording pays ~1s of
transcode cost, not 18s. Benchmarked locally:

  Baseline (current):         32-39% duplicate frames, 25% frame-count
                              shortfall on mid-file segments.
  Tier 1 (flag changes only): ~same — fps filter issue is not flag-fixable.
  Tier 2 (CFR preflight):     1.7-6% duplicate frames, correct frame
                              count in every scenario tested.

The compiler warning that previously told users to manually re-encode
is downgraded to `console.info` since the engine now handles it.

— Rames Jusso
---
 .../src/services/videoFrameExtractor.test.ts  | 127 +++++++++++++++++-
 .../src/services/videoFrameExtractor.ts       | 106 +++++++++++++++
 .../producer/src/services/htmlCompiler.ts     |   7 +-
 3 files changed, 235 insertions(+), 5 deletions(-)

diff --git a/packages/engine/src/services/videoFrameExtractor.test.ts b/packages/engine/src/services/videoFrameExtractor.test.ts
index 5415f1fda..4cc8eeca8 100644
--- a/packages/engine/src/services/videoFrameExtractor.test.ts
+++ b/packages/engine/src/services/videoFrameExtractor.test.ts
@@ -1,5 +1,15 @@
-import { describe, expect, it } from "vitest";
-import { parseVideoElements, parseImageElements } from "./videoFrameExtractor.js";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+import {
+  parseVideoElements,
+  parseImageElements,
+  extractAllVideoFrames,
+  type VideoElement,
+} from "./videoFrameExtractor.js";
+import { extractVideoMetadata } from "../utils/ffprobe.js";
 
 describe("parseVideoElements", () => {
   it("parses videos without an id or data-start attribute", () => {
@@ -81,3 +91,116 @@ describe("parseImageElements", () => {
     expect(images[0]!.end).toBe(5);
   });
 });
+
+// Regression test for the VFR (variable frame rate) freeze bug.
+// Screen recordings and phone videos often have irregular timestamps.
+// When such inputs hit `extractVideoFramesRange`'s `-ss <start> -i ... -t <dur>
+// -vf fps=N` pipeline, the fps filter can emit fewer frames than requested —
+// e.g. a 4-second segment at 30fps would produce ~90 frames instead of 120.
+// FrameLookupTable.getFrameAtTime then returns null for out-of-range indices
+// and the compositor holds the last valid frame, which the user perceives as
+// the video freezing. extractAllVideoFrames normalizes VFR sources to CFR
+// before extraction to fix this.
+const FIXTURE_DIR = mkdtempSync(join(tmpdir(), "hf-vfr-test-"));
+const VFR_FIXTURE = join(FIXTURE_DIR, "vfr_screen.mp4");
+
+function runFfmpegSync(args: string[]): void {
+  const r = spawnSync("ffmpeg", args, { encoding: "utf8" });
+  if (r.status !== 0) {
+    throw new Error(`ffmpeg failed (${r.status}): ${r.stderr.slice(-400)}`);
+  }
+}
+
+beforeAll(() => {
+  // 10s testsrc2 at 60fps, ~40% of frames dropped via select filter and
+  // encoded with -vsync vfr so timestamps are irregular. Declared fps 60,
+  // actual average ~36 — well over the 10% threshold used by isVFR.
+  runFfmpegSync([
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-f",
+    "lavfi",
+    "-i",
+    "testsrc2=s=320x180:d=10:rate=60",
+    "-vf",
+    "drawtext=text='n=%{n}':fontsize=24:fontcolor=white:x=10:y=10:box=1:boxcolor=black@0.6," +
+      "select='not(between(n,30,89))*not(between(n,180,239))*not(between(n,330,389))*not(between(n,480,539))'",
+    "-vsync",
+    "vfr",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-pix_fmt",
+    "yuv420p",
+    "-g",
+    "600",
+    "-keyint_min",
+    "600",
+    VFR_FIXTURE,
+  ]);
+}, 30_000);
+
+afterAll(() => {
+  if (existsSync(FIXTURE_DIR)) rmSync(FIXTURE_DIR, { recursive: true, force: true });
+});
+
+describe("extractAllVideoFrames on a VFR source", () => {
+  it("detects the synthesized fixture as VFR", async () => {
+    const md = await extractVideoMetadata(VFR_FIXTURE);
+    expect(md.isVFR).toBe(true);
+  });
+
+  it("produces the expected frame count for a mid-file segment", async () => {
+    const outputDir = join(FIXTURE_DIR, "out-mid-segment");
+    mkdirSync(outputDir, { recursive: true });
+
+    const video: VideoElement = {
+      id: "v1",
+      src: VFR_FIXTURE,
+      start: 0,
+      end: 4,
+      mediaStart: 3,
+      hasAudio: false,
+    };
+
+    const result = await extractAllVideoFrames([video], FIXTURE_DIR, {
+      fps: 30,
+      outputDir,
+    });
+
+    expect(result.errors).toEqual([]);
+    expect(result.extracted).toHaveLength(1);
+    const frames = readdirSync(join(outputDir, "v1")).filter((f) => f.endsWith(".jpg"));
+    // Expect 120 frames for 4s at 30fps. Allow ±1 for rounding at the
+    // boundary; pre-fix behavior produced ~90 frames (a 25% shortfall).
+    expect(frames.length).toBeGreaterThanOrEqual(119);
+    expect(frames.length).toBeLessThanOrEqual(121);
+  }, 60_000);
+
+  it("produces the expected frame count when mediaStart=0 and the full VFR file is used", async () => {
+    const outputDir = join(FIXTURE_DIR, "out-full");
+    mkdirSync(outputDir, { recursive: true });
+
+    const video: VideoElement = {
+      id: "vfull",
+      src: VFR_FIXTURE,
+      start: 0,
+      end: 10,
+      mediaStart: 0,
+      hasAudio: false,
+    };
+
+    const result = await extractAllVideoFrames([video], FIXTURE_DIR, {
+      fps: 30,
+      outputDir,
+    });
+
+    expect(result.errors).toEqual([]);
+    const frames = readdirSync(join(outputDir, "vfull")).filter((f) => f.endsWith(".jpg"));
+    expect(frames.length).toBeGreaterThanOrEqual(299);
+    expect(frames.length).toBeLessThanOrEqual(301);
+  }, 60_000);
+});
diff --git a/packages/engine/src/services/videoFrameExtractor.ts b/packages/engine/src/services/videoFrameExtractor.ts
index b59d7112d..8b19c9b6c 100644
--- a/packages/engine/src/services/videoFrameExtractor.ts
+++ b/packages/engine/src/services/videoFrameExtractor.ts
@@ -296,6 +296,62 @@ async function convertSdrToHdr(
   }
 }
 
+/**
+ * Re-encode a VFR (variable frame rate) video segment to CFR so the downstream
+ * fps filter can extract frames reliably. Screen recordings, phone videos, and
+ * some webcams emit irregular timestamps that cause two failure modes:
+ *   1. Output has fewer frames than expected (e.g. -ss 3 -t 4 produces 90
+ *      frames instead of 120 @ 30fps). FrameLookupTable.getFrameAtTime then
+ *      returns null for late timestamps and the caller freezes on the last
+ *      valid frame.
+ *   2. Large duplicate-frame runs where source PTS don't land on target
+ *      timestamps.
+ *
+ * Only the [startTime, startTime+duration] window is re-encoded, so long
+ * recordings aren't fully transcoded when only a short clip is used.
+ */
+async function convertVfrToCfr(
+  inputPath: string,
+  outputPath: string,
+  targetFps: number,
+  startTime: number,
+  duration: number,
+  signal?: AbortSignal,
+  config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout">>,
+): Promise<void> {
+  const timeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+
+  const args = [
+    "-ss",
+    String(startTime),
+    "-i",
+    inputPath,
+    "-t",
+    String(duration),
+    "-fps_mode",
+    "cfr",
+    "-r",
+    String(targetFps),
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "18",
+    "-c:a",
+    "copy",
+    "-y",
+    outputPath,
+  ];
+
+  const result = await runFfmpeg(args, { signal, timeout });
+  if (!result.success) {
+    throw new Error(
+      `VFR→CFR conversion failed (exit ${result.exitCode}): ${result.stderr.slice(-300)}`,
+    );
+  }
+}
+
 export async function extractAllVideoFrames(
   videos: VideoElement[],
   baseDir: string,
@@ -371,6 +427,56 @@ export async function extractAllVideoFrames(
     }
   }
 
+  // Phase 2b: Normalize VFR (variable frame rate) inputs to CFR. Screen
+  // recordings and phone videos often have irregular timestamps that cause
+  // the fps filter in extractVideoFramesRange to emit fewer frames than
+  // expected, which surfaces downstream as frozen video segments. Only the
+  // used [mediaStart, mediaStart+duration] window is re-encoded, so long
+  // recordings don't pay the full-file transcode cost for a short clip.
+  const vfrNormDir = join(options.outputDir, "_vfr_normalized");
+  let vfrNormDirCreated = false;
+  for (let i = 0; i < resolvedVideos.length; i++) {
+    if (signal?.aborted) break;
+    const entry = resolvedVideos[i];
+    if (!entry) continue;
+    const metadata = await extractVideoMetadata(entry.videoPath);
+    if (!metadata.isVFR) continue;
+
+    let segDuration = entry.video.end - entry.video.start;
+    if (!Number.isFinite(segDuration) || segDuration <= 0) {
+      const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
+      segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+    }
+
+    if (!vfrNormDirCreated) {
+      mkdirSync(vfrNormDir, { recursive: true });
+      vfrNormDirCreated = true;
+    }
+
+    const normalizedPath = join(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    try {
+      await convertVfrToCfr(
+        entry.videoPath,
+        normalizedPath,
+        options.fps,
+        entry.video.mediaStart,
+        segDuration,
+        signal,
+        config,
+      );
+      entry.videoPath = normalizedPath;
+      // Segment-scoped re-encode starts the new file at t=0, so downstream
+      // extraction must seek from 0, not the original mediaStart. Shallow-copy
+      // to avoid mutating the caller's VideoElement.
+      entry.video = { ...entry.video, mediaStart: 0 };
+    } catch (err) {
+      errors.push({
+        videoId: entry.video.id,
+        error: `VFR→CFR conversion failed: ${err instanceof Error ? err.message : String(err)}`,
+      });
+    }
+  }
+
   // Phase 3: Extract frames (parallel)
   const results = await Promise.all(
     resolvedVideos.map(async ({ video, videoPath }) => {
diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index 1cf41cc3d..0750814d1 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -1028,9 +1028,10 @@ export async function compileForRender(
           );
         }
         if (metadata.isVFR) {
-          console.warn(
-            `[Compiler] WARNING: Video "${video.id}" is variable frame rate (VFR). ` +
-              `Screen recordings and phone videos are often VFR, which causes stuttering and frame skipping in renders. Re-encode with: ${reencode}`,
+          console.info(
+            `[Compiler] Video "${video.id}" is variable frame rate (VFR); ` +
+              `the engine will normalize it to CFR before frame extraction. ` +
+              `If rendering feels slow on this video, pre-encode once with: ${reencode}`,
           );
         }
       })

From 13f631c81c97aa17fb41464bb8ccb4ce3d907baf Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 07:06:23 +0000
Subject: [PATCH 2/6] refactor(engine): clean up VFR normalization loop after
 review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Drop the `vfrNormDirCreated` flag; `mkdirSync({recursive:true})` is
  idempotent and cheap.
- Don't re-wrap the `VFR→CFR conversion failed` prefix — `convertVfrToCfr`
  already throws a message with that label; adding it again in the catch
  produced "VFR→CFR conversion failed: VFR→CFR conversion failed (exit 1)".
- Shorten the Phase 2b header comment; the function docstring above
  `convertVfrToCfr` already explains the failure modes and rationale.
- Note which frame windows the VFR fixture's select filter drops so the
  magic numbers are scannable.

No behavior change; 311/311 engine tests still pass.

— Rames Jusso
---
 .../src/services/videoFrameExtractor.test.ts    |  3 +++
 .../engine/src/services/videoFrameExtractor.ts  | 17 ++++-------------
 2 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/packages/engine/src/services/videoFrameExtractor.test.ts b/packages/engine/src/services/videoFrameExtractor.test.ts
index 4cc8eeca8..dab5af647 100644
--- a/packages/engine/src/services/videoFrameExtractor.test.ts
+++ b/packages/engine/src/services/videoFrameExtractor.test.ts
@@ -115,6 +115,9 @@ beforeAll(() => {
   // 10s testsrc2 at 60fps, ~40% of frames dropped via select filter and
   // encoded with -vsync vfr so timestamps are irregular. Declared fps 60,
   // actual average ~36 — well over the 10% threshold used by isVFR.
+  // The select expression drops four 1-second windows (frames 30-89,
+  // 180-239, 330-389, 480-539) to simulate static segments in a screen
+  // recording where no pixels changed.
   runFfmpegSync([
     "-y",
     "-hide_banner",
diff --git a/packages/engine/src/services/videoFrameExtractor.ts b/packages/engine/src/services/videoFrameExtractor.ts
index 8b19c9b6c..a78ac6408 100644
--- a/packages/engine/src/services/videoFrameExtractor.ts
+++ b/packages/engine/src/services/videoFrameExtractor.ts
@@ -427,14 +427,9 @@ export async function extractAllVideoFrames(
     }
   }
 
-  // Phase 2b: Normalize VFR (variable frame rate) inputs to CFR. Screen
-  // recordings and phone videos often have irregular timestamps that cause
-  // the fps filter in extractVideoFramesRange to emit fewer frames than
-  // expected, which surfaces downstream as frozen video segments. Only the
-  // used [mediaStart, mediaStart+duration] window is re-encoded, so long
-  // recordings don't pay the full-file transcode cost for a short clip.
+  // Phase 2b: Re-encode VFR inputs to CFR so the fps filter in Phase 3 produces
+  // the expected frame count. Only the used segment is transcoded.
   const vfrNormDir = join(options.outputDir, "_vfr_normalized");
-  let vfrNormDirCreated = false;
   for (let i = 0; i < resolvedVideos.length; i++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i];
@@ -448,11 +443,7 @@ export async function extractAllVideoFrames(
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
 
-    if (!vfrNormDirCreated) {
-      mkdirSync(vfrNormDir, { recursive: true });
-      vfrNormDirCreated = true;
-    }
-
+    mkdirSync(vfrNormDir, { recursive: true });
     const normalizedPath = join(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
@@ -472,7 +463,7 @@ export async function extractAllVideoFrames(
     } catch (err) {
       errors.push({
         videoId: entry.video.id,
-        error: `VFR→CFR conversion failed: ${err instanceof Error ? err.message : String(err)}`,
+        error: err instanceof Error ? err.message : String(err),
       });
     }
   }

From bcae3778e8ad7bdda3e2286e2a937435d0e152ce Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 18:01:19 +0000
Subject: [PATCH 3/6] test(engine): add VFR regression unit tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a describe block that synthesizes a VFR fixture via ffmpeg and asserts
the extractor produces the expected frame count (no shortfall) and no long
runs of duplicate frames — the user-visible "frozen screen recording"
symptom. Covers both a mid-file segment and the full-file case.

Guarded with describe.skipIf(!HAS_FFMPEG) because the CI Test job on
ubuntu-24.04 and the Windows test-windows job don't install ffmpeg. The
producer-level regression test in packages/producer/tests/vfr-screen-recording/
runs inside Dockerfile.test (which has ffmpeg) and is the primary CI signal
for this bug; these unit tests are supplementary coverage for local and
any ffmpeg-equipped CI environment.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/services/videoFrameExtractor.test.ts  | 140 +++++++++++-------
 1 file changed, 85 insertions(+), 55 deletions(-)

diff --git a/packages/engine/src/services/videoFrameExtractor.test.ts b/packages/engine/src/services/videoFrameExtractor.test.ts
index dab5af647..d41ac47fa 100644
--- a/packages/engine/src/services/videoFrameExtractor.test.ts
+++ b/packages/engine/src/services/videoFrameExtractor.test.ts
@@ -1,5 +1,6 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -10,6 +11,15 @@ import {
   type VideoElement,
 } from "./videoFrameExtractor.js";
 import { extractVideoMetadata } from "../utils/ffprobe.js";
+import { runFfmpeg } from "../utils/runFfmpeg.js";
+
+// ffmpeg is not preinstalled on GitHub's ubuntu-24.04 runners. The producer
+// regression test at packages/producer/tests/vfr-screen-recording/ runs inside
+// Dockerfile.test (which does include ffmpeg) and is the primary CI signal
+// for this bug. Locally and in any CI job with ffmpeg on PATH, the tests
+// below run too — they exercise the extractor in isolation against a
+// synthesized VFR fixture.
+const HAS_FFMPEG = spawnSync("ffmpeg", ["-version"]).status === 0;
 
 describe("parseVideoElements", () => {
   it("parses videos without an id or data-start attribute", () => {
@@ -101,56 +111,56 @@ describe("parseImageElements", () => {
 // and the compositor holds the last valid frame, which the user perceives as
 // the video freezing. extractAllVideoFrames normalizes VFR sources to CFR
 // before extraction to fix this.
-const FIXTURE_DIR = mkdtempSync(join(tmpdir(), "hf-vfr-test-"));
-const VFR_FIXTURE = join(FIXTURE_DIR, "vfr_screen.mp4");
-
-function runFfmpegSync(args: string[]): void {
-  const r = spawnSync("ffmpeg", args, { encoding: "utf8" });
-  if (r.status !== 0) {
-    throw new Error(`ffmpeg failed (${r.status}): ${r.stderr.slice(-400)}`);
-  }
-}
-
-beforeAll(() => {
-  // 10s testsrc2 at 60fps, ~40% of frames dropped via select filter and
-  // encoded with -vsync vfr so timestamps are irregular. Declared fps 60,
-  // actual average ~36 — well over the 10% threshold used by isVFR.
-  // The select expression drops four 1-second windows (frames 30-89,
-  // 180-239, 330-389, 480-539) to simulate static segments in a screen
-  // recording where no pixels changed.
-  runFfmpegSync([
-    "-y",
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-f",
-    "lavfi",
-    "-i",
-    "testsrc2=s=320x180:d=10:rate=60",
-    "-vf",
-    "drawtext=text='n=%{n}':fontsize=24:fontcolor=white:x=10:y=10:box=1:boxcolor=black@0.6," +
-      "select='not(between(n,30,89))*not(between(n,180,239))*not(between(n,330,389))*not(between(n,480,539))'",
-    "-vsync",
-    "vfr",
-    "-c:v",
-    "libx264",
-    "-preset",
-    "ultrafast",
-    "-pix_fmt",
-    "yuv420p",
-    "-g",
-    "600",
-    "-keyint_min",
-    "600",
-    VFR_FIXTURE,
-  ]);
-}, 30_000);
-
-afterAll(() => {
-  if (existsSync(FIXTURE_DIR)) rmSync(FIXTURE_DIR, { recursive: true, force: true });
-});
+describe.skipIf(!HAS_FFMPEG)("extractAllVideoFrames on a VFR source", () => {
+  const FIXTURE_DIR = mkdtempSync(join(tmpdir(), "hf-vfr-test-"));
+  const VFR_FIXTURE = join(FIXTURE_DIR, "vfr_screen.mp4");
+
+  beforeAll(async () => {
+    // 10s testsrc2 at 60fps, ~40% of frames dropped via select filter and
+    // encoded with -vsync vfr so timestamps are irregular. Declared fps 60,
+    // actual average ~36 — well over the 10% threshold used by isVFR.
+    // The select expression drops four 1-second windows (frames 30-89,
+    // 180-239, 330-389, 480-539) to simulate static segments in a screen
+    // recording where no pixels changed.
+    // -g/-keyint_min 600 forces a single keyframe so mid-segment seeks in the
+    // mediaStart=3 test don't snap to an intermediate IDR and drift the count.
+    const result = await runFfmpeg([
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "lavfi",
+      "-i",
+      "testsrc2=s=320x180:d=10:rate=60",
+      "-vf",
+      "drawtext=text='n=%{n}':fontsize=24:fontcolor=white:x=10:y=10:box=1:boxcolor=black@0.6," +
+        "select='not(between(n,30,89))*not(between(n,180,239))*not(between(n,330,389))*not(between(n,480,539))'",
+      "-vsync",
+      "vfr",
+      "-c:v",
+      "libx264",
+      "-preset",
+      "ultrafast",
+      "-pix_fmt",
+      "yuv420p",
+      "-g",
+      "600",
+      "-keyint_min",
+      "600",
+      VFR_FIXTURE,
+    ]);
+    if (!result.success) {
+      throw new Error(
+        `ffmpeg fixture synthesis failed (${result.exitCode}): ${result.stderr.slice(-400)}`,
+      );
+    }
+  }, 30_000);
+
+  afterAll(() => {
+    if (existsSync(FIXTURE_DIR)) rmSync(FIXTURE_DIR, { recursive: true, force: true });
+  });
 
-describe("extractAllVideoFrames on a VFR source", () => {
   it("detects the synthesized fixture as VFR", async () => {
     const md = await extractVideoMetadata(VFR_FIXTURE);
     expect(md.isVFR).toBe(true);
@@ -177,13 +187,18 @@ describe("extractAllVideoFrames on a VFR source", () => {
     expect(result.errors).toEqual([]);
     expect(result.extracted).toHaveLength(1);
     const frames = readdirSync(join(outputDir, "v1")).filter((f) => f.endsWith(".jpg"));
-    // Expect 120 frames for 4s at 30fps. Allow ±1 for rounding at the
-    // boundary; pre-fix behavior produced ~90 frames (a 25% shortfall).
+    // Pre-fix behavior produced ~90 frames (a 25% shortfall).
     expect(frames.length).toBeGreaterThanOrEqual(119);
     expect(frames.length).toBeLessThanOrEqual(121);
   }, 60_000);
 
-  it("produces the expected frame count when mediaStart=0 and the full VFR file is used", async () => {
+  // Asserts both frame-count correctness and that we don't emit long runs of
+  // byte-identical "duplicate" frames — the user-visible "frozen screen
+  // recording" symptom. Pre-fix duplicate rate on this fixture is ~38%
+  // (116/300); on the actual reporter's ScreenCaptureKit clip, 18–44% across
+  // segments. <10% threshold leaves margin across ffmpeg versions without
+  // letting a regression slip through.
+  it("produces the full frame count and no duplicate-frame runs on the full VFR file", async () => {
     const outputDir = join(FIXTURE_DIR, "out-full");
     mkdirSync(outputDir, { recursive: true });
 
@@ -200,10 +215,25 @@ describe("extractAllVideoFrames on a VFR source", () => {
       fps: 30,
       outputDir,
     });
-
     expect(result.errors).toEqual([]);
-    const frames = readdirSync(join(outputDir, "vfull")).filter((f) => f.endsWith(".jpg"));
+
+    const frameDir = join(outputDir, "vfull");
+    const frames = readdirSync(frameDir)
+      .filter((f) => f.endsWith(".jpg"))
+      .sort();
     expect(frames.length).toBeGreaterThanOrEqual(299);
     expect(frames.length).toBeLessThanOrEqual(301);
+
+    let prevHash: string | null = null;
+    let duplicates = 0;
+    for (const f of frames) {
+      const hash = createHash("sha256")
+        .update(readFileSync(join(frameDir, f)))
+        .digest("hex");
+      if (hash === prevHash) duplicates += 1;
+      prevHash = hash;
+    }
+    const duplicateRate = duplicates / frames.length;
+    expect(duplicateRate).toBeLessThan(0.1);
   }, 60_000);
 });

From 5b1f63f1d67cb1f49f5fc7610a479ce462e34051 Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 18:01:39 +0000
Subject: [PATCH 4/6] test(producer): add vfr-screen-recording regression test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

End-to-end CI regression coverage for PR #360 via the existing
regression-harness: renders a 3s composition containing a real macOS
ScreenCaptureKit clip (r_frame_rate=120, avg≈36fps) seeked to
mediaStart=1, then PSNR-compares against a committed output.mp4.

Fixture src/clip.mp4 (108 KB) is a 5-second excerpt downscaled to 480×332
with -fps_mode passthrough to preserve the VFR timestamps. Content is the
public hyperframes OSS repo root page — see NOTICE.md for provenance.

With the fix applied, all 100 PSNR checkpoints pass. With the fix reverted,
66 of 100 fail (PSNR drops from ~43 dB to ~20 dB in the duplicate-frame
windows). Tagged "regression,video,vfr" so it runs in the fast shard
of .github/workflows/regression.yml automatically.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../tests/vfr-screen-recording/NOTICE.md      | 22 ++++++
 .../tests/vfr-screen-recording/meta.json      | 13 ++++
 .../vfr-screen-recording/output/compiled.html | 72 +++++++++++++++++++
 .../vfr-screen-recording/output/output.mp4    |  3 +
 .../tests/vfr-screen-recording/src/clip.mp4   |  3 +
 .../tests/vfr-screen-recording/src/index.html | 69 ++++++++++++++++++
 6 files changed, 182 insertions(+)
 create mode 100644 packages/producer/tests/vfr-screen-recording/NOTICE.md
 create mode 100644 packages/producer/tests/vfr-screen-recording/meta.json
 create mode 100644 packages/producer/tests/vfr-screen-recording/output/compiled.html
 create mode 100644 packages/producer/tests/vfr-screen-recording/output/output.mp4
 create mode 100644 packages/producer/tests/vfr-screen-recording/src/clip.mp4
 create mode 100644 packages/producer/tests/vfr-screen-recording/src/index.html

diff --git a/packages/producer/tests/vfr-screen-recording/NOTICE.md b/packages/producer/tests/vfr-screen-recording/NOTICE.md
new file mode 100644
index 000000000..6c2635f73
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/NOTICE.md
@@ -0,0 +1,22 @@
+# Source attribution
+
+`src/clip.mp4` is a 5-second excerpt from a macOS ScreenCaptureKit (ReplayKit)
+recording, used here as a regression fixture for the VFR (variable-frame-rate)
+freeze bug fixed in PR #360.
+
+- **Original duration**: 21s, recorded via `ReplayKitRecording` (the
+  `com.apple.quicktime.author` QuickTime tag identifies this).
+- **Excerpt**: 16s–21s of the original, downscaled from 2746×1902 to 480×332,
+  re-encoded with `ffmpeg -fps_mode passthrough -c:v libx264 -preset slow
+  -crf 28 -an` to preserve the original VFR timestamps.
+- **Recorded content**: the public `heygen-com/hyperframes` GitHub repo root
+  page. No private, proprietary, or user-identifying content.
+
+## Properties preserved from the original
+
+- `r_frame_rate`: 120/1
+- `avg_frame_rate`: ~36.1fps (21720/601)
+- `isVFR`: true (70% delta vs `r_frame_rate`, well over the 10% threshold in
+  `ffprobe.ts`)
+- Pre-fix duplicate-frame rate: ~34% on a mid-file 3s segment extracted at
+  30fps — matches the 18–44% observed across segments of the full recording.
diff --git a/packages/producer/tests/vfr-screen-recording/meta.json b/packages/producer/tests/vfr-screen-recording/meta.json
new file mode 100644
index 000000000..643dc2e41
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/meta.json
@@ -0,0 +1,13 @@
+{
+  "name": "vfr-screen-recording",
+  "description": "Regression test for the VFR (variable-frame-rate) screen-recording freeze bug (PR #360). Renders a 3-second composition with a macOS ScreenCaptureKit clip (r_frame_rate=120, avg≈36fps) seeked to mediaStart=1. Pre-fix, the fps filter emitted long runs of duplicate frames that the compositor held as a frozen image; post-fix, VFR→CFR normalization keeps frame-accurate timing.",
+  "tags": ["regression", "video", "vfr"],
+  "minPsnr": 28,
+  "maxFrameFailures": 2,
+  "minAudioCorrelation": 0,
+  "maxAudioLagWindows": 1,
+  "renderConfig": {
+    "fps": 30,
+    "workers": 1
+  }
+}
diff --git a/packages/producer/tests/vfr-screen-recording/output/compiled.html b/packages/producer/tests/vfr-screen-recording/output/compiled.html
new file mode 100644
index 000000000..5d2dcc0c4
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/output/compiled.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head><style data-hyperframes-deterministic-fonts="true">@font-face {
+  font-family: "Segoe UI";
+  src: url("data:font/woff2;base64,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") format("woff2");
+  font-style: normal;
+  font-weight: 400;
+  font-display: block;
+}
+
+@font-face {
+  font-family: "Segoe UI";
+  src: url("data:font/woff2;base64,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") format("woff2");
+  font-style: normal;
+  font-weight: 700;
+  font-display: block;
+}
+
+@font-face {
+  font-family: "Segoe UI";
+  src: url("data:font/woff2;base64,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") format("woff2");
+  font-style: normal;
+  font-weight: 900;
+  font-display: block;
+}</style>
+    <meta charset="UTF-8">
+    <title>VFR Screen Recording Regression</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        padding: 0;
+        background: #000;
+      }
+      #main {
+        position: relative;
+        width: 480px;
+        height: 332px;
+        overflow: hidden;
+      }
+      #clip {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+      }
+      #label {
+        position: absolute;
+        top: 16px;
+        left: 16px;
+        z-index: 10;
+        padding: 6px 12px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        font-size: 16px;
+        font-weight: 700;
+        color: #ffffff;
+        background: rgba(0, 0, 0, 0.55);
+        border-radius: 6px;
+        letter-spacing: 0.04em;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="main" data-composition-id="vfr-screen-recording" data-start="0" data-duration="3" data-width="480" data-height="332">
+      <video id="clip" class="clip" data-start="0" data-duration="3" data-media-start="1" data-track-index="0" src="clip.mp4" muted playsinline data-end="3" data-has-audio="true"></video>
+
+      <div id="label">VFR</div>
+    </div>
+    
+  <script>window.__timelines = window.__timelines || {};</script></body>
+</html>
diff --git a/packages/producer/tests/vfr-screen-recording/output/output.mp4 b/packages/producer/tests/vfr-screen-recording/output/output.mp4
new file mode 100644
index 000000000..77b569581
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/output/output.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44893780f480c0a43f91cff9dc186f08047f504cdcc6a8e9020605dc93c5bfc3
+size 414474
diff --git a/packages/producer/tests/vfr-screen-recording/src/clip.mp4 b/packages/producer/tests/vfr-screen-recording/src/clip.mp4
new file mode 100644
index 000000000..091ae23d3
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/src/clip.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:602459ff96bcd7cd4bf306935b857676434bb65b2a1e395d30ce19a225bbd359
+size 108396
diff --git a/packages/producer/tests/vfr-screen-recording/src/index.html b/packages/producer/tests/vfr-screen-recording/src/index.html
new file mode 100644
index 000000000..ea409fdcd
--- /dev/null
+++ b/packages/producer/tests/vfr-screen-recording/src/index.html
@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>VFR Screen Recording Regression</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        padding: 0;
+        background: #000;
+      }
+      #main {
+        position: relative;
+        width: 480px;
+        height: 332px;
+        overflow: hidden;
+      }
+      #clip {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+      }
+      #label {
+        position: absolute;
+        top: 16px;
+        left: 16px;
+        z-index: 10;
+        padding: 6px 12px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        font-size: 16px;
+        font-weight: 700;
+        color: #ffffff;
+        background: rgba(0, 0, 0, 0.55);
+        border-radius: 6px;
+        letter-spacing: 0.04em;
+      }
+    </style>
+  </head>
+  <body>
+    <div
+      id="main"
+      data-composition-id="vfr-screen-recording"
+      data-start="0"
+      data-duration="3"
+      data-width="480"
+      data-height="332"
+    >
+      <video
+        id="clip"
+        class="clip"
+        data-start="0"
+        data-duration="3"
+        data-media-start="1"
+        data-track-index="0"
+        src="clip.mp4"
+        muted
+        playsinline
+      ></video>
+
+      <div id="label">VFR</div>
+    </div>
+    <script>
+      window.__timelines = window.__timelines || {};
+    </script>
+  </body>
+</html>

From 7c7bccc3757c2c7c7ae51b435113e15fb5e1cf85 Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 18:28:16 +0000
Subject: [PATCH 5/6] test(producer): regenerate vfr-screen-recording baseline
 in Docker
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The committed golden output.mp4 was initially rendered on the host machine;
CI runs the renderer inside Dockerfile.test with a different Chrome +
ffmpeg build, producing pixel-level drift that failed PSNR at 54/100
checkpoints (~20 dB vs 41 dB in the VFR sparse-content windows). Both
renders are valid — the VFR source has inherent sampling ambiguity in
static segments, and different Chrome/ffmpeg builds make different valid
choices.

Regenerated the baseline via `bun run docker:test:update vfr-screen-recording`
so it matches the Docker environment CI actually uses. Matches the flow
the existing sub-composition-video, hdr-pq, etc. baselines were captured
with.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../producer/tests/vfr-screen-recording/output/output.mp4     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/producer/tests/vfr-screen-recording/output/output.mp4 b/packages/producer/tests/vfr-screen-recording/output/output.mp4
index 77b569581..4e8f676d0 100644
--- a/packages/producer/tests/vfr-screen-recording/output/output.mp4
+++ b/packages/producer/tests/vfr-screen-recording/output/output.mp4
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:44893780f480c0a43f91cff9dc186f08047f504cdcc6a8e9020605dc93c5bfc3
-size 414474
+oid sha256:7aec7945d08be6b3c69464d9cf89445c44d52c9e0f89bad367592268964b2b22
+size 472149

From 2b4ff554def2b27fd317d6dfd85199a760566291 Mon Sep 17 00:00:00 2001
From: James <james.russo@heygen.com>
Date: Tue, 21 Apr 2026 18:37:44 +0000
Subject: [PATCH 6/6] docs: document that producer test baselines must be
 captured in Docker

Hit this 2026-04-21 with the vfr-screen-recording regression test:
host-generated output.mp4 baseline tripped 54/100 PSNR checkpoints in CI
because Chrome + ffmpeg drift between the host and Dockerfile.test.

Document the `bun run --cwd packages/producer docker:test:update <name>`
flow so future contributors don't repeat the mistake.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index b65f7b2a0..e9fc57bc4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -45,6 +45,26 @@ When adding a new CLI command:
 5. **Document it** in `docs/packages/cli.mdx` — add a section with usage examples and flags.
 6. Validate by running `npx tsx packages/cli/src/cli.ts --help` (command appears in the list) and `npx tsx packages/cli/src/cli.ts <name> --help` (examples appear).
 
+### Regression Test Golden Baselines (producer)
+
+`packages/producer/tests/<name>/output/output.mp4` baselines MUST be generated
+inside `Dockerfile.test`, not on your host. CI renders inside that Docker image
+with a specific Chrome + ffmpeg build; pixel-level output drifts across
+different host Chrome/ffmpeg versions and will fail PSNR at dozens of
+checkpoints even when the code is correct.
+
+```bash
+# Build the test image once:
+docker build -t hyperframes-producer:test -f Dockerfile.test .
+
+# Generate or update a baseline (runs the harness with --update inside Docker):
+bun run --cwd packages/producer docker:test:update <test-name>
+```
+
+Never run `bun run --cwd packages/producer test:update` directly from the
+host to capture a baseline that will be committed — the resulting output.mp4
+will not match CI. Use it only for local-only experimentation.
+
 ## Skills
 
 Composition authoring (not repo development) is guided by skills installed via `npx skills add heygen-com/hyperframes`. See `skills/` for source. Invoke `/hyperframes`, `/hyperframes-cli`, `/hyperframes-registry`, or `/gsap` when authoring compositions. When a user provides a website URL and wants a video, invoke `/website-to-hyperframes` — it runs the full 7-step capture-to-video pipeline.