@hyperframes/producer 0.8.181 → 0.8.183

package/dist/distributed.js

@@ -89,6 +89,8 @@ import {
   extractMediaMetadata as extractMediaMetadata4,
   resolveConfig as resolveConfig2,
   closeCaptureSession as closeCaptureSession8,
+  createCaptureSession as createCaptureSession8,
+  initializeSession as initializeSession8,
   createVideoFrameInjector,
   getEncoderPreset as getEncoderPreset3,
   distributeFrames as distributeFrames2,
@@ -4955,6 +4957,7 @@ async function runAudioStage(input) {
     audios,
     masterFxChain,
     urlByAbsentLocalPath,
+    keepEncoderInputAt,
     abortSignal,
     assertNotAborted,
     log
@@ -4974,7 +4977,13 @@ async function runAudioStage(input) {
         audioOutputPath,
         duration,
         abortSignal,
-        { ffmpegProcessTimeout, audioGain, masterFxChain, urlByAbsentLocalPath },
+        {
+          ffmpegProcessTimeout,
+          audioGain,
+          masterFxChain,
+          urlByAbsentLocalPath,
+          keepEncoderInputAt
+        },
         compiledDir
       );
     } catch (err) {
@@ -5088,13 +5097,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,
@@ -5106,7 +5131,8 @@ function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeD
     headroom.estimatedBytes,
     headroom.freeBytes,
     framesDir,
-    "estimate"
+    "estimate",
+    remedy
   );
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
@@ -5126,7 +5152,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;
@@ -5138,7 +5164,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);
     }
   };
 }
@@ -5180,11 +5206,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({
@@ -5459,8 +5487,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,
@@ -5710,7 +5740,8 @@ import { dirname as dirname6, join as join13 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
-  extractAudioMetadata as extractAudioMetadata2,
+  encodeAac,
+  extractAudioMetadata as extractAudioMetadata3,
   getFfprobeBinary,
   ManagedChildProcess,
   runFfmpeg as runFfmpeg5,
@@ -5719,7 +5750,12 @@ import {
 import { redactKnownPaths, redactTelemetryString as redactTelemetryString3 } from "@hyperframes/core";
 
 // src/services/render/audioTruePeak.ts
-import { aacSegmentCount, describeFfmpegFailure, runFfmpeg as runFfmpeg4 } from "@hyperframes/engine";
+import {
+  aacSegmentCount,
+  describeFfmpegFailure,
+  extractAudioMetadata as extractAudioMetadata2,
+  runFfmpeg as runFfmpeg4
+} from "@hyperframes/engine";
 var toDbfs = (token) => token.toLowerCase() === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
 function checkedDbfs(value) {
   if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY) {
@@ -5757,12 +5793,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 extractAudioMetadata2(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(
@@ -5791,24 +5828,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;
@@ -5823,53 +5844,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: []
   };
 }
@@ -5886,7 +5867,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)
@@ -5933,7 +5915,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,
@@ -5965,7 +5947,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       targetDurationSeconds,
       signal: input.signal,
       probeTruePeak,
-      runner
+      encode
     });
     if (!correction.success) {
       return {
@@ -5995,12 +5977,8 @@ async function constrainAacTruePeak(input) {
     audioPath: input.audioPath,
     targetDurationSeconds: input.targetDurationSeconds,
     signal: input.signal,
-    probeTruePeak: async (audioPath, signal) => {
-      const { sampleRate } = await extractAudioMetadata2(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) {
@@ -6027,13 +6005,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 {
@@ -6128,7 +6104,7 @@ function parseFrameRate(rate) {
   return { fpsNum, fpsDen };
 }
 async function defaultProbeAudioInfo(audioPath, signal) {
-  const metadata = await extractAudioMetadata2(audioPath, { signal });
+  const metadata = await extractAudioMetadata3(audioPath, { signal });
   return {
     durationSeconds: metadata.durationSeconds,
     sampleRate: metadata.sampleRate,
@@ -6137,7 +6113,18 @@ async function defaultProbeAudioInfo(audioPath, signal) {
   };
 }
 async function defaultRunFfmpeg(args, timeoutMs, signal) {
-  const result = await runFfmpeg5(args, { signal, timeout: timeoutMs });
+  return toStepResult(await runFfmpeg5(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,
@@ -6513,15 +6500,33 @@ function createRenderJob(config) {
     warnings: []
   };
 }
+function explainStreamingEncodeGate(cfg, outputFormat, workerCount, durationSeconds, forceParallelStream = false) {
+  if (!cfg.enableStreamingEncode) return { enabled: false, reason: "disabled_by_config" };
+  if (outputFormat === "png-sequence" || outputFormat === "gif") {
+    return { enabled: false, reason: "format_excluded" };
+  }
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+    return { enabled: false, reason: "invalid_duration" };
+  }
+  const overCap = cfg.streamingEncodeDurationCapEnabled === true && durationSeconds > cfg.streamingEncodeMaxDurationSeconds;
+  if (overCap && !cfg.lowMemoryMode) return { enabled: false, reason: "duration_cap" };
+  if (forceParallelStream || process.env.HF_DE_PARALLEL_STREAM === "true") {
+    return { enabled: true, reason: "parallel_forced" };
+  }
+  if (workerCount === 1) {
+    return { enabled: true, reason: overCap ? "low_memory_mode" : "single_worker" };
+  }
+  return { enabled: false, reason: "multi_worker" };
+}
 var DEFAULT_SEGMENTED_MIN_SECONDS = Number.POSITIVE_INFINITY;
 
 // src/services/distributed/planFrameCost.ts
 import { join as join17 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
-  createCaptureSession as createCaptureSession8,
+  createCaptureSession as createCaptureSession9,
   createFrameLookupTable as createFrameLookupTable3,
-  initializeSession as initializeSession8
+  initializeSession as initializeSession9
 } from "@hyperframes/engine";
 
 // src/services/distributed/chunkFrames.ts
@@ -6919,6 +6924,29 @@ function buildChunkCaptureOptions(input) {
     requiresWebGpu: compositionRequiresWebGpu3(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 = createFrameLookupTable2(
+    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 ?? {};
@@ -6935,24 +6963,7 @@ async function extractDeferredVideoFramesForChunk(input) {
     });
   }
   if (deferred.length === 0) return [];
-  const table = createFrameLookupTable2(
-    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 = join16(input.outputRoot, video.videoId);
@@ -6978,7 +6989,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
@@ -7025,7 +7037,7 @@ async function measurePlanSecondsPerFrame(input) {
   });
   let session = null;
   try {
-    session = await createCaptureSession8(
+    session = await createCaptureSession9(
       fileServer.url,
       join17(workDir, "frame-cost"),
       buildChunkCaptureOptions({
@@ -7037,7 +7049,7 @@ async function measurePlanSecondsPerFrame(input) {
       createChunkVideoFrameInjectorFactory(lookup)(),
       createCaptureCalibrationConfig(input.cfg)
     );
-    await initializeSession8(session);
+    await initializeSession9(session);
     const { estimate } = await measureCaptureCostFromSession(session, input.totalFrames, fps, log);
     return (estimate.p95Ms ?? 0) / 1e3;
   } finally {
@@ -7631,6 +7643,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 = [];
@@ -7672,24 +7698,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),
@@ -7698,9 +7748,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;
           })
@@ -7716,20 +7766,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;
@@ -7762,15 +7817,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);
   mkdirSync8(dirname9(outputPath), { recursive: true });
   const workDir = mkdtempSync3(`${outputPath}.stitch-`);
   const out = createWriteStream(join19(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);
     renameSync3(join19(workDir, "out.mp4"), outputPath);
@@ -8345,7 +8401,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) {
@@ -8440,8 +8497,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,
@@ -8577,6 +8636,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,
+    ...existsSync15(pcmPath) ? { sourcePath: pcmPath } : {},
+    targetDurationSeconds: seconds,
+    signal: c.abortSignal,
+    timeoutMs: c.cfg.ffmpegProcessTimeout
+  }).finally(() => rmSync8(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);
@@ -8587,24 +8740,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 = join22(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join22(planDir, "video-frames");
   if (existsSync15(videoFramesDst)) rmSync8(videoFramesDst, { recursive: true, force: true });
@@ -8660,23 +8798,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 = join22(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);
@@ -8726,22 +8859,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 = join22(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync15(audioResult.audioOutputPath)) {
+  if (audioResult?.hasAudio && existsSync15(audioResult.audioOutputPath)) {
     renameSync4(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync15(planAudioPath)) {
+  if (chunksCarryAudio && existsSync15(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();
@@ -8767,7 +8894,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     effectiveChunkSize,
     chunkCount,
     runtimeEnv,
-    chunksCarryAudio: chunksCarryAudio2
+    chunksCarryAudio,
+    separateAudio
   });
   const compositionJson = {
     durationSeconds: job.duration ?? 0,
@@ -8812,7 +8940,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);
@@ -8837,6 +8965,33 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     producerVersion
   };
 }
+async function buildPlanAudio(projectDir, config, workRoot, outputPath, options = {}) {
+  const c = await compilePlanComposition(projectDir, config, workRoot, {
+    ...options,
+    executionPlanSizeLimitBytes: Number.MAX_SAFE_INTEGER
+  });
+  try {
+    const seconds = c.totalFrames / config.fps;
+    const pcmPath = join22(c.workDir, "plan-mix.wav");
+    let stageStarted = Date.now();
+    await extractPlanVideos(c, true);
+    logPlanStage(c.log, "extract", stageStarted);
+    stageStarted = Date.now();
+    const mixed = await mixPlanAudio(c, c.compiledDir, seconds, pcmPath);
+    logPlanStage(c.log, "audio", stageStarted);
+    if (mixed.audioError) {
+      applyDistributedAudioWarningPolicy(c.job, mixed.audioError, mixed.audioFailures, c.log);
+    }
+    if (!mixed.hasAudio || !existsSync15(mixed.audioOutputPath)) return { hasAudio: false };
+    renameSync4(mixed.audioOutputPath, outputPath);
+    stageStarted = Date.now();
+    await holdPlanAudioPeak(c, outputPath, pcmPath, seconds);
+    logPlanStage(c.log, "audio-peak", stageStarted);
+    return { hasAudio: true };
+  } finally {
+    rmSync8(c.workDir, { recursive: true, force: true });
+  }
+}
 async function plan(projectDir, config, planDir, options = {}) {
   const executionPlan = await buildLocalExecutionPlan(projectDir, config, planDir, options);
   return {
@@ -9445,7 +9600,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) {
@@ -9781,7 +9937,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,
@@ -9979,16 +10136,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 = join26(planDir, "meta", "encoder.json");
-  if (!existsSync18(encoderJsonPath)) return false;
-  return JSON.parse(readFileSync11(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
+  if (!existsSync18(encoderJsonPath)) return {};
+  return JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -10062,11 +10223,12 @@ import {
   calculateOptimalWorkers as calculateOptimalWorkers2,
   classifyCaptureFailure as classifyCaptureFailure4,
   closeCaptureSession as closeCaptureSession10,
-  createCaptureSession as createCaptureSession9,
+  createCaptureSession as createCaptureSession10,
   createFrameLookupTable as createFrameLookupTable5,
   deriveBeginFrameProbeTimeTicks as deriveBeginFrameProbeTimeTicks2,
   getEncoderPreset as getEncoderPreset6,
-  initializeSession as initializeSession9,
+  initializeSession as initializeSession10,
+  measureVideoShownBoxes,
   probeBeginFrameLiveness as probeBeginFrameLiveness2,
   readWebGlVendorInfoFromCanvas,
   resolveConfig as resolveConfig5
@@ -10095,9 +10257,9 @@ function resolveChunkFrameRange(slice, chunkIndex, frameRange) {
   return { startFrame, endFrame };
 }
 var distributedCaptureSessionDependencies = {
-  createCaptureSession: createCaptureSession9,
+  createCaptureSession: createCaptureSession10,
   assertSwiftShader,
-  initializeSession: initializeSession9,
+  initializeSession: initializeSession10,
   closeCaptureSession: closeCaptureSession10,
   readWebGlVendorInfo: readWebGlVendorInfoFromCanvas
 };
@@ -10288,34 +10450,15 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const framesDir = join27(workDir, "captured-frames");
     mkdirSync14(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 ? createFrameLookupTable5(
-      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,
@@ -10331,8 +10474,12 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       videoCount: planVideos?.videos.length ?? 0,
       html: readFileSync12(join27(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 = calculateOptimalWorkers2(framesInChunk, void 0, cfg);
     let session = null;
@@ -10345,6 +10492,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();
@@ -10355,6 +10503,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) {
@@ -10396,6 +10549,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 ? createFrameLookupTable5(
+        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,
@@ -10586,6 +10762,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,
@@ -10897,10 +11075,11 @@ function validateIntDimension(field, value) {
 }
 
 // src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync13, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
+import { closeSync as closeSync5, openSync as openSync5, readdirSync as readdirSync10, readSync as readSync3, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
 import { join as join29 } from "node:path";
 var SITE_ID_SCHEME = "site-v2\0";
+var READ_CHUNK_BYTES = 256 * 1024;
 function listSiteFiles(projectDir) {
   const files = [];
   const ancestors = /* @__PURE__ */ new Set([realpathSync2(projectDir)]);
@@ -10933,10 +11112,19 @@ function listSiteFiles(projectDir) {
 }
 function hashProjectDir(projectDir, files = listSiteFiles(projectDir)) {
   const hash = createHash6("sha256").update(SITE_ID_SCHEME);
+  const chunk = Buffer.allocUnsafe(READ_CHUNK_BYTES);
   for (const rel of files) {
     hash.update(rel);
     hash.update("\0");
-    hash.update(readFileSync13(join29(projectDir, rel)));
+    const fd = openSync5(join29(projectDir, rel), "r");
+    try {
+      let read;
+      while ((read = readSync3(fd, chunk, 0, chunk.length, null)) > 0) {
+        hash.update(chunk.subarray(0, read));
+      }
+    } finally {
+      closeSync5(fd);
+    }
   }
   return hash.digest("hex").slice(0, 16);
 }
@@ -10984,6 +11172,7 @@ export {
   assemble,
   assembleV2,
   buildChunkSlices,
+  buildPlanAudio,
   buildStitchedHeader,
   chunksAreStitchedMp4,
   createPlanV2FromExecutionPlan,
@@ -11001,6 +11190,7 @@ export {
   plan,
   planV2,
   planV2WithPublisher,
+  plansSeparateAudio,
   publishPlanV2FromExecutionPlan,
   publishPlanV2FromV1,
   readMp4Layout,
@@ -11013,6 +11203,7 @@ export {
   renderChunkV2,
   resolveChunkPlan,
   resolvePlanAudioPath,
+  stitchesSeparateAudio,
   validateDistributedRenderConfig,
   validatePlanV2MaterializedTarget,
   validateVariablesPayload