Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
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.tsindex 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.tsindex 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.tsindex 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 "./captureFailuexport 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.tsindex 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-hitdiff --git a/packages/engine/src/services/videoFrameInjector.ts b/packages/engine/src/services/videoFrameInjector.tsindex 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.mjsindex 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.tsnew file mode 100644index 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.jsonindex 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",