Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
perf(producer): multi-worker mp4 renders start encoding while frames are still being captured (#5952)
Miguel Ángeleec3c51d7509
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.tsindex 26fd4571d7..36b984d745 100644--- a/packages/engine/src/index.ts+++ b/packages/engine/src/index.ts@@ -295,6 +295,7 @@ export {type WorkerResult,type WorkerSizing,type WorkerSizingBound,+ type LandedFrame,type ParallelProgress,} from "./services/parallelCoordinator.js";diff --git a/packages/engine/src/services/parallelCoordinator.ts b/packages/engine/src/services/parallelCoordinator.tsindex adf6699fa5..d970fa191d 100644--- a/packages/engine/src/services/parallelCoordinator.ts+++ b/packages/engine/src/services/parallelCoordinator.ts@@ -88,6 +88,14 @@ export interface ParallelProgress {workerProgress: Map<number, number>;/** Latest lifecycle transition; absent on ordinary completed-frame updates. */latestWorkerPhase?: ParallelWorkerPhaseDiagnostic;+ /** Disk capture only: the frame file this update finished writing, readable from now on. */+ landedFrame?: LandedFrame;+}++/** A captured frame file: `index` is its file index (`frame_<index>`), `path` where it was written. */+export interface LandedFrame {+ index: number;+ path: string;}export type ParallelWorkerPhase =@@ -552,7 +560,9 @@ async function captureFrameRange(task: WorkerTask,captureOptions: CaptureOptions,signal: AbortSignal | undefined,- onFrameCaptured: ((workerId: number, frameIndex: number) => void) | undefined,+ onFrameCaptured:+ | ((workerId: number, frameIndex: number, landedFrame?: LandedFrame) => void)+ | undefined,onFrameBuffer:| ((frameIndex: number, buffer: Buffer, session: CaptureSession) => Promise<void>)| undefined,@@ -645,18 +655,20 @@ async function captureFrameRange(const time = (i * captureOptions.fps.den) / captureOptions.fps.num;const fileFrameIdx = i - outputOffset;+ let landedFrame: LandedFrame | undefined;if (onFrameBuffer) {const { buffer } = await runCaptureOperation("frame_capture", i, () =>captureFrameToBuffer(session, fileFrameIdx, time),);await onFrameBuffer(i, buffer, session);} else {- await runCaptureOperation("frame_capture", i, () =>+ const { path } = await runCaptureOperation("frame_capture", i, () =>captureFrame(session, fileFrameIdx, time),);+ landedFrame = { index: fileFrameIdx, path };}framesCaptured++;- if (onFrameCaptured) onFrameCaptured(task.workerId, i);+ if (onFrameCaptured) onFrameCaptured(task.workerId, i, landedFrame);}return framesCaptured;}@@ -824,7 +836,7 @@ async function executeWorkerTask(captureOptions: CaptureOptions,createBeforeCaptureHook: () => BeforeCaptureHook | null,signal?: AbortSignal,- onFrameCaptured?: (workerId: number, frameIndex: number) => void,+ onFrameCaptured?: (workerId: number, frameIndex: number, landedFrame?: LandedFrame) => void,onFrameBuffer?: (frameIndex: number, buffer: Buffer, session: CaptureSession) => Promise<void>,config?: Partial<EngineConfig>,parallel?: boolean,@@ -1066,7 +1078,7 @@ export async function executeParallelCapture(for (const task of tasks) workerProgress.set(task.workerId, 0);- const onFrameCaptured = (workerId: number, _frameIndex: number) => {+ const onFrameCaptured = (workerId: number, _frameIndex: number, landedFrame?: LandedFrame) => {const current = workerProgress.get(workerId) || 0;workerProgress.set(workerId, current + 1);@@ -1077,6 +1089,7 @@ export async function executeParallelCapture(capturedFrames,activeWorkers: tasks.length,workerProgress: new Map(workerProgress),+ ...(landedFrame && { landedFrame }),});}};diff --git a/packages/producer/scripts/test-classification.mjs b/packages/producer/scripts/test-classification.mjsindex cf3937ba88..7ee13f95ca 100644--- a/packages/producer/scripts/test-classification.mjs+++ b/packages/producer/scripts/test-classification.mjs@@ -37,6 +37,7 @@ const INTEGRATION_TEST_FILES = new Set(["src/services/render/renderCancel.integration.test.ts","src/services/render/segmentedColorGrading.integration.test.ts","src/services/render/stages/compileStage.mediaType.test.ts",+ "src/services/render/stages/encodeWhileCapturing.test.ts","src/services/render/stages/gifEncodeArgs.test.ts","src/services/videoFrameBorderClip.test.ts","src/utils/audioRegression.test.ts",diff --git a/packages/producer/src/services/render/stages/captureStage.ts b/packages/producer/src/services/render/stages/captureStage.tsindex a1963b9b26..c949ec1faa 100644--- a/packages/producer/src/services/render/stages/captureStage.ts+++ b/packages/producer/src/services/render/stages/captureStage.ts@@ -45,6 +45,7 @@ import {type CapturePerfSummary,type CaptureSession,type EngineConfig,+ type LandedFrame,captureFrame,captureFrameToBufferPipelined,verifyDiskDrawElementSamples,@@ -118,6 +119,7 @@ export interface CaptureStageInput {* When set, `endFrame - startFrame` MUST equal `totalFrames`.*/frameRange?: { startFrame: number; endFrame: number };+ onFrameLanded?: (frame: LandedFrame) => void;}export interface CaptureStageResult {@@ -408,6 +410,7 @@ export async function runCaptureStage(input: CaptureStageInput): Promise<Captureif (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);return;}+ if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);job.framesRendered = progress.capturedFrames;checkDiskProjection(progress.capturedFrames);const frameProgress = progress.capturedFrames / progress.totalFrames;diff --git a/packages/producer/src/services/render/stages/encodeStage.test.ts b/packages/producer/src/services/render/stages/encodeStage.test.tsindex 74858dab71..0469fe4303 100644--- a/packages/producer/src/services/render/stages/encodeStage.test.ts+++ b/packages/producer/src/services/render/stages/encodeStage.test.ts@@ -46,6 +46,7 @@ mock.module("@hyperframes/engine", () => ({}),resolveConfig: () => resolvedEngineConfig,runFfmpeg: runFfmpegMock,+ spawnStreamingEncoder: mock(),}));const tempDirs: string[] = [];diff --git a/packages/producer/src/services/render/stages/encodeStage.ts b/packages/producer/src/services/render/stages/encodeStage.tsindex 3c9465f33b..e5fda1acbc 100644--- a/packages/producer/src/services/render/stages/encodeStage.ts+++ b/packages/producer/src/services/render/stages/encodeStage.ts@@ -26,6 +26,10 @@* branch + same args.* - `Encoding failed: <err>` throws on the encoder's* `success: false`.+ *+ * `encodeWhileCapturing` runs the same mp4 encode during multi-worker disk+ * capture, feeding frames in order as they land, and falls back to this+ * stage's encode if it fails.*/import {@@ -38,6 +42,7 @@ import {statSync,writeFileSync,} from "node:fs";+import { readFile } from "node:fs/promises";import { dirname, join } from "node:path";import {encodeFramesChunkedConcat,@@ -47,8 +52,10 @@ import {MIXED_AUDIO_FILENAME,resolveConfig,runFfmpeg,+ spawnStreamingEncoder,type EngineConfig,type EncodeResult,+ type LandedFrame,} from "@hyperframes/engine";import {clearGifFramesBeforeNext,@@ -56,7 +63,7 @@ import {type Fps,} from "@hyperframes/core";import type { ProducerLogger } from "../../../logger.js";-import { formatExportFrameName } from "../../../utils/paths.js";+import { formatCaptureFrameName, formatExportFrameName } from "../../../utils/paths.js";import type { ProgressCallback, RenderJob } from "../../renderOrchestrator.js";import {buildGifPalettegenArgs,@@ -108,7 +115,8 @@ export interface EncodeStageInput {enableChunkedEncode: boolean;chunkedEncodeSize: number;/** Already-resolved engine config from the orchestrator; direct callers fall back below. */- engineConfig?: Pick<EngineConfig, "ffmpegEncodeTimeout" | "vp9CpuUsed">;+ engineConfig?: Pick<EngineConfig, "ffmpegEncodeTimeout" | "vp9CpuUsed"> &+ Partial<Pick<EngineConfig, "ffmpegStreamingTimeout">>;abortSignal: AbortSignal | undefined;assertNotAborted: () => void;onProgress?: ProgressCallback;@@ -254,6 +262,171 @@ function startEncodeProgress(return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);}+function resolveEngineConfig(input: EncodeStageInput) {+ return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();+}++function videoEncoderOptions(input: EncodeStageInput, engineCfg: Pick<EngineConfig, "vp9CpuUsed">) {+ const { job, preset } = input;+ return {+ fps: job.config.fps,+ width: input.width,+ height: input.height,+ codec: preset.codec,+ preset: preset.preset,+ quality: input.effectiveQuality,+ bitrate: input.effectiveBitrate,+ pixelFormat: preset.pixelFormat,+ vp9CpuUsed: engineCfg.vp9CpuUsed,+ useGpu: job.config.useGpu,+ hdr: preset.hdr,+ // Distributed chunk renders pass these so the encoder writes closed-GOP+ // keyframes that survive `-f concat -c copy` at assemble time. In-process+ // renders leave both undefined → preserves the existing open-GOP output.+ lockGopForChunkConcat: input.lockGopForChunkConcat === true,+ gopSize: input.gopSize,+ };+}++/**+ * Software libx264 from JPEG only: the streaming encoder then runs the disk encoder's+ * arguments (same bytes). Needs a core the capture workers leave free.+ */+export function canEncodeWhileCapturing(+ input: EncodeStageInput,+ workerCount: number,+ cpuCount: number,+): boolean {+ return (+ workerCount > 1 &&+ workerCount < cpuCount &&+ !input.isPngSequence &&+ !input.isGif &&+ !input.enableChunkedEncode &&+ input.preset.codec === "h264" &&+ !input.preset.hdr &&+ input.job.config.useGpu !== true &&+ input.captureImageFormat === "jpeg" &&+ input.lockGopForChunkConcat !== true+ );+}++export interface EncodeWhileCapturing {+ /** A worker finished writing this frame. */+ onFrameLanded: (frame: LandedFrame) => void;+ /** Capture succeeded and every frame is in `framesDir`: encode the rest. */+ finish: () => Promise<EncodeStageResult>;+ /** Capture failed: stop the encoder and wait for it to exit. */+ abort: () => Promise<void>;+ /** Frames handed to the encoder so far. */+ readonly framesFed: number;+}++/** The merge renames a worker's frame into `framesDir` at any moment; rename is atomic, so it is at one of the two. */+async function readLandedFrame(workerPath: string | undefined, mergedPath: string) {+ if (workerPath !== undefined) {+ try {+ return await readFile(workerPath);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;+ }+ }+ return readFile(mergedPath);+}++/**+ * Feeds frames 0, 1, 2… to the encoder as each lands; capture never waits on it.+ * On failure `finish` re-runs `runEncodeStage` on the same frames.+ */+export function encodeWhileCapturing(+ input: EncodeStageInput,+ totalFrames: number,+): EncodeWhileCapturing {+ const engineCfg = resolveEngineConfig(input);+ const stop = new AbortController();+ const signal = input.abortSignal+ ? AbortSignal.any([input.abortSignal, stop.signal])+ : stop.signal;+ const landed = new Map<number, string>();+ let captureDone = false;+ let framesFed = 0;+ let wake: (() => void) | null = null;+ const nudge = () => {+ wake?.();+ wake = null;+ };+ signal.addEventListener("abort", nudge, { once: true });+ let reportFed = null as ((frames?: number) => void) | null;++ const encoder = spawnStreamingEncoder(+ input.videoOnlyPath,+ { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },+ signal,+ engineCfg,+ );+ const fed: Promise<unknown> = (async () => {+ const stream = await encoder;+ for (let next = 0; next < totalFrames; next++) {+ while (!landed.has(next) && !captureDone && !signal.aborted) {+ await new Promise<void>((resolve) => (wake = resolve));+ }+ if (signal.aborted) return;+ const mergedPath = join(input.framesDir, formatCaptureFrameName(next, "jpg"));+ const frame = await readLandedFrame(landed.get(next), mergedPath);+ landed.delete(next);+ if (!(await stream.writeFrame(frame))) {+ throw new Error(stream.getExitError() ?? "encoder exited before the last frame");+ }+ framesFed++;+ reportFed?.(framesFed);+ }+ })().then(+ () => undefined,+ (error: unknown) => error ?? new Error("encode failed"),+ );+ const closeEncoder = async () => (await encoder.catch(() => null))?.close();++ return {+ onFrameLanded: (frame) => {+ landed.set(frame.index, frame.path);+ nudge();+ },+ finish: async () => {+ const start = Date.now();+ captureDone = true;+ input.log.info("[Render] Encoded frames while capturing", {+ framesFed,+ totalFrames,+ });+ const encoded = startEncodeProgress(input.job, "Encoding video", input.onProgress);+ reportFed = encoded;+ nudge();+ const failure = await fed;+ const result = await closeEncoder();+ input.assertNotAborted();+ if (failure === undefined && result?.success) {+ encoded();+ return { encodeMs: Date.now() - start };+ }+ input.log.warn(+ "[Render] Encoding while capturing failed; encoding the frames after capture",+ {+ error: String(failure ?? result?.error),+ },+ );+ return runEncodeStage(input);+ },+ abort: async () => {+ stop.abort();+ await fed;+ await closeEncoder();+ },+ get framesFed() {+ return framesFed;+ },+ };+}+export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeStageResult> {const {job,@@ -261,16 +434,11 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeStaoutputPath,framesDir,videoOnlyPath,- width,- height,needsAlpha,hasAudio,audioOutputPath,isPngSequence,isGif,- preset,- effectiveQuality,- effectiveBitrate,enableChunkedEncode,chunkedEncodeSize,abortSignal,@@ -313,7 +481,7 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeStareturn { encodeMs: Date.now() - stage5Start };}- const engineCfg = input.engineConfig ?? job.config.producerConfig ?? resolveConfig();+ const engineCfg = resolveEngineConfig(input);if (isGif) {// ── Stage 5 (gif): two-pass palette encode ───────────────────────@@ -357,24 +525,7 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeStaconst frameExt = frameFileExtension(input.captureImageFormat);const framePattern = `frame_%06d.${frameExt}`;- const encoderOpts = {- fps: job.config.fps,- width,- height,- codec: preset.codec,- preset: preset.preset,- quality: effectiveQuality,- bitrate: effectiveBitrate,- pixelFormat: preset.pixelFormat,- vp9CpuUsed: engineCfg.vp9CpuUsed,- useGpu: job.config.useGpu,- hdr: preset.hdr,- // Distributed chunk renders pass these so the encoder writes closed-GOP- // keyframes that survive `-f concat -c copy` at assemble time. In-process- // renders leave both undefined → preserves the existing open-GOP output.- lockGopForChunkConcat: input.lockGopForChunkConcat === true,- gopSize: input.gopSize,- };+ const encoderOpts = videoEncoderOptions(input, engineCfg);const encodeResult = enableChunkedEncode? await encodeFramesChunkedConcat(framesDir,diff --git a/packages/producer/src/services/render/stages/encodeWhileCapturing.test.ts b/packages/producer/src/services/render/stages/encodeWhileCapturing.test.tsnew file mode 100644index 0000000000..8c15677778--- /dev/null+++ b/packages/producer/src/services/render/stages/encodeWhileCapturing.test.ts@@ -0,0 +1,136 @@+import { createHash } from "node:crypto";+import { execFileSync } from "node:child_process";+import { mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import { getFfmpegBinary } from "@hyperframes/engine";+import {+ canEncodeWhileCapturing,+ encodeWhileCapturing,+ runEncodeStage,+ type EncodeStageInput,+} from "./encodeStage.js";++const FRAMES = 12;+const tempDirs: string[] = [];++afterEach(() => {+ for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });+});++const sha = (path: string) => createHash("sha256").update(readFileSync(path)).digest("hex");+const frameName = (i: number) => `frame_${String(i).padStart(6, "0")}.jpg`;++/** Two workers' contiguous ranges on disk, as the parallel capture leaves them before the merge. */+function captureToWorkerDirs() {+ const root = mkdtempSync(join(tmpdir(), "hf-encode-overlap-"));+ tempDirs.push(root);+ const framesDir = join(root, "frames");+ mkdirSync(framesDir);+ execFileSync(getFfmpegBinary(), [+ "-v",+ "error",+ "-f",+ "lavfi",+ "-i",+ `testsrc2=s=64x64:r=30:d=${FRAMES / 30}`,+ "-start_number",+ "0",+ join(framesDir, "frame_%06d.jpg"),+ ]);+ const landed = [];+ for (let i = 0; i < FRAMES; i++) {+ const workerDir = join(root, `worker-${i < FRAMES / 2 ? 0 : 1}`);+ mkdirSync(workerDir, { recursive: true });+ renameSync(join(framesDir, frameName(i)), join(workerDir, frameName(i)));+ landed.push({ index: i, path: join(workerDir, frameName(i)) });+ }+ const merge = () =>+ landed.forEach((f) => renameSync(f.path, join(framesDir, frameName(f.index))));+ return { root, framesDir, landed, merge };+}++function makeInput(root: string, framesDir: string, videoOnlyName: string): EncodeStageInput {+ return {+ job: {+ id: "encode-while-capturing-test",+ config: { fps: { num: 30, den: 1 }, quality: "standard" },+ status: "queued",+ progress: 0,+ currentStage: "queued",+ createdAt: new Date(0),+ duration: FRAMES / 30,+ },+ log: { error: () => {}, warn: () => {}, info: () => {}, debug: () => {} },+ outputPath: join(root, "out.mp4"),+ framesDir,+ videoOnlyPath: join(root, videoOnlyName),+ width: 64,+ height: 64,+ needsAlpha: false,+ captureImageFormat: "jpeg",+ hasAudio: false,+ isPngSequence: false,+ isGif: false,+ preset: { codec: "h264", preset: "medium", quality: 16, pixelFormat: "yuv420p" },+ effectiveQuality: 16,+ effectiveBitrate: undefined,+ enableChunkedEncode: false,+ chunkedEncodeSize: 30,+ abortSignal: undefined,+ assertNotAborted: () => {},+ };+}++async function until(condition: () => boolean) {+ const deadline = Date.now() + 20_000;+ while (!condition()) {+ if (Date.now() > deadline) throw new Error("condition not reached");+ await new Promise((resolve) => setImmediate(resolve));+ }+}++describe("encodeWhileCapturing", () => {+ it("runs only when the capture workers leave a core free for the encoder", () => {+ const input = makeInput("/r", "/r/frames", "v.mp4");+ expect(canEncodeWhileCapturing(input, 4, 8)).toBe(true);+ expect(canEncodeWhileCapturing(input, 4, 4)).toBe(false);+ expect(canEncodeWhileCapturing(input, 1, 8)).toBe(false);+ });++ it("encodes in frame order while frames land out of order, byte-identical to the encode after capture", async () => {+ const { root, framesDir, landed, merge } = captureToWorkerDirs();+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);+ // Worker 1 finishes its range before worker 0 does.+ for (const frame of [...landed.slice(FRAMES / 2), ...landed.slice(0, FRAMES / 2)]) {+ overlap.onFrameLanded(frame);+ }+ await until(() => overlap.framesFed === FRAMES);+ merge();+ await overlap.finish();++ await runEncodeStage(makeInput(root, framesDir, "after.mp4"));+ expect(sha(join(root, "overlap.mp4"))).toBe(sha(join(root, "after.mp4")));+ });++ it("reads frames the merge already moved, and frames that never reported landing", async () => {+ const { root, framesDir, landed, merge } = captureToWorkerDirs();+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);+ landed.slice(0, 3).forEach(overlap.onFrameLanded);+ merge();+ await overlap.finish();++ await runEncodeStage(makeInput(root, framesDir, "after.mp4"));+ expect(sha(join(root, "overlap.mp4"))).toBe(sha(join(root, "after.mp4")));+ });++ it("abort stops an encoder still waiting on frames", async () => {+ const { root, framesDir, landed } = captureToWorkerDirs();+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);+ overlap.onFrameLanded(landed[0]!);+ await until(() => overlap.framesFed === 1);+ await overlap.abort();+ expect(overlap.framesFed).toBe(1);+ });+});diff --git a/packages/producer/src/services/renderCommitCancellation.test.ts b/packages/producer/src/services/renderCommitCancellation.test.tsindex 9ae0f47e11..682a7587cb 100644--- a/packages/producer/src/services/renderCommitCancellation.test.ts+++ b/packages/producer/src/services/renderCommitCancellation.test.ts@@ -84,6 +84,7 @@ vi.mock("./render/stages/captureStage.js", async (importOriginal) => ({}));vi.mock("./render/stages/encodeStage.js", () => ({+ canEncodeWhileCapturing: () => false,runEncodeStage: async ({ outputPath }: { outputPath: string }) => {mkdirSync(outputPath, { recursive: true });writeFileSync(join(outputPath, "frame_000001.png"), "new-render");diff --git a/packages/producer/src/services/renderOrchestrator.ts b/packages/producer/src/services/renderOrchestrator.tsindex 3043282743..2faf76cbc1 100644--- a/packages/producer/src/services/renderOrchestrator.ts+++ b/packages/producer/src/services/renderOrchestrator.ts@@ -211,7 +211,12 @@ import {runCaptureStreamingStage,} from "./render/stages/captureStreamingStage.js";import { runCaptureHdrStage } from "./render/stages/captureHdrStage.js";-import { runEncodeStage } from "./render/stages/encodeStage.js";+import {+ canEncodeWhileCapturing,+ encodeWhileCapturing,+ runEncodeStage,+ type EncodeStageInput,+} from "./render/stages/encodeStage.js";import { runAssembleStage } from "./render/stages/assembleStage.js";import { shouldUseLayeredComposite } from "./hdrCompositor.js";import {@@ -4868,6 +4873,40 @@ async function executeRenderPipeline(input: {}// ── Disk-based capture (original flow) ────────────────────────────resetCaptureAttemptProgress(job);+ const encodeInput: EncodeStageInput = {+ job,+ log,+ outputPath: stagedOutputPath,+ framesDir,+ videoOnlyPath,+ width,+ height,+ needsAlpha,+ captureImageFormat: captureOptions.format ?? "jpeg",+ hasAudio,+ audioOutputPath,+ isPngSequence,+ isGif,+ preset,+ effectiveQuality,+ effectiveBitrate,+ enableChunkedEncode,+ chunkedEncodeSize,+ engineConfig: cfg,+ // Same value the streaming encoder above spreads — the disk and+ // chunked-concat encoders need an identical GOP lock for HLS.+ ...hlsEncoderGopLock,+ abortSignal: executionSignal,+ assertNotAborted,+ onProgress,+ };+ // Not under drawElement: its verify failure discards every frame and recaptures.+ const overlap =+ !cfg.useDrawElement &&+ workerSizing !== undefined &&+ canEncodeWhileCapturing(encodeInput, capturePlan.workerCount, workerSizing.cpuCount)+ ? encodeWhileCapturing(encodeInput, totalFrames)+ : null;const captureFrameStart = Date.now();const invokeDiskCapture = (diskPlan: SdrDiskCapturePlan) =>observeRenderStage(@@ -4892,12 +4931,14 @@ async function executeRenderPipeline(input: {abortSignal: executionSignal,assertNotAborted,onProgress,+ onFrameLanded: (frame) => overlap?.onFrameLanded(frame),}),);let captureRes;try {captureRes = await invokeDiskCapture(capturePlan);} catch (err) {+ await overlap?.abort();// Disk-path drawElement verification or capture failed. A canvas// or paint-record failure cannot use the injected page as ground truth.// Same recovery contract as the streaming drain: re-render on the@@ -4987,34 +5028,7 @@ async function executeRenderPipeline(input: {isGif,chunkedEncode: enableChunkedEncode,}),- () =>- runEncodeStage({- job,- log,- outputPath: stagedOutputPath,- framesDir,- videoOnlyPath,- width,- height,- needsAlpha,- captureImageFormat: captureOptions.format ?? "jpeg",- hasAudio,- audioOutputPath,- isPngSequence,- isGif,- preset,- effectiveQuality,- effectiveBitrate,- enableChunkedEncode,- chunkedEncodeSize,- engineConfig: cfg,- // Same value the streaming encoder above spreads — the disk and- // chunked-concat encoders need an identical GOP lock for HLS.- ...hlsEncoderGopLock,- abortSignal: executionSignal,- assertNotAborted,- onProgress,- }),+ () => (overlap ? overlap.finish() : runEncodeStage(encodeInput)),);perfStages.encodeMs = encodeRes.encodeMs;}diff --git a/scripts/test-reachability.json b/scripts/test-reachability.jsonindex 46d3918c86..2e48edb8eb 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": "1f3380ad44971fbf728239b89c35a92d25ccf8ee416f1d77458bddfb7f222965",+ "packages/producer/scripts/test-classification.mjs": "d55e0caf7939aecfd204db01dc78373961c85896bf3dbe0b1f85a9ed67301bdd",".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",