hyperframes 0.8.181 → 0.8.184

package/dist/{chunk-HODBPO4A.js → chunk-3MDJIWOV.js}

@@ -5,12 +5,10 @@ var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
-  parseEncoderOptions
-} from "./chunk-KLIKCX6Q.js";
-import {
-  RENDER_TEMP_DIR,
-  createStudioPositionSeekReapplyScript
-} from "./chunk-EVMY7IPL.js";
+  EncoderInterruptedError,
+  encoderFailureError,
+  prepareAnimatedGifInputs
+} from "./chunk-TE427YID.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -18,12 +16,14 @@ import {
   iterateFontFamilyDeclarations,
   normalizeSystemFontPrimaryFamilies,
   resolveFontFamilyDeclarationFamilies
-} from "./chunk-B4VT6YU2.js";
+} from "./chunk-OLZENUPI.js";
 import {
-  EncoderInterruptedError,
-  encoderFailureError,
-  prepareAnimatedGifInputs
-} from "./chunk-4USWWI2Y.js";
+  parseEncoderOptions
+} from "./chunk-KLIKCX6Q.js";
+import {
+  RENDER_TEMP_DIR,
+  createStudioPositionSeekReapplyScript
+} from "./chunk-EVMY7IPL.js";
 import {
   BROWSER_GPU_NOT_SOFTWARE,
   CaptureFailure,
@@ -80,6 +80,7 @@ import {
   distributeFrames,
   distributeFramesInterleaved,
   downloadToTemp,
+  encodeAac,
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
   executeParallelCapture,
@@ -113,6 +114,7 @@ import {
   isVideoFrameFormat,
   isVideoHiddenBeforeStreamStart,
   isVideoPastTimelineEnd,
+  measureVideoShownBoxes,
   mergeWorkerFrames,
   muxVideoWithAudio,
   normalizeObjectFit,
@@ -139,7 +141,6 @@ import {
   resolveFinalFrameExtractionWindow,
   resolveHeadlessShellPath,
   resolvePlayableVideoDuration,
-  resolveReferencedStart,
   resolveVideoExtractionWindow,
   runFfmpeg,
   runVideoExtractionWithRetry,
@@ -153,46 +154,35 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-YPBIAONI.js";
-import {
-  assignBundledRuntimeCompositionIds,
-  buildVariablesByCompScript,
-  emitMountedModuleScripts,
-  emitRootCompositionVariableStyles,
-  ensureExternalLinkTag,
-  ensureExternalScriptTag,
-  extractStandaloneEntryFromIndex,
-  inlineSubCompositions,
-  isTemplateEntry,
-  parsesAsScript,
-  prepareFlattenedInnerRoot
-} from "./chunk-4IEH6EAC.js";
-import {
-  LOW_MEMORY_TOTAL_MB_THRESHOLD,
-  getCgroupMemoryLimitMb,
-  getSystemTotalMb
-} from "./chunk-W2LGJSEN.js";
+} from "./chunk-RGXVEYHI.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
-  MEDIA_START_BASIS_ATTR,
   chainCapture,
   clearGifFramesBeforeNext,
-  compositionOriginSeconds,
-  cutToHostSlots,
   fpsToFfmpegArg,
   fpsToNumber,
   gifClearsAfterLeavingFrameInPlace,
   gsapCdnDist,
-  hostInPointSeconds,
   isDistributedFps,
   parseFps,
   parseVfxChain,
-  readMediaStartBasis,
-  resolveAbsoluteMediaStartSeconds,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-LBQFLUIY.js";
+} from "./chunk-J3QM7AHP.js";
+import {
+  assignBundledRuntimeCompositionIds,
+  buildVariablesByCompScript,
+  emitMountedModuleScripts,
+  emitRootCompositionVariableStyles,
+  ensureExternalLinkTag,
+  ensureExternalScriptTag,
+  extractStandaloneEntryFromIndex,
+  inlineSubCompositions,
+  isTemplateEntry,
+  parsesAsScript,
+  prepareFlattenedInnerRoot
+} from "./chunk-YALM6XN4.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -220,7 +210,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-BAZ5LCR3.js";
+} from "./chunk-R2SQBPMH.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-UJKQWGFF.js";
@@ -235,24 +225,36 @@ import {
   normalizeResolutionFlag,
   suggestMatchingPreset
 } from "./chunk-YMS5FOMC.js";
+import {
+  TRANSITIONS,
+  convertTransfer,
+  crossfade
+} from "./chunk-3GXQPCJC.js";
 import {
   redactKnownPaths,
   redactTelemetryString
 } from "./chunk-634HSJ3J.js";
 import {
   chromeMajorCeiling
-} from "./chunk-537IYAEE.js";
+} from "./chunk-4UMPIPCQ.js";
 import {
-  lintHyperframeHtml
-} from "./chunk-GK2FIKIQ.js";
+  lintHyperframeHtml,
+  resolveReferencedStart
+} from "./chunk-ADDHW2FS.js";
 import {
   isUnresolvedAssetPlaceholder,
   readProjectFile,
   resolveProjectRelativeSrc
 } from "./chunk-6BNTGNGD.js";
 import {
-  checkSubCompositionUsability
-} from "./chunk-32GKETR7.js";
+  MEDIA_START_BASIS_ATTR,
+  checkSubCompositionUsability,
+  compositionOriginSeconds,
+  cutToHostSlots,
+  hostInPointSeconds,
+  readMediaStartBasis,
+  resolveAbsoluteMediaStartSeconds
+} from "./chunk-MMQ52NIZ.js";
 import {
   CSS_URL_RE,
   decodedUrlPath,
@@ -265,10 +267,10 @@ import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";
 import {
-  TRANSITIONS,
-  convertTransfer,
-  crossfade
-} from "./chunk-3GXQPCJC.js";
+  LOW_MEMORY_TOTAL_MB_THRESHOLD,
+  getCgroupMemoryLimitMb,
+  getSystemTotalMb
+} from "./chunk-W2LGJSEN.js";
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
@@ -1596,7 +1598,7 @@ function pidScope() {
   return {
     host: hostname(),
     // Without /proc (macOS, Windows) the boot time, to the minute, stands in for the boot id.
-    boot: attempt(() => readFileSync2("/proc/sys/kernel/random/boot_id", "utf-8").trim()) ?? String(Math.round(Date.now() / 6e4 - uptime() / 60)),
+    boot: attempt(() => readFileSync2("/proc/sys/kernel/random/boot_id", "utf-8").trim()) ?? attempt(() => String(Math.round(Date.now() / 6e4 - uptime() / 60))),
     pidns: attempt(() => readlinkSync("/proc/self/ns/pid"))
   };
 }
@@ -1614,9 +1616,14 @@ function alive(pid) {
     return error.code === "EPERM";
   }
 }
-function inThisPidScope(owner) {
+function knownPidScope() {
   const scope = pidScope();
-  return owner.host === scope.host && owner.boot === scope.boot && owner.pidns === scope.pidns;
+  const unknown = scope.boot === void 0 || process.platform === "linux" && scope.pidns === void 0;
+  return unknown ? void 0 : scope;
+}
+function inThisPidScope(owner) {
+  const scope = knownPidScope();
+  return scope !== void 0 && owner.host === scope.host && owner.boot === scope.boot && owner.pidns === scope.pidns;
 }
 function ownerState(dir) {
   let owner;
@@ -1681,7 +1688,9 @@ async function defaultArtifactDurationProbe(path) {
   const meta = await extractMediaMetadata(path);
   return {
     durationSeconds: meta.durationSeconds,
-    frames: meta.frames
+    frames: meta.frames,
+    width: meta.width,
+    height: meta.height
   };
 }
 function buildArtifactExpectation(input) {
@@ -1690,7 +1699,9 @@ function buildArtifactExpectation(input) {
   const expectation = {
     expectedDurationSeconds: input.durationSeconds,
     fps: input.fps,
-    expectedFrames: input.expectedFrames
+    expectedFrames: input.expectedFrames,
+    expectedWidth: input.width,
+    expectedHeight: input.height
   };
   if (input.outputFormat !== "hls") return expectation;
   return {
@@ -1758,6 +1769,16 @@ function assertFrameCountWithinTolerance(expectedFrames, probedFrames, stagingPa
     `Render artifact is truncated: expected ${expectedFrames} frames, probed ${probedFrames} frames (shortfall ${shortfall} frames). Artifact: ${stagingPath}`
   );
 }
+function assertSizeMatches(expected, probed, stagingPath) {
+  const { expectedWidth: width, expectedHeight: height } = expected;
+  if (width === void 0 || height === void 0) return;
+  if (probed.width === void 0 || probed.height === void 0) return;
+  const fits = (want, got) => got === want || got === want + want % 2;
+  if (fits(width, probed.width) && fits(height, probed.height)) return;
+  throw new Error(
+    `Render artifact has the wrong size: expected ${width}x${height}, probed ${probed.width}x${probed.height}. Artifact: ${stagingPath}`
+  );
+}
 var ArtifactTransaction = class {
   constructor(destinationPath, kind, fileSystem = defaultFileSystem, durationProbe = defaultArtifactDurationProbe) {
     this.kind = kind;
@@ -1830,6 +1851,7 @@ var ArtifactTransaction = class {
     if (expected.expectedFrames !== void 0) {
       assertFrameCountWithinTolerance(expected.expectedFrames, probed.frames, probePath);
     }
+    assertSizeMatches(expected, probed, probePath);
   }
   async runDurationProbe(probePath) {
     try {
@@ -3308,7 +3330,9 @@ function aggregateDrawElement(perfs, de) {
   if (perfs.length === 0) return void 0;
   const modes = [...new Set(perfs.map((p) => p.captureMode).filter(Boolean))].sort();
   const gateReasons = [
-    ...new Set(perfs.map((p) => p.deGateReason).filter((r) => !!r))
+    ...new Set(
+      [de.probeGateReason, ...perfs.map((p) => p.deGateReason)].filter((r) => !!r)
+    )
   ].sort();
   const gpuRenderers = [
     ...new Set(perfs.map((p) => p.gpuRenderer).filter((r) => !!r))
@@ -6580,7 +6604,7 @@ async function readLocalFont(absPath) {
   return { kind: "inline", buffer: Buffer.concat(chunks, totalBytes) };
 }
 async function embedLocalFontFaces(html, projectDir) {
-  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-L7YEEFGI.js");
+  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-VQ5UBMXY.js");
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const fontFaceRe = /@font-face\s*\{([^}]*)\}/gi;
   let result = html;
@@ -8337,6 +8361,7 @@ async function runAudioStage(input) {
     audios,
     masterFxChain,
     urlByAbsentLocalPath,
+    keepEncoderInputAt,
     abortSignal,
     assertNotAborted,
     log
@@ -8356,7 +8381,13 @@ async function runAudioStage(input) {
         audioOutputPath,
         duration,
         abortSignal,
-        { ffmpegProcessTimeout, audioGain, masterFxChain, urlByAbsentLocalPath },
+        {
+          ffmpegProcessTimeout,
+          audioGain,
+          masterFxChain,
+          urlByAbsentLocalPath,
+          keepEncoderInputAt
+        },
         compiledDir
       );
     } catch (err) {
@@ -8456,13 +8487,29 @@ function inspectDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, free
   }
   return { available: false, estimatedBytes, freeBytes };
 }
-function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis) {
+function diskCaptureRemedy(cfg, outputFormat, durationSeconds, workerCount) {
+  const oneWorker = explainStreamingEncodeGate(cfg, outputFormat, 1, durationSeconds);
+  if (workerCount > 1 && oneWorker.enabled) {
+    return `This render stores frames because it captures with ${workerCount} workers. Free up disk space, or re-run this render with --workers 1 to stream frames into the encoder instead. One worker is slower, so keep the default worker count for renders that fit on disk.`;
+  }
+  switch (oneWorker.reason) {
+    case "format_excluded":
+      return `${outputFormat} output stores every frame at any worker count. Free up disk space or render to mp4.`;
+    case "disabled_by_config":
+      return "PRODUCER_ENABLE_STREAMING_ENCODE=false sends every render to disk. Free up disk space or unset it.";
+    case "duration_cap":
+      return "The streaming duration cap (PRODUCER_STREAMING_ENCODE_DURATION_CAP_ENABLED=true) sends renders longer than PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS to disk at any worker count. Free up disk space, unset the cap, or use --low-memory-mode, which streams past it on one worker.";
+    default:
+      return "Free up disk space.";
+  }
+}
+function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remedy) {
   const basisNote = basis === "measured" ? ` (measured from the first ${DISK_PROJECTION_SAMPLE_FRAMES} frames)` : "";
   return new Error(
-    `Disk capture may need ~${(needBytes / 1e6).toFixed(1)} MB of temporary frame storage${basisNote}, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Disk capture stores every frame as an image file (JPEG, or PNG for alpha). mp4/mov renders stream instead: always at --workers 1, and multi-worker on Linux BeginFrame capture. This render landed on disk because the output is png-sequence or gif, because it is multi-worker screenshot capture (opt in with HF_CAPTURE_PARALLEL_STREAM=true), or because streaming was switched off: HF_CAPTURE_PARALLEL_STREAM=false, PRODUCER_ENABLE_STREAMING_ENCODE=false, or the duration cap (PRODUCER_STREAMING_ENCODE_DURATION_CAP_ENABLED=true) on a render longer than PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS. HDR and shader-transition renders never reach this check; they run their own compositor. Re-run with --workers 1, use --low-memory-mode, or free up disk space.`
+    `Disk capture may need ~${(needBytes / 1e6).toFixed(1)} MB of temporary frame storage${basisNote}, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Disk capture stores every frame as an image file (JPEG, or PNG for alpha). ${remedy}`
   );
 }
-function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes) {
+function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, remedy, freeDiskBytes) {
   const headroom = inspectDiskCaptureHeadroom(
     framesDir,
     totalFrames,
@@ -8474,7 +8521,8 @@ function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeD
     headroom.estimatedBytes,
     headroom.freeBytes,
     framesDir,
-    "estimate"
+    "estimate",
+    remedy
   );
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
@@ -8494,7 +8542,7 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   return total;
 }
 function createDiskCaptureProjection(input) {
-  const { framesDir, totalFrames, measureBytes, freeDiskBytes = freeDiskBytesAt } = input;
+  const { framesDir, totalFrames, measureBytes, remedy, freeDiskBytes = freeDiskBytesAt } = input;
   let checked = false;
   return (capturedFrames) => {
     if (checked || capturedFrames < DISK_PROJECTION_SAMPLE_FRAMES) return;
@@ -8506,7 +8554,7 @@ function createDiskCaptureProjection(input) {
     if (remaining <= 0 || freeBytes === null) return;
     const needBytes = Math.ceil(measured / capturedFrames * remaining);
     if (needBytes > freeBytes * 0.9) {
-      throw diskCaptureShortfallError(needBytes, freeBytes, framesDir, "measured");
+      throw diskCaptureShortfallError(needBytes, freeBytes, framesDir, "measured", remedy);
     }
   };
 }
@@ -8548,11 +8596,13 @@ async function runCaptureStage(input) {
     }
   }
   const captureOptions = buildCaptureOptions();
-  assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions);
+  const remedy = diskCaptureRemedy(cfg, job.config.format ?? "mp4", job.duration ?? 0, workerCount);
+  assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, remedy);
   const checkDiskProjection = createDiskCaptureProjection({
     framesDir,
     totalFrames,
-    measureBytes: () => measureCaptureFrameBytes(workDir, framesDir)
+    measureBytes: () => measureCaptureFrameBytes(workDir, framesDir),
+    remedy
   });
   if (workerCount > 1) {
     const attempts = await executeDiskCaptureWithAdaptiveRetry({
@@ -8573,6 +8623,7 @@ async function runCaptureStage(input) {
           if (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;
@@ -9719,6 +9770,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync4
 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
 import { dirname as dirname7, join as join23 } from "path";
 
 // ../producer/src/services/render/stages/gifEncodeArgs.ts
@@ -9728,8 +9780,10 @@ function fpsToFfmpegArg2(fps) {
 }
 var KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA = ["-reinit_filter", "0"];
 var WRITE_EVERY_FRAME_WHOLE = ["-gifflags", "0"];
+var FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE = ["-xerror"];
 function framesInput(input, fpsArg) {
   return [
+    ...FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE,
     "-framerate",
     fpsArg,
     ...KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA,
@@ -9848,6 +9902,124 @@ function startEncodeProgress(job, stage, onProgress) {
   });
   return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
 }
+function resolveEngineConfig(input) {
+  return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
+}
+function videoEncoderOptions(input, engineCfg) {
+  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
+  };
+}
+function canEncodeWhileCapturing(input, workerCount, cpuCount) {
+  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;
+}
+async function readLandedFrame(workerPath, mergedPath) {
+  if (workerPath !== void 0) {
+    try {
+      return await readFile2(workerPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  return readFile2(mergedPath);
+}
+function encodeWhileCapturing(input, totalFrames) {
+  const engineCfg = resolveEngineConfig(input);
+  const stop = new AbortController();
+  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, stop.signal]) : stop.signal;
+  const landed = /* @__PURE__ */ new Map();
+  let captureDone = false;
+  let framesFed = 0;
+  let wake = null;
+  const nudge = () => {
+    wake?.();
+    wake = null;
+  };
+  signal.addEventListener("abort", nudge, { once: true });
+  let reportFed = null;
+  const encoder = spawnStreamingEncoder(
+    input.videoOnlyPath,
+    { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },
+    signal,
+    engineCfg
+  );
+  const fed = (async () => {
+    const stream = await encoder;
+    for (let next = 0; next < totalFrames; next++) {
+      while (!landed.has(next) && !captureDone && !signal.aborted) {
+        await new Promise((resolve11) => wake = resolve11);
+      }
+      if (signal.aborted) return;
+      const mergedPath = join23(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(
+    () => void 0,
+    (error) => 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 === void 0 && 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;
+    }
+  };
+}
 async function runEncodeStage(input) {
   const {
     job,
@@ -9855,16 +10027,11 @@ async function runEncodeStage(input) {
     outputPath,
     framesDir,
     videoOnlyPath,
-    width,
-    height,
     needsAlpha,
     hasAudio,
     audioOutputPath,
     isPngSequence,
     isGif,
-    preset,
-    effectiveQuality,
-    effectiveBitrate,
     enableChunkedEncode,
     chunkedEncodeSize,
     abortSignal,
@@ -9894,7 +10061,7 @@ async function runEncodeStage(input) {
     encoded();
     return { encodeMs: Date.now() - stage5Start };
   }
-  const engineCfg = input.engineConfig ?? job.config.producerConfig ?? resolveConfig();
+  const engineCfg = resolveEngineConfig(input);
   if (isGif) {
     const encoded = startEncodeProgress(job, "Encoding GIF", onProgress);
     if (hasAudio) {
@@ -9924,24 +10091,7 @@ async function runEncodeStage(input) {
   const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
   const 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,
     framePattern,
@@ -10014,12 +10164,13 @@ async function scanTruePeak(audioPath, trim, timeoutMs, signal) {
   };
 }
 async function measureTruePeakDbfs(audioPath, options) {
-  const { timeoutMs, signal, segments } = options;
+  const { timeoutMs, signal } = options;
   const wholeFile = async () => (await scanTruePeak(audioPath, "", timeoutMs, signal)).peak;
+  const { durationSeconds, sampleRate } = await extractAudioMetadata(audioPath, { signal });
   const block = 4800;
-  const count = segments?.sampleRate === 48e3 ? aacSegmentCount(segments.durationSeconds) : 1;
-  if (!segments || count === 1) return wholeFile();
-  const cut = (k) => k * Math.floor(segments.durationSeconds * 10 / count) * block;
+  const count = sampleRate === 48e3 && Number.isFinite(durationSeconds) ? aacSegmentCount(durationSeconds) : 1;
+  if (count === 1) return wholeFile();
+  const cut = (k) => k * Math.floor(durationSeconds * 10 / count) * block;
   const peers = new AbortController();
   const segmentSignal = signal ? AbortSignal.any([signal, peers.signal]) : peers.signal;
   const scans = await Promise.all(
@@ -10048,24 +10199,8 @@ var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
 var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
 var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
 var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
-function buildAacTruePeakCorrectionArgs(inputPath, outputPath, targetDurationSeconds, attenuationDb) {
-  return [
-    "-i",
-    inputPath,
-    "-map",
-    "0:a:0",
-    "-vn",
-    "-af",
-    `volume=${attenuationDb.toFixed(3)}dB`,
-    "-t",
-    formatSeconds(targetDurationSeconds),
-    "-c:a",
-    "aac",
-    "-b:a",
-    "192k",
-    "-y",
-    outputPath
-  ];
+function aacTruePeakCorrectionFilter(targetDurationSeconds, attenuationDb) {
+  return `volume=${attenuationDb.toFixed(3)}dB,apad,atrim=0:${formatSeconds(targetDurationSeconds)}`;
 }
 function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
   const delta = targetDurationSeconds - sourceDurationSeconds;
@@ -10080,53 +10215,13 @@ function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, tar
   if (delta > 0) {
     return {
       operation: "pad",
-      steps: [
-        {
-          kind: "normalize",
-          args: [
-            "-i",
-            audioPath,
-            "-af",
-            `apad,atrim=0:${targetSec}`,
-            "-t",
-            targetSec,
-            "-c:a",
-            "aac",
-            "-b:a",
-            "192k",
-            "-y",
-            outputPath
-          ]
-        }
-      ],
+      steps: [{ kind: "normalize", filter: `apad,atrim=0:${targetSec}` }],
       cleanupPaths: []
     };
   }
   return {
     operation: "trim",
-    steps: [
-      {
-        kind: "trim",
-        args: [
-          "-i",
-          audioPath,
-          "-af",
-          `atrim=duration=${targetSec},asetpts=PTS-STARTPTS`,
-          // `atrim` limits decoded samples but does not cap muxer timestamps
-          // introduced by encoder delay/flush.  The output duration contract
-          // is enforced at the container boundary as well; without `-t`, a
-          // long primed source can retain its original tail after re-encode.
-          "-t",
-          targetSec,
-          "-c:a",
-          "aac",
-          "-b:a",
-          "192k",
-          "-y",
-          outputPath
-        ]
-      }
-    ],
+    steps: [{ kind: "trim", filter: `atrim=duration=${targetSec},asetpts=PTS-STARTPTS` }],
     cleanupPaths: []
   };
 }
@@ -10143,7 +10238,8 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   const probeAudio = input.probeAudioInfo ?? defaultProbeAudioInfo;
   const timeoutMs = input.timeoutMs ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const runner = input.runFfmpeg ?? ((args) => defaultRunFfmpeg(args, timeoutMs, input.signal));
-  const probeTruePeak = input.probeAudioTruePeakDbfs ?? (input.runFfmpeg ? void 0 : (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }));
+  const encode = input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal);
+  const probeTruePeak = input.probeAudioTruePeakDbfs ?? (input.runFfmpeg || input.encodeAac ? void 0 : (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }));
   const [videoResult, audioResult] = await Promise.allSettled([
     probeVideo(input.videoPath),
     probeAudio(input.audioPath, input.signal)
@@ -10190,7 +10286,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   );
   try {
     for (const step of plan2.steps) {
-      const ffmpegResult = await runner(step.args);
+      const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(input.audioPath, input.outputPath, targetDurationSeconds, step.filter);
       if (!ffmpegResult.success) {
         return {
           success: false,
@@ -10222,7 +10318,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       targetDurationSeconds,
       signal: input.signal,
       probeTruePeak,
-      runner
+      encode
     });
     if (!correction.success) {
       return {
@@ -10252,12 +10348,8 @@ async function constrainAacTruePeak(input) {
     audioPath: input.audioPath,
     targetDurationSeconds: input.targetDurationSeconds,
     signal: input.signal,
-    probeTruePeak: async (audioPath, signal) => {
-      const { sampleRate } = await extractAudioMetadata(audioPath, { signal });
-      const segments = { durationSeconds: input.targetDurationSeconds, sampleRate };
-      return measureTruePeakDbfs(audioPath, { timeoutMs, signal, segments });
-    },
-    runner: (args) => defaultRunFfmpeg(args, timeoutMs, input.signal)
+    probeTruePeak: (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }),
+    encode: defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
   });
 }
 async function enforceAacTruePeak(input) {
@@ -10284,13 +10376,11 @@ async function enforceAacTruePeak(input) {
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
       attenuationDb += correctionTargetDbfs - truePeakDbfs;
-      const result = await input.runner(
-        buildAacTruePeakCorrectionArgs(
-          input.audioPath,
-          correctedPath,
-          input.targetDurationSeconds,
-          attenuationDb
-        )
+      const result = await input.encode(
+        input.audioPath,
+        correctedPath,
+        input.targetDurationSeconds,
+        aacTruePeakCorrectionFilter(input.targetDurationSeconds, attenuationDb)
       );
       if (!result.success) {
         return {
@@ -10394,7 +10484,18 @@ async function defaultProbeAudioInfo(audioPath, signal) {
   };
 }
 async function defaultRunFfmpeg(args, timeoutMs, signal) {
-  const result = await runFfmpeg(args, { signal, timeout: timeoutMs });
+  return toStepResult(await runFfmpeg(args, { signal, timeout: timeoutMs }), timeoutMs);
+}
+function defaultAacEncoder(timeoutMs, signal, pcmSourcePath) {
+  return async (inputPath, outputPath, durationSeconds, filter) => {
+    const options = pcmSourcePath ? { signal, timeout: timeoutMs, filter } : { signal, timeout: timeoutMs, filter, segments: 1 };
+    return toStepResult(
+      await encodeAac(pcmSourcePath ?? inputPath, outputPath, durationSeconds, options),
+      timeoutMs
+    );
+  };
+}
+function toStepResult(result, timeoutMs) {
   if (result.success) return { success: true };
   return {
     success: false,
@@ -10582,7 +10683,7 @@ function assertOutputScaleSupported(deviceScaleFactor, route) {
   const reason = UNSUPPORTED_REASON2[route];
   if (reason === null) return;
   throw new Error(
-    `[Render] --resolution other than the composition's size is not supported on the "${route}" capture route: ${reason}. Render at the composition's size, or as mp4 with page-side compositing.`
+    `[Render] --resolution other than the composition's size is not supported on the "${route}" capture route: ${reason}. Render at the composition's size; or, for HDR footage, add --sdr to render this size in standard colour; or, for shader transitions, render as mp4.`
   );
 }
 
@@ -10800,7 +10901,7 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32") return join25(systemTempDir, "hf-render-");
+  if (platform2 === "win32" || platform2 === "darwin") return join25(systemTempDir, "hf-render-");
   return join25(dirname9(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
@@ -11294,6 +11395,9 @@ function resolveDeShortBand(args) {
 function shouldPreferSingleWorkerDrawElement(args) {
   return args.workerCount > 1 && typeof args.requestedWorkers !== "number" && args.useDrawElement && !args.deCompileGate && !args.forceScreenshot && outputUsesH264Pipeline(args.outputFormat) && args.minFrames > 0 && args.totalFrames >= args.minFrames && args.singleWorkerStreamingOk && !args.layeredOrEffectRoute && !args.supersampling && !args.probeDeGated && !args.experimentalParallelDeOptIn;
 }
+function isProbeDeGated(session) {
+  return session !== null && session.captureMode !== "drawelement" && !session.deInitDeferred;
+}
 function resolveInversionRetryPlan(args) {
   if (args.deWorkerInversion !== "inverted") return null;
   const workerCount = args.isMemoryExhaustion ? 1 : args.preInversionWorkerCount;
@@ -11375,7 +11479,8 @@ async function closeOrphanedProbeForRetry(probe, closer, log, retryContext) {
 }
 function resolveParallelCaptureMode(args) {
   const supersampling = (args.deviceScaleFactor ?? 1) !== 1;
-  return args.headlessShell && args.platform === "linux" && !args.forceScreenshot && !supersampling ? "beginframe" : "screenshot";
+  const headlessShell = args.headlessShellPath !== void 0;
+  return headlessShell && args.platform === "linux" && !args.forceScreenshot && !supersampling ? "beginframe" : "screenshot";
 }
 function isCaptureParallelStreamRouterEnabled(env, resolvedMode) {
   const raw = env.HF_CAPTURE_PARALLEL_STREAM?.trim().toLowerCase();
@@ -11983,6 +12088,7 @@ async function executeRenderPipeline(input) {
     );
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = Boolean(effectiveHdr && nativeHdrIds.size > 0);
+    if (hasHdrContent) assertOutputScaleSupported(deviceScaleFactor, "hdr_layered");
     const deSingleMinFramesRaw = process.env.HF_DE_SINGLE_MIN_FRAMES;
     const deSingleMinFramesNum = deSingleMinFramesRaw === void 0 || deSingleMinFramesRaw.trim() === "" ? 900 : Number(deSingleMinFramesRaw);
     const deSingleMinFrames = Number.isFinite(deSingleMinFramesNum) ? deSingleMinFramesNum : 900;
@@ -12023,7 +12129,7 @@ async function executeRenderPipeline(input) {
       singleWorkerStreamingOk: shouldUseStreamingEncode(cfg, outputFormat, 1, job.duration),
       layeredOrEffectRoute: hasHdrContent || compiled.hasShaderTransitions,
       supersampling: deviceScaleFactor !== 1,
-      probeDeGated: probeSession !== null && probeSession.captureMode !== "drawelement" && !probeSession.deInitDeferred,
+      probeDeGated: isProbeDeGated(probeSession),
       experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true" || // Verified parallel DE streaming (opt-in) wants its parallelism kept.
       process.env.HF_DE_PARALLEL_STREAM === "true"
     };
@@ -12032,14 +12138,14 @@ async function executeRenderPipeline(input) {
       ...deInversionArgs,
       minFrames: Math.min(deSingleMinFrames, deShortBandMinFrames)
     });
-    const deShortBand = resolveDeShortBand({
+    let deShortBand = resolveDeShortBand({
       invertAtBaseFloor,
       invertAtBandFloor,
       bandEnabled: deShortBandEnabled,
       bandOpen: deShortBandOpen,
       elementCountSource: compositionElementCountSource
     });
-    const deInversionEligible = deShortBandRoute && deShortBand === "applied" ? invertAtBandFloor : invertAtBaseFloor;
+    let deInversionEligible = deShortBandRoute && deShortBand === "applied" ? invertAtBandFloor : invertAtBaseFloor;
     const deInversionEffectiveMinFrames = deShortBandRoute && deShortBand === "applied" ? Math.min(deSingleMinFrames, deShortBandMinFrames) : deSingleMinFrames;
     const deParallelRouterEnabled = isDeParallelRouterEnabled(process.env);
     const deParallelMinFramesRaw = process.env.HF_DE_PARALLEL_MIN_FRAMES;
@@ -12048,7 +12154,7 @@ async function executeRenderPipeline(input) {
     const deParallelMinMemRaw = process.env.HF_DE_PARALLEL_MIN_MEM_MB;
     const deParallelMinMemNum = deParallelMinMemRaw === void 0 || deParallelMinMemRaw.trim() === "" ? 24576 : Number(deParallelMinMemRaw);
     const deParallelMinMemoryMb = Number.isFinite(deParallelMinMemNum) ? deParallelMinMemNum : 24576;
-    const deParallelRouterEligible = shouldPreferParallelDrawElement({
+    let deParallelRouterEligible = shouldPreferParallelDrawElement({
       workerCount: WOULD_RESOLVE_MULTI_WORKER,
       requestedWorkers: job.config.workers,
       useDrawElement: cfg.useDrawElement,
@@ -12059,7 +12165,7 @@ async function executeRenderPipeline(input) {
       minFrames: deParallelMinFrames,
       layeredOrEffectRoute: hasHdrContent || compiled.hasShaderTransitions,
       supersampling: deviceScaleFactor !== 1,
-      probeDeGated: probeSession !== null && probeSession.captureMode !== "drawelement" && !probeSession.deInitDeferred,
+      probeDeGated: isProbeDeGated(probeSession),
       experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true" || process.env.HF_DE_PARALLEL_STREAM === "true",
       routerEnabled: deParallelRouterEnabled,
       // Router pins 3 workers for the streaming path; don't pin when a
@@ -12075,6 +12181,35 @@ async function executeRenderPipeline(input) {
       totalMemoryMb: Math.round(totalmem2() / (1024 * 1024)),
       minMemoryMb: deParallelMinMemoryMb
     });
+    if (probeSession === null && (deInversionEligible || deParallelRouterEligible)) {
+      try {
+        probeSession = await createCaptureSession(
+          activeFileServer.url,
+          framesDir,
+          buildCaptureOptions(),
+          null,
+          { ...cfg, forceScreenshot: captureForceScreenshot }
+        );
+        await initializeSession(probeSession);
+      } catch (error) {
+        assertNotAborted();
+        if (probeSession) {
+          lastBrowserConsole = probeSession.browserConsoleBuffer;
+          await closeCaptureSession(probeSession).catch(() => {
+          });
+          probeSession = null;
+        }
+        log.warn("[Render] Fast capture gate check failed; routing without it.", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (isProbeDeGated(probeSession)) {
+        deInversionEligible = false;
+        deParallelRouterEligible = false;
+        deShortBand = void 0;
+      }
+    }
+    const deProbeGateReason = isProbeDeGated(probeSession) ? probeSession.deGateReason : void 0;
     let workerCount;
     const captureStageObservationData = (extra = {}) => ({
       stagePhase: "capturing",
@@ -12262,7 +12397,7 @@ async function executeRenderPipeline(input) {
     }
     const parallelCaptureMode = resolveParallelCaptureMode({
       platform: process.platform,
-      headlessShell: resolveHeadlessShellPath(cfg) !== null,
+      headlessShellPath: resolveHeadlessShellPath(cfg),
       forceScreenshot: captureForceScreenshot,
       deviceScaleFactor: captureOptions.deviceScaleFactor
     });
@@ -12864,6 +12999,34 @@ async function executeRenderPipeline(input) {
           throw new Error(`Disk capture requires sdr_disk plan; got ${capturePlan.kind}`);
         }
         resetCaptureAttemptProgress(job);
+        const encodeInput = {
+          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
+        };
+        const overlap = !cfg.useDrawElement && workerSizing !== void 0 && canEncodeWhileCapturing(encodeInput, capturePlan.workerCount, workerSizing.cpuCount) ? encodeWhileCapturing(encodeInput, totalFrames) : null;
         const captureFrameStart = Date.now();
         const invokeDiskCapture = (diskPlan) => observeRenderStage(
           observability,
@@ -12885,13 +13048,15 @@ async function executeRenderPipeline(input) {
             createRenderVideoFrameInjector,
             abortSignal: executionSignal,
             assertNotAborted,
-            onProgress
+            onProgress,
+            onFrameLanded: (frame) => overlap?.onFrameLanded(frame)
           })
         );
         let captureRes;
         try {
           captureRes = await invokeDiskCapture(capturePlan);
         } catch (err) {
+          await overlap?.abort();
           if (!isDrawElementVerificationError(err) && !isDrawElementCaptureError(err) || err instanceof RenderCancelledError || executionSignal?.aborted === true) {
             throw err;
           }
@@ -12960,33 +13125,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;
       }
@@ -13034,7 +13173,9 @@ async function executeRenderPipeline(input) {
         outputFormat,
         durationSeconds: job.duration,
         fps: fpsToNumber(job.config.fps),
-        expectedFrames: captureTotalFrames
+        expectedFrames: captureTotalFrames,
+        width: outputWidth,
+        height: outputHeight
       })
     );
     const totalElapsed = Date.now() - pipelineStart;
@@ -13070,6 +13211,7 @@ async function executeRenderPipeline(input) {
       drawElement: {
         compileGate: deCompileGate,
         clampReason: deClampReason,
+        probeGateReason: deProbeGateReason,
         workerInversion: deWorkerInversion,
         preInversionWorkers: deWorkerInversion ? preRoutingWorkerCount : void 0,
         compositionElementCount,
@@ -13622,6 +13764,29 @@ function buildChunkCaptureOptions(input) {
     requiresWebGpu: compositionRequiresWebGpu(input.html)
   };
 }
+function shownDeferredFrameIndexes(planVideos, frames, fps) {
+  const shown = /* @__PURE__ */ new Map();
+  const deferred = planVideos.extracted.filter((video) => video.deferredRange);
+  if (deferred.length === 0) return shown;
+  const table = createFrameLookupTable(
+    planVideos.videos,
+    deferred.map((video) => ({
+      ...video,
+      outputDir: "",
+      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
+    })),
+    resolveRenderFpsConfig(fps).value
+  );
+  for (const frame of frames) {
+    const globalTime = frame * fps.den / fps.num;
+    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
+      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
+      indexes.add(payload.frameIndex);
+      shown.set(videoId, indexes);
+    }
+  }
+  return shown;
+}
 async function extractDeferredVideoFramesForChunk(input) {
   const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
   const remoteSources = input.remoteSources ?? {};
@@ -13638,24 +13803,7 @@ async function extractDeferredVideoFramesForChunk(input) {
     });
   }
   if (deferred.length === 0) return [];
-  const table = createFrameLookupTable(
-    input.planVideos.videos,
-    deferred.map((video) => ({
-      ...video,
-      outputDir: input.outputRoot,
-      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
-    })),
-    resolveRenderFpsConfig(input.fps).value
-  );
-  const shown = /* @__PURE__ */ new Map();
-  for (const frame of input.frames) {
-    const globalTime = frame * input.fps.den / input.fps.num;
-    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
-      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
-      indexes.add(payload.frameIndex);
-      shown.set(videoId, indexes);
-    }
-  }
+  const shown = shownDeferredFrameIndexes(input.planVideos, input.frames, input.fps);
   return Promise.all(
     deferred.map(async (video) => {
       const outputDir = join27(input.outputRoot, video.videoId);
@@ -13681,7 +13829,8 @@ async function extractDeferredVideoFramesForChunk(input) {
           fps: input.fps,
           outputDir: input.outputRoot,
           format: range.format,
-          frameRanges: contiguousRuns(indexes)
+          frameRanges: contiguousRuns(indexes),
+          shownBox: input.shownBoxes?.get(video.videoId)
         },
         void 0,
         input.cfg
@@ -14333,6 +14482,20 @@ function withDuration(buf, target, duration) {
 function timescaleOf(buf, header) {
   return buf.readUInt32BE(header.bodyStart + (buf[header.bodyStart] === 1 ? 20 : 12));
 }
+var TRACK_ID_AT = { tkhd: [12, 20], mvhd: [96, 108] };
+function idOf(buf, target) {
+  return buf.readUInt32BE(
+    target.bodyStart + TRACK_ID_AT[target.type][buf[target.bodyStart] === 1 ? 1 : 0]
+  );
+}
+function withId(boxBytes, type, id) {
+  const header = boxAt(boxBytes, 0, 0, boxBytes.length);
+  boxBytes.writeUInt32BE(
+    id,
+    header.bodyStart + TRACK_ID_AT[type][boxBytes[header.bodyStart] === 1 ? 1 : 0]
+  );
+  return boxBytes;
+}
 function buildStbl(stsd, track) {
   const stts = runs(track.durations);
   const stsc = [];
@@ -14374,24 +14537,48 @@ function planTracksOf(tracks, plan2, index) {
   }
   return matched;
 }
-function buildStitchedHeader(layouts) {
-  const plan2 = readTracks(layouts[0].moov);
-  const chunks = layouts.map((layout, i) => planTracksOf(readTracks(layout.moov), plan2, i));
+function sourceTracks(layouts, audio) {
+  const chunkPlan = readTracks(layouts[0].moov);
+  const audioTracks = audio ? readTracks(audio.moov) : [];
+  if (audio && (audioTracks.length !== 1 || audioTracks[0].handler !== "soun")) {
+    throw new Error("[mp4Stitch] the separate audio file must hold one audio track");
+  }
+  const plan2 = [...chunkPlan, ...audioTracks];
+  const chunks = layouts.map((layout, i) => {
+    const tracks = readTracks(layout.moov);
+    if (audio && tracks.some((track) => track.handler === "soun")) {
+      throw new Error(`[mp4Stitch] chunk ${i} carries its own audio`);
+    }
+    return planTracksOf(tracks, plan2, i);
+  });
+  return {
+    plan: plan2,
+    chunkTrackCount: chunkPlan.length,
+    sources: audio ? [[...chunkPlan.map(() => null), audioTracks[0]], ...chunks] : chunks
+  };
+}
+function buildStitchedHeader(layouts, audio) {
+  const { plan: plan2, chunkTrackCount, sources } = sourceTracks(layouts, audio);
+  const sourceLayouts = audio ? [audio, ...layouts] : layouts;
   const payloadBases = [];
   let payloadBytes = 0;
-  for (const layout of layouts) {
+  for (const layout of sourceLayouts) {
     payloadBases.push(payloadBytes);
     payloadBytes += layout.payloadEnd - layout.payloadStart;
   }
   const template = layouts[0].moov;
   const root = boxAt(template, 0, 0, template.length);
-  const movieTimescale = timescaleOf(template, child(template, root, "mvhd"));
+  const mvhd = child(template, root, "mvhd");
+  const movieTimescale = timescaleOf(template, mvhd);
+  const chunkTrackIds = plan2.slice(0, chunkTrackCount).map((track) => idOf(template, child(template, track.trak, "tkhd")));
+  const audioTrackId = Math.max(...chunkTrackIds) + 1;
   const buildMoov = (dataStart2) => {
     const traks = plan2.map((track, t) => {
-      const parts = chunks.flatMap((tracks, chunk) => {
+      const parts = sources.flatMap((tracks, chunk) => {
         const part = tracks[t];
         return part ? [{ ...part, chunk }] : [];
       });
+      const moov = t < chunkTrackCount ? template : audio.moov;
       const merged = {
         durations: parts.flatMap((part) => part.durations),
         sizes: parts.flatMap((part) => part.sizes),
@@ -14400,9 +14587,9 @@ function buildStitchedHeader(layouts) {
         chunkOffsets: parts.flatMap(
           (part) => part.chunkOffsets.map((offset) => {
             const i = part.chunk;
-            const { payloadStart, payloadEnd } = layouts[i];
+            const { payloadStart, payloadEnd } = sourceLayouts[i];
             if (offset < payloadStart || offset >= payloadEnd) {
-              throw new Error(`[mp4Stitch] chunk ${i} has samples outside its mdat`);
+              throw new Error(`[mp4Stitch] source ${i} has samples outside its mdat`);
             }
             return offset - payloadStart + payloadBases[i] + dataStart2;
           })
@@ -14418,20 +14605,25 @@ function buildStitchedHeader(layouts) {
       elst.writeBigInt64BE(BigInt(track.mediaTime), 12);
       elst.writeUInt32BE(65536, 20);
       const edts = track.mediaTime ? box("edts", fullBox("elst", 1, elst)) : Buffer.alloc(0);
-      const trak = rebuild(template, track.trak, {
-        tkhd: (tkhd) => Buffer.concat([withDuration(template, tkhd, shown), edts]),
+      const tkhdOf = (tkhd) => {
+        const timed = withDuration(moov, tkhd, shown);
+        return t < chunkTrackCount ? timed : withId(timed, "tkhd", audioTrackId);
+      };
+      const trak = rebuild(moov, track.trak, {
+        tkhd: (tkhd) => Buffer.concat([tkhdOf(tkhd), edts]),
         edts: () => Buffer.alloc(0),
-        mdia: (mdia) => rebuild(template, mdia, {
-          mdhd: (mdhd) => withDuration(template, mdhd, mediaDuration),
-          minf: (minf) => rebuild(template, minf, { stbl: () => buildStbl(track.stsd, merged) })
+        mdia: (mdia) => rebuild(moov, mdia, {
+          mdhd: (mdhd) => withDuration(moov, mdhd, mediaDuration),
+          minf: (minf) => rebuild(moov, minf, { stbl: () => buildStbl(track.stsd, merged) })
         })
       });
       return { trak, shown };
     });
     let next = 0;
+    const movieHeader = withDuration(template, mvhd, Math.max(...traks.map((t) => t.shown)));
     return rebuild(template, root, {
-      mvhd: (mvhd) => withDuration(template, mvhd, Math.max(...traks.map((t) => t.shown))),
-      trak: () => traks[next++].trak
+      mvhd: () => audio ? withId(movieHeader, "mvhd", audioTrackId + 1) : movieHeader,
+      trak: () => ++next < chunkTrackCount ? traks[next - 1].trak : Buffer.concat(traks.slice(next - 1).map((t) => t.trak))
     });
   };
   const ftyp = layouts[0].ftyp;
@@ -14464,15 +14656,16 @@ async function copyPayload(path, layout, index, out) {
     );
   }
 }
-async function writeStitchedMp4(chunkPaths, outputPath) {
-  const layouts = await Promise.all(chunkPaths.map((path) => readMp4Layout(fileRange(path))));
-  const header = buildStitchedHeader(layouts);
+async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
+  const sourcePaths = audioPath ? [audioPath, ...chunkPaths] : chunkPaths;
+  const layouts = await Promise.all(sourcePaths.map((path) => readMp4Layout(fileRange(path))));
+  const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
   mkdirSync10(dirname11(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
   const out = createWriteStream(join30(workDir, "out.mp4"));
   try {
     out.write(header);
-    for (const [i, path] of chunkPaths.entries()) await copyPayload(path, layouts[i], i, out);
+    for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
     renameSync4(join30(workDir, "out.mp4"), outputPath);
@@ -15043,7 +15236,8 @@ function buildLockedRenderConfig(input) {
     chunkCount: input.chunkCount,
     runtimeEnv: input.runtimeEnv,
     variables: config.variables,
-    ...input.chunksCarryAudio ? { chunksCarryAudio: true } : {}
+    ...input.chunksCarryAudio ? { chunksCarryAudio: true } : {},
+    ...input.separateAudio ? { separateAudio: true } : {}
   };
 }
 function carriesChunkAudio(config, options) {
@@ -15138,8 +15332,10 @@ function createVideoSourceShipper(input) {
     return result;
   };
 }
-async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, options = {}) {
-  const planDir = executionPlanDir;
+function plansSeparateAudio(config, options) {
+  return options.deferAudio === true && config.format === "mp4" && config.cfr !== true;
+}
+async function compilePlanComposition(projectDir, config, planDir, options) {
   rejectUnsupportedDistributedFormat(config);
   validateNoGpuEncode({
     useGpu: false,
@@ -15267,7 +15463,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-RDSWHMJS.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-4UYM2K3S.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -15275,6 +15471,100 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       });
     }
   }
+  return {
+    projectDir,
+    log,
+    sizeLimitBytes,
+    abortSignal,
+    assertNotAborted,
+    cfg,
+    job,
+    workDir,
+    compiledDir,
+    finalCompiledDir,
+    remoteFiles,
+    urlByAbsentLocalPath,
+    localPathByUrl,
+    compileResult,
+    compiled,
+    composition,
+    deviceScaleFactor,
+    forceScreenshot,
+    width,
+    height,
+    probeResult,
+    totalFrames
+  };
+}
+function mixPlanAudio(c, compiledDir, seconds, pcmPath) {
+  return runAudioStage({
+    projectDir: c.projectDir,
+    workDir: c.workDir,
+    compiledDir,
+    urlByAbsentLocalPath: c.urlByAbsentLocalPath,
+    duration: seconds,
+    ffmpegProcessTimeout: c.cfg.ffmpegProcessTimeout,
+    audioGain: c.cfg.audioGain,
+    audios: c.composition.audios,
+    masterFxChain: c.composition.masterFxChain,
+    ...pcmPath ? { keepEncoderInputAt: pcmPath } : {},
+    abortSignal: c.abortSignal,
+    assertNotAborted: c.assertNotAborted
+  });
+}
+async function extractPlanVideos(c, deferRangeExtraction) {
+  const extractResult = await runExtractVideosStage({
+    projectDir: c.projectDir,
+    compiledDir: c.compiledDir,
+    job: c.job,
+    cfg: c.cfg,
+    composition: c.composition,
+    abortSignal: c.abortSignal,
+    assertNotAborted: c.assertNotAborted,
+    materializeSymlinks: true,
+    deferRangeExtraction,
+    urlByAbsentLocalPath: c.urlByAbsentLocalPath
+  });
+  if (extractResult.failureToEnforce) throw extractResult.failureToEnforce;
+  if (extractResult.extractionResult) {
+    assertVideoExtractionSucceeded(extractResult.extractionResult);
+  }
+  return extractResult;
+}
+async function holdPlanAudioPeak(c, audioPath, pcmPath, seconds) {
+  const peak = await constrainAacTruePeak({
+    audioPath,
+    ...existsSync20(pcmPath) ? { sourcePath: pcmPath } : {},
+    targetDurationSeconds: seconds,
+    signal: c.abortSignal,
+    timeoutMs: c.cfg.ffmpegProcessTimeout
+  }).finally(() => rmSync10(pcmPath, { force: true }));
+  if (!peak.success) throw encoderFailureError("[plan] audio true-peak check failed", peak);
+}
+async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, options = {}) {
+  const planDir = executionPlanDir;
+  const c = await compilePlanComposition(projectDir, config, planDir, options);
+  const {
+    log,
+    sizeLimitBytes,
+    cfg,
+    job,
+    workDir,
+    compiledDir,
+    finalCompiledDir,
+    remoteFiles,
+    urlByAbsentLocalPath,
+    localPathByUrl,
+    compileResult,
+    compiled,
+    composition,
+    deviceScaleFactor,
+    forceScreenshot,
+    width,
+    height,
+    probeResult,
+    totalFrames
+  } = c;
   const megapixels = compileResult.outputWidth * compileResult.outputHeight / 1e6;
   let maxParallel = resolveMaxParallelChunks(config, totalFrames, megapixels, log);
   const measureFrameCost = chunkSizingUsesFrameCost(config) && planNeedsFrameCostMeasurement(compiled.html);
@@ -15285,24 +15575,9 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     observedAt: "pre-extract",
     log
   });
-  stageStarted = Date.now();
-  const extractResult = await runExtractVideosStage({
-    projectDir,
-    compiledDir,
-    job,
-    cfg,
-    composition,
-    abortSignal,
-    assertNotAborted,
-    materializeSymlinks: true,
-    deferRangeExtraction: options.deferVideoExtraction,
-    urlByAbsentLocalPath
-  });
+  let stageStarted = Date.now();
+  const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  if (extractResult.failureToEnforce) throw extractResult.failureToEnforce;
-  if (extractResult.extractionResult) {
-    assertVideoExtractionSucceeded(extractResult.extractionResult);
-  }
   const stagedVideoFrames = join33(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join33(planDir, "video-frames");
   if (existsSync20(videoFramesDst)) rmSync10(videoFramesDst, { recursive: true, force: true });
@@ -15358,23 +15633,18 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     "utf-8"
   );
   const digests = options.digests ?? /* @__PURE__ */ new Map();
-  const chunksCarryAudio2 = carriesChunkAudio(config, options);
-  const audioSeconds = chunksCarryAudio2 ? totalFrames / config.fps : probeResult.duration;
+  const separateAudio = plansSeparateAudio(config, options);
+  const chunksCarryAudio = !separateAudio && carriesChunkAudio(config, options);
+  const audioSeconds = chunksCarryAudio ? totalFrames / config.fps : probeResult.duration;
+  const planMixPcmPath = join33(workDir, "plan-mix.wav");
   stageStarted = Date.now();
   const [audioOutcome, overlapOutcome, frameCostOutcome] = await Promise.allSettled([
-    runAudioStage({
-      projectDir,
-      workDir,
-      compiledDir: finalCompiledDir,
-      urlByAbsentLocalPath,
-      duration: audioSeconds,
-      ffmpegProcessTimeout: cfg.ffmpegProcessTimeout,
-      audioGain: cfg.audioGain,
-      audios: composition.audios,
-      masterFxChain: composition.masterFxChain,
-      abortSignal,
-      assertNotAborted
-    }).finally(() => logPlanStage(log, "audio", stageStarted)),
+    separateAudio ? null : mixPlanAudio(
+      c,
+      finalCompiledDir,
+      audioSeconds,
+      chunksCarryAudio ? planMixPcmPath : void 0
+    ).finally(() => logPlanStage(log, "audio", stageStarted)),
     (async () => {
       for (const dir of [finalCompiledDir, videoFramesDst, videoSourcesDir]) {
         await prehashPlanFiles(dir, digests);
@@ -15424,22 +15694,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   );
   const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
   const audioResult = audioOutcome.value;
-  if (audioResult.audioError) {
+  if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
   const planAudioPath = join33(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync20(audioResult.audioOutputPath)) {
+  if (audioResult?.hasAudio && existsSync20(audioResult.audioOutputPath)) {
     renameSync5(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync20(planAudioPath)) {
+  if (chunksCarryAudio && existsSync20(planAudioPath)) {
     stageStarted = Date.now();
-    const peak = await constrainAacTruePeak({
-      audioPath: planAudioPath,
-      targetDurationSeconds: audioSeconds,
-      signal: abortSignal,
-      timeoutMs: cfg.ffmpegProcessTimeout
-    });
-    if (!peak.success) throw encoderFailureError("[plan] audio true-peak check failed", peak);
+    await holdPlanAudioPeak(c, planAudioPath, planMixPcmPath, audioSeconds);
     logPlanStage(log, "audio-peak", stageStarted);
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
@@ -15465,7 +15729,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     effectiveChunkSize,
     chunkCount,
     runtimeEnv,
-    chunksCarryAudio: chunksCarryAudio2
+    chunksCarryAudio,
+    separateAudio
   });
   const compositionJson = {
     durationSeconds: job.duration ?? 0,
@@ -15510,7 +15775,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     fontSnapshotSha,
     durationSeconds: job.duration ?? 0,
     totalFrames,
-    hasAudio: audioResult.hasAudio,
+    hasAudio: audioResult?.hasAudio ?? false,
     digests
   });
   logPlanStage(log, "freeze", stageStarted);
@@ -16861,7 +17126,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-RDSWHMJS.js");
+    const { drainBrowserPool } = await import("./src-4UYM2K3S.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -17485,7 +17750,8 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
         )
       ),
       chunksCarryAudio: options.chunksCarryAudio,
-      sliceChunkAudio: true
+      sliceChunkAudio: true,
+      deferAudio: options.deferAudio
     });
     return await publishExecutionPlan(stagingRoot, publisher, { digests, log: config.logger });
   } catch (error) {
@@ -17811,7 +18077,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
   }
   if (chunksAreStitchedMp4(planDir, cfr)) {
-    await writeStitchedMp4(chunkPaths, outputPath);
+    const separateAudio = stitchesSeparateAudio(planDir) && audioPath !== null;
+    await writeStitchedMp4(chunkPaths, outputPath, separateAudio ? audioPath : void 0);
     return {
       outputPath,
       durationMs: Date.now() - start,
@@ -18009,16 +18276,20 @@ async function runAssembleFfmpeg(args, step, signal, timeout) {
   }
 }
 function chunksAreStitchedMp4(planDir, cfr) {
-  if (!chunksCarryAudio(planDir)) return false;
+  const { chunksCarryAudio, separateAudio } = lockedAudio(planDir);
+  if (!chunksCarryAudio && !separateAudio) return false;
   if (cfr) {
-    throw new Error("[assemble] cfr=true cannot re-encode a plan whose mp4 chunks carry audio");
+    throw new Error("[assemble] cfr=true cannot re-encode a plan whose mp4 chunks are stitched");
   }
   return true;
 }
-function chunksCarryAudio(planDir) {
+function stitchesSeparateAudio(planDir) {
+  return lockedAudio(planDir).separateAudio === true;
+}
+function lockedAudio(planDir) {
   const encoderJsonPath = join40(planDir, "meta", "encoder.json");
-  if (!existsSync26(encoderJsonPath)) return false;
-  return JSON.parse(readFileSync13(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
+  if (!existsSync26(encoderJsonPath)) return {};
+  return JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -18097,6 +18368,12 @@ function validatePlanVideosForChunk(value) {
     );
   }
 }
+var MIN_FRAMES_PER_CHUNK_BROWSER = 20;
+function resolveChunkCaptureWorkers(framesInChunk, machineSized, maxCaptureWorkers) {
+  if (maxCaptureWorkers === void 0) return machineSized;
+  const byFrames = Math.floor(framesInChunk / MIN_FRAMES_PER_CHUNK_BROWSER);
+  return Math.max(machineSized, Math.floor(Math.min(maxCaptureWorkers, byFrames)));
+}
 function resolveChunkFrameRange(slice, chunkIndex, frameRange) {
   if (frameRange === void 0) return { startFrame: slice.startFrame, endFrame: slice.endFrame };
   const { startFrame, endFrame } = frameRange;
@@ -18302,34 +18579,15 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const framesDir = join41(workDir, "captured-frames");
     mkdirSync17(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
-    const deferredVideoFrames = planVideos ? await extractDeferredVideoFramesForChunk({
-      planDir,
-      planVideos,
-      frames: Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i),
-      fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
-      outputRoot: videoFramesDir,
-      cfg,
-      remoteSources
-    }) : [];
+    const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
+    const chunkFps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
+    const deferredVideos = planVideos?.extracted.filter((video) => video.deferredRange) ?? [];
+    const shownFrames = planVideos ? shownDeferredFrameIndexes(planVideos, chunkFrameNumbers, chunkFps) : /* @__PURE__ */ new Map();
     const remoteVideoIds = new Set(
       planVideos?.extracted.filter(
         (video) => video.deferredRange && Object.hasOwn(remoteSources, video.deferredRange.sourcePath)
       ).map((video) => video.videoId)
     );
-    const remoteVideos = deferredVideoFrames.filter((video) => remoteVideoIds.has(video.videoId));
-    const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable(
-      planVideos.videos,
-      [
-        ...rebuildExtractedFramesFromPlanDir(
-          planDir,
-          planVideos.extracted.filter((video) => !video.deferredRange),
-          v2Manifest === null ? "dense-v1" : "sparse-v2"
-        ),
-        ...deferredVideoFrames
-      ],
-      resolveRenderFpsConfig(job.config.fps).value
-    ) : null;
-    const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
     const fileServer = await createFileServer({
       projectDir: compiledDir,
       compiledDir,
@@ -18345,10 +18603,18 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       videoCount: planVideos?.videos.length ?? 0,
       html: readFileSync14(join41(compiledDir, "index.html"), "utf-8"),
       // The plan ships a deferred source only to chunks that show it; don't wait on the rest.
-      skipReadinessVideoIds: deferredVideoFrames.filter((video) => video.framePaths.size === 0 || remoteVideoIds.has(video.videoId)).map((video) => video.videoId),
-      videoMetadataHints: collectVideoMetadataHints(remoteVideos)
+      skipReadinessVideoIds: deferredVideos.filter(
+        (video) => !shownFrames.get(video.videoId)?.size || remoteVideoIds.has(video.videoId)
+      ).map((video) => video.videoId),
+      videoMetadataHints: collectVideoMetadataHints(
+        deferredVideos.filter((video) => remoteVideoIds.has(video.videoId))
+      )
     });
-    const chunkWorkerCount = calculateOptimalWorkers(framesInChunk, void 0, cfg);
+    const chunkWorkerCount = resolveChunkCaptureWorkers(
+      framesInChunk,
+      calculateOptimalWorkers(framesInChunk, void 0, cfg),
+      options?.maxCaptureWorkers
+    );
     let session = null;
     let outputKind;
     let framesEncoded = 0;
@@ -18359,6 +18625,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const capturePerfs = [];
     const captureAttempts = [];
     let forceScreenshotForChunk = encoder.forceScreenshot;
+    let shownBoxes;
     try {
       if (chunkWorkerCount === 1 || !forceScreenshotForChunk) {
         const bootStarted = Date.now();
@@ -18369,6 +18636,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           cfg
         );
         sessionBootMs = Date.now() - bootStarted;
+        shownBoxes = await measureVideoShownBoxes(
+          session.page,
+          [...shownFrames.keys()],
+          chunkFrameNumbers.map((frame) => frame * chunkFps.den / chunkFps.num)
+        );
         const browserSelectedScreenshot = session.launchCaptureMode === "screenshot";
         const beginFrameStalled = !browserSelectedScreenshot && await beginFrameSessionNeedsScreenshotFallback(session);
         if (browserSelectedScreenshot) {
@@ -18410,6 +18682,29 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           session = null;
         }
       }
+      const deferredVideoFrames = planVideos ? await extractDeferredVideoFramesForChunk({
+        planDir,
+        planVideos,
+        frames: chunkFrameNumbers,
+        fps: chunkFps,
+        outputRoot: videoFramesDir,
+        cfg,
+        remoteSources,
+        shownBoxes
+      }) : [];
+      const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable(
+        planVideos.videos,
+        [
+          ...rebuildExtractedFramesFromPlanDir(
+            planDir,
+            planVideos.extracted.filter((video) => !video.deferredRange),
+            v2Manifest === null ? "dense-v1" : "sparse-v2"
+          ),
+          ...deferredVideoFrames
+        ],
+        resolveRenderFpsConfig(job.config.fps).value
+      ) : null;
+      const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
         forceScreenshot: forceScreenshotForChunk,
@@ -18600,6 +18895,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       encodeStageMs,
       workers: chunkWorkerCount,
       captureMode,
+      // Device-pixel box each video's frames were extracted to cover; a video not listed kept full size.
+      videoShownBoxes: Object.fromEntries(shownBoxes ?? []),
       sha256,
       outputKind,
       producerVersion: plan2.producerVersion,
@@ -18669,9 +18966,10 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
 }
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync15, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
+import { closeSync as closeSync8, openSync as openSync7, readdirSync as readdirSync12, readSync as readSync5, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
 import { createHash as createHash7 } from "crypto";
 import { join as join43 } from "path";
+var READ_CHUNK_BYTES = 256 * 1024;
 
 export {
   createConsoleLogger,