Skip to content

Write HTML. Render video. Built for agents.

fix(engine): motion blur works over video by holding each video frame across samples (#5150)

Miguel Ángel3b89bfe8a71f
diff --git a/packages/engine/src/services/frameCapture-gpuCompletion.test.ts b/packages/engine/src/services/frameCapture-gpuCompletion.test.ts
index 0145762781..ab566d3a7e 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, quantizedTime, heldVideoTime)",
+ );
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..1a6f3fa1d2 100644
--- a/packages/engine/src/services/frameCapture-motionBlur.test.ts
+++ b/packages/engine/src/services/frameCapture-motionBlur.test.ts
@@ -317,10 +317,59 @@ 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)", () => {
+ function recordInjections() {
+ const calls: Array<{ time: number; held: number | undefined; seeksBefore: number }> = [];
+ const hook: CaptureSession["onBeforeCapture"] = async (_page, 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 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);
+
+ // 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 () => {
+ const { calls, hook } = recordInjections();
+
+ await captureFrameToBuffer(
+ makeSession({ onBeforeCapture: hook, motionBlur: resolveMotionBlurPlan({}) ?? undefined }),
+ 10,
+ 10 / 30,
+ );
+
+ expect(calls.map((call) => call.time)).toEqual([10 / 30, ...sampleSeekTimes()]);
+ expect(calls.map((call) => call.held)).toEqual(Array(calls.length).fill(10 / 30));
+ });
+
+ it("holds nothing on a frame without blur", async () => {
+ const { calls, hook } = recordInjections();
+
+ await captureFrameToBuffer(
+ makeSession({ onBeforeCapture: hook, motionBlur: undefined }),
+ 10,
+ 10 / 30,
+ );
+
+ 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 5ec6fd1deb..c864018f4b 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -102,8 +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. */
-export type BeforeCaptureHook = (page: Page, time: number) => Promise<void>;
+/** 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 interface CaptureSession {
browser: Browser;
@@ -2805,6 +2807,7 @@ async function prepareFrameForCapture(
frameIndex: number,
time: number,
seekOptions?: HfSeekOptions,
+ heldVideoTime?: number,
): Promise<{
quantizedTime: number;
seekMs: number;
@@ -2835,7 +2838,7 @@ async function prepareFrameForCapture(
// replacements for <video> elements.
const beforeCaptureStart = Date.now();
if (session.onBeforeCapture) {
- await session.onBeforeCapture(page, quantizedTime);
+ await session.onBeforeCapture(page, quantizedTime, heldVideoTime);
}
await waitForPendingSeekCompletion(page);
await page.evaluate(async () => {
@@ -3879,9 +3882,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. `<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.
*/
export function resolveSessionMotionBlur(session: CaptureSession): MotionBlurPlan | undefined {
const plan = resolveMotionBlurPlan(session.options.motionBlur);
@@ -3896,11 +3897,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;
}
@@ -3919,6 +3915,7 @@ async function captureFrameSurface(
frameIndex: number,
time: number,
seekOptions?: HfSeekOptions,
+ heldVideoTime?: number,
): Promise<CapturedSurface> {
const { page, options } = session;
const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
@@ -3926,6 +3923,7 @@ async function captureFrameSurface(
frameIndex,
time,
seekOptions,
+ heldVideoTime,
);
const screenshotStart = Date.now();
@@ -4112,6 +4110,7 @@ async function resolveAdaptiveSampleCount(
plan: MotionBlurPlan,
fps: number,
sampleSeek: HfSeekOptions,
+ frameTime: number,
): Promise<{
samplesPerFrame: number;
seekMs: number;
@@ -4127,8 +4126,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,
@@ -4160,6 +4159,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,
@@ -4175,6 +4181,7 @@ async function captureAccumulatedFrame(
plan,
fps,
sampleSeek,
+ frameTime,
);
samplesPerFrame = chosen.samplesPerFrame;
totals.seekMs += chosen.seekMs;
@@ -4184,7 +4191,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/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/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..cb9089235b
--- /dev/null
+++ b/packages/producer/src/services/render/motionBlurVideo.integration.test.ts
@@ -0,0 +1,239 @@
+// 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 {
+ cpSync,
+ mkdirSync,
+ mkdtempSync,
+ readdirSync,
+ readFileSync,
+ rmSync,
+ writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+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;
+ 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;
+ }
+ @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>
+`;
+
+// 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 = join(
+ dirname(fileURLToPath(import.meta.url)),
+ "../../../tests/nested-sequential-video-local-start/src",
+);
+const CUT_FPS = 24;
+const CUT_FRAME = 24;
+const CUT_FRAME_COUNT = 48;
+
+let root: string;
+
+async function renderFrames(
+ name: string,
+ motionBlur?: MotionBlurOptions,
+ projectDir = root,
+ fps = FPS,
+): Promise<Buffer[]> {
+ const outputDir = join(root, name);
+ const job = createRenderJob({
+ fps,
+ quality: "draft",
+ format: "png-sequence",
+ hdrMode: "force-sdr",
+ workers: 1,
+ motionBlur,
+ logger: { info() {}, warn() {}, error() {}, debug() {} },
+ producerConfig: resolveConfig({ browserGpuMode: "software" }),
+ });
+ 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);
+ 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[];
+ let cutPlain: Buffer[];
+ let cutBlurred: 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 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(() => {
+ 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("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(plainLevel).toBeGreaterThan(50);
+ 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++) {
+ expect(blurredAgain[i]!.equals(blurred[i]!), `frame ${i}`).toBe(true);
+ }
+ });
+});
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",