@hyperframes/producer 0.8.191 → 0.8.193

package/dist/distributed.js

@@ -6,7 +6,6 @@ import {
   existsSync as existsSync15,
   linkSync,
   mkdirSync as mkdirSync10,
-  renameSync as renameSync4,
   rmSync as rmSync9,
   writeFileSync as writeFileSync6
 } from "node:fs";
@@ -18,7 +17,10 @@ import {
 import {
   getEncoderPreset as getEncoderPreset4,
   normalizeVp9CpuUsed,
-  resolveConfig as resolveConfig3
+  resolveConfig as resolveConfig3,
+  declareContentAddressedUrl,
+  renameWithRetry as renameWithRetry6,
+  declareProbeFactsUrl
 } from "@hyperframes/engine";
 
 // src/logger.ts
@@ -1149,7 +1151,7 @@ function encoderFailureError(prefix, result) {
 }
 
 // src/services/render/artifactTransaction.ts
-import { HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST } from "@hyperframes/engine";
+import { HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST, renameWithRetry } from "@hyperframes/engine";
 
 // src/utils/ffprobe.ts
 import {
@@ -1226,6 +1228,24 @@ import {
 
 // src/services/render/captureStageError.ts
 import { CaptureFailure, classifyCaptureFailure } from "@hyperframes/engine";
+
+// src/services/render/perfSummary.ts
+import { fpsToNumber as fpsToNumber3 } from "@hyperframes/core";
+function pushWorkerDedupPerfs(results, sink) {
+  for (const r of results) {
+    if (r.perf) sink.push(r.perf);
+  }
+}
+function pushWorkerPageErrors(results, sink) {
+  for (const result of results) {
+    for (const line of result.pageErrorLines ?? []) if (!sink.includes(line)) sink.push(line);
+  }
+}
+function withWorkerPageErrors(consoleLines, workerLines) {
+  return [...consoleLines, ...workerLines.filter((line) => !consoleLines.includes(line))];
+}
+
+// src/services/render/captureStageError.ts
 var CaptureStageError = class extends CaptureFailure {
   browserConsole;
   constructor(input) {
@@ -1234,10 +1254,13 @@ var CaptureStageError = class extends CaptureFailure {
       kind: classified.kind,
       message: normalizeErrorMessage(input.cause),
       cause: input.cause,
-      workerDiagnostics: classified.workerDiagnostics
+      workerDiagnostics: classified.workerDiagnostics,
+      pageErrorLines: classified.pageErrorLines
     });
     this.name = "CaptureStageError";
-    this.browserConsole = input.browserConsole.slice();
+    this.browserConsole = withWorkerPageErrors(input.browserConsole, [
+      ...classified.pageErrorLines
+    ]);
     if (input.cause instanceof Error && input.cause.stack) {
       this.stack = input.cause.stack;
     }
@@ -1297,7 +1320,7 @@ import {
   resolveVideoExtractionWindow,
   runFfmpeg
 } from "@hyperframes/engine";
-import { fpsToFfmpegArg, fpsToNumber as fpsToNumber3 } from "@hyperframes/core";
+import { fpsToFfmpegArg, fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 var NO_FOLLOW_FLAG = constants2.O_NOFOLLOW ?? 0;
 var BYTES_PER_MIB = 1024 * 1024;
 
@@ -1323,13 +1346,8 @@ import {
   spawnStreamingEncoder
 } from "@hyperframes/engine";
 
-// src/services/render/perfSummary.ts
-import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
-function pushWorkerDedupPerfs(results, sink) {
-  for (const r of results) {
-    if (r.perf) sink.push(r.perf);
-  }
-}
+// src/services/render/segmentManifest.ts
+import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
 
 // src/services/render/hdrMode.ts
 import {
@@ -1683,19 +1701,11 @@ import {
 
 // src/services/animatedGifPrep.ts
 import { createHash as createHash2 } from "node:crypto";
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
-  renameSync,
-  rmSync as rmSync3,
-  statSync as statSync2
-} from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync2 } from "node:fs";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, resolve as resolve4 } from "node:path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import { parseAnimatedGifMetadata } from "@hyperframes/core";
-import { DEFAULT_VP9_CPU_USED, runFfmpeg as runFfmpeg2 } from "@hyperframes/engine";
+import { DEFAULT_VP9_CPU_USED, runFfmpeg as runFfmpeg2, renameWithRetry as renameWithRetry3 } from "@hyperframes/engine";
 var PREPARED_GIF_SUBDIR = "_animated_gif";
 var CACHE_SCHEMA = "hfgif-v1";
 function splitUrlSuffix(src) {
@@ -1874,7 +1884,7 @@ async function ensurePreparedWebm(input) {
         throw new Error("Animated GIF transcode produced an empty output");
       }
       if (!isUsableFile(input.cachePath)) {
-        renameSync(tmpPath, input.cachePath);
+        renameWithRetry3(tmpPath, input.cachePath);
       } else {
         rmSync3(tmpPath, { force: true });
       }
@@ -4281,6 +4291,10 @@ async function runProbeStage(input) {
                 if (el.loop && !existing.loop) {
                   existing.loop = true;
                 }
+                const audio = composition.audios.find(
+                  (audio2) => audio2.type === "video" && audio2.id === `${el.id}-audio`
+                );
+                if (audio) audio.loop = existing.loop;
               }
             } else if (!compiled.droppedMediaIds.has(el.id)) {
               composition.videos.push({
@@ -4318,6 +4332,7 @@ async function runProbeStage(input) {
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart
                 );
+                existing.loop = el.loop;
                 if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON) {
                   existing.volume = el.volume;
                 }
@@ -4329,6 +4344,7 @@ async function runProbeStage(input) {
                 start: el.start,
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
+                loop: el.loop,
                 layer: 0,
                 volume: el.volume,
                 type: "audio"
@@ -4583,6 +4599,10 @@ import {
   extractMediaMetadata as extractMediaMetadata3,
   isVideoPastTimelineEnd,
   isHdrColorSpace as isHdrColorSpace2,
+  rebaseVideoToWindow,
+  resolveFinalFrameExtractionWindow as resolveFinalFrameExtractionWindow2,
+  resolveVideoExtractionWindow as resolveVideoExtractionWindow2,
+  isHttpUrl as isHttpUrl2,
   resolveProjectRelativeSrc as resolveProjectRelativeSrc3,
   runVideoExtractionWithRetry,
   safeVideoExtractionSourceIdentity
@@ -4948,6 +4968,8 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
       start: video.start,
       end: video.end,
       mediaStart: video.mediaStart,
+      playbackRate: video.playbackRate,
+      loop: video.loop,
       layer: 0,
       volume: 1,
       type: "video"
@@ -4955,6 +4977,33 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
     existingAudioSrcs.add(video.src);
   }
 }
+async function appendVideoAudioFromProbe(input) {
+  const { projectDir, compiledDir, composition, urlByAbsentLocalPath } = input;
+  const videos = composition.videos.filter(
+    (video) => !isVideoPastTimelineEnd(video, composition.duration)
+  );
+  const probed = await Promise.all(
+    videos.map(async (video) => {
+      const path = isHttpUrl2(video.src) ? video.src : resolveProjectRelativeSrc3(video.src, projectDir, compiledDir);
+      const readFrom = urlByAbsentLocalPath?.get(path) ?? path;
+      if (!isHttpUrl2(readFrom) && !existsSync7(readFrom)) return null;
+      const metadata = await extractMediaMetadata3(readFrom);
+      const window2 = await resolveFinalFrameExtractionWindow2(
+        readFrom,
+        video,
+        metadata,
+        resolveVideoExtractionWindow2(video, metadata, composition.duration)
+      );
+      if (window2.durationSeconds <= 0) return null;
+      rebaseVideoToWindow(video, window2);
+      return { videoId: video.id, metadata };
+    })
+  );
+  appendAutoDetectedVideoAudio(
+    composition,
+    probed.filter((entry) => entry !== null)
+  );
+}
 
 // src/services/render/stages/audioStage.ts
 import { join as join10 } from "node:path";
@@ -4967,7 +5016,7 @@ import {
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, renameSync as renameSync2, rmSync as rmSync4 } from "node:fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname5, join as join9 } from "node:path";
 import {
   DEFAULT_CONFIG,
@@ -4976,6 +5025,7 @@ import {
   extractAudioMetadata as extractAudioMetadata3,
   getFfprobeBinary,
   ManagedChildProcess,
+  renameWithRetry as renameWithRetry4,
   runFfmpeg as runFfmpeg4,
   trackChildProcess
 } from "@hyperframes/engine";
@@ -5231,7 +5281,7 @@ async function enforceAacTruePeak(input) {
       }
       if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
         if (measuredPath !== correctedPath) return { success: true };
-        renameSync2(correctedPath, input.audioPath);
+        renameWithRetry4(correctedPath, input.audioPath);
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
@@ -5421,6 +5471,7 @@ async function runAudioStage(input) {
     const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
     let audioLoweredDb;
     if (result.hasAudio) {
+      const guardStart = Date.now();
       const peak = await constrainAacTruePeak({
         audioPath: result.audioOutputPath,
         sourcePath: pcmSourcePath,
@@ -5430,6 +5481,7 @@ async function runAudioStage(input) {
       });
       if (!peak.success) throw encoderFailureError("Audio true-peak check failed", peak);
       audioLoweredDb = peak.loweredDb;
+      input.log?.info("[audio] phases", { ...result.audioPhaseMs, guard: Date.now() - guardStart });
     }
     return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
   } finally {
@@ -5455,6 +5507,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
   let hasAudio = false;
   let audioError;
   let audioFailures;
+  let audioPhaseMs;
   if (audios.length > 0) {
     let audioResult;
     try {
@@ -5504,6 +5557,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertAudioNotInterrupted(audioResult.failures);
     hasAudio = audioResult.success;
     audioFailures = audioResult.failures;
+    audioPhaseMs = audioResult.phaseMs;
     if (!hasAudio) {
       audioError = audioResult.error ?? "audio mix failed for an unknown reason";
       for (const failure of audioResult.failures ?? []) {
@@ -5522,7 +5576,8 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     audioOutputPath,
     hasAudio,
     audioError,
-    audioFailures
+    audioFailures,
+    audioPhaseMs
   };
 }
 
@@ -5632,6 +5687,7 @@ async function runCaptureStage(input) {
   let { workerCount } = plan2;
   const { forceScreenshot } = plan2;
   let lastBrowserConsole = [];
+  const workerPageErrors = [];
   let captureBeyondViewport = probeSession?.options.captureBeyondViewport;
   const captureCfg = cfg.forceScreenshot === forceScreenshot ? cfg : { ...cfg, forceScreenshot };
   if (frameRange !== void 0) {
@@ -5669,6 +5725,7 @@ async function runCaptureStage(input) {
       abortSignal,
       frameRangeStart: frameRange?.startFrame,
       dedupPerfs,
+      pageErrorLines: workerPageErrors,
       onProgress: (progress) => {
         if (progress.latestWorkerPhase) {
           if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
@@ -5689,6 +5746,11 @@ async function runCaptureStage(input) {
       },
       cfg: captureCfg,
       log
+    }).catch((error) => {
+      throw wrapCaptureStageError(
+        error,
+        withWorkerPageErrors(probeSession?.browserConsoleBuffer ?? [], workerPageErrors)
+      );
     });
     captureAttempts.push(...attempts);
     const lastAttempt = attempts[attempts.length - 1];
@@ -5701,6 +5763,7 @@ async function runCaptureStage(input) {
       await closeCaptureSession5(probeSession);
       probeSession = null;
     }
+    lastBrowserConsole = withWorkerPageErrors(lastBrowserConsole, workerPageErrors);
   } else {
     const sequential = await runSequentialDiskCapture(
       input,
@@ -5908,6 +5971,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
 import { dirname as dirname6, join as join12 } from "node:path";
 import {
   encodeFramesChunkedConcat,
@@ -6077,6 +6141,100 @@ function videoEncoderOptions(input, engineCfg) {
     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";
+}
+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 = spawnStreamingEncoder4(
+    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((resolve9) => wake = resolve9);
+      }
+      if (signal.aborted) return;
+      const mergedPath = join12(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,
@@ -6390,6 +6548,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
             options.cfg
           );
           pushWorkerDedupPerfs(workerResults, options.dedupPerfs);
+          if (options.pageErrorLines) pushWorkerPageErrors(workerResults, options.pageErrorLines);
         } finally {
           await mergeWorkerFrames(attemptWorkDir, tasks, options.framesDir);
         }
@@ -7468,15 +7627,9 @@ import { join as join19 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg6 } from "@hyperframes/engine";
 
 // src/services/distributed/mp4Stitch.ts
-import {
-  createReadStream as createReadStream4,
-  createWriteStream,
-  mkdirSync as mkdirSync8,
-  mkdtempSync as mkdtempSync3,
-  renameSync as renameSync3,
-  rmSync as rmSync8
-} from "node:fs";
+import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
 import { open } from "node:fs/promises";
+import { renameWithRetry as renameWithRetry5 } from "@hyperframes/engine";
 import { dirname as dirname9, join as join18 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
@@ -7849,7 +8002,7 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
     for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameSync3(join18(workDir, "out.mp4"), outputPath);
+    renameWithRetry5(join18(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync8(workDir, { recursive: true, force: true });
@@ -8579,6 +8732,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
   const remoteLocalPath = (rel) => join21(projectDir, ...rel.split("/"));
+  for (const [, file] of remoteFiles) {
+    declareContentAddressedUrl(file.url, file.sha256);
+    if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
+  }
   const urlByAbsentLocalPath = new Map(
     remoteFiles.map(([rel, file]) => [remoteLocalPath(rel), file.url])
   );
@@ -8700,7 +8857,8 @@ function mixPlanAudio(c, compiledDir) {
     audios: c.composition.audios,
     masterFxChain: c.composition.masterFxChain,
     abortSignal: c.abortSignal,
-    assertNotAborted: c.assertNotAborted
+    assertNotAborted: c.assertNotAborted,
+    log: c.log
   });
 }
 async function extractPlanVideos(c, deferRangeExtraction) {
@@ -8719,6 +8877,7 @@ async function extractPlanVideos(c, deferRangeExtraction) {
   if (extractResult.failureToEnforce) throw extractResult.failureToEnforce;
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
+    c.log.info("[plan] extract phases", { ...extractResult.extractionResult.phaseBreakdown });
   }
   return extractResult;
 }
@@ -8764,12 +8923,12 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const videoSourcesDir = join21(planDir, "video-sources");
   rmSync9(videoSourcesDir, { recursive: true, force: true });
   if (existsSync15(stagedVideoFrames)) {
-    renameSync4(stagedVideoFrames, videoFramesDst);
+    renameWithRetry6(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync10(videoFramesDst, { recursive: true });
   }
   if (existsSync15(finalCompiledDir)) rmSync9(finalCompiledDir, { recursive: true, force: true });
-  renameSync4(compiledDir, finalCompiledDir);
+  renameWithRetry6(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
     projectDir,
@@ -8872,7 +9031,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   }
   const planAudioPath = join21(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync15(audioResult.audioOutputPath)) {
-    renameSync4(audioResult.audioOutputPath, planAudioPath);
+    renameWithRetry6(audioResult.audioOutputPath, planAudioPath);
   }
   if (chunksCarryAudio && existsSync15(planAudioPath)) {
     if (options.sliceChunkAudio) {
@@ -8977,7 +9136,7 @@ async function buildPlanAudio(projectDir, config, workRoot, outputPath, options
   });
   try {
     let stageStarted = Date.now();
-    await extractPlanVideos(c, true);
+    await appendVideoAudioFromProbe(c);
     logPlanStage(c.log, "extract", stageStarted);
     stageStarted = Date.now();
     const mixed = await mixPlanAudio(c, c.compiledDir);
@@ -8986,7 +9145,7 @@ async function buildPlanAudio(projectDir, config, workRoot, outputPath, options
       applyDistributedAudioWarningPolicy(c.job, mixed.audioError, mixed.audioFailures, c.log);
     }
     if (!mixed.hasAudio || !existsSync15(mixed.audioOutputPath)) return { hasAudio: false };
-    renameSync4(mixed.audioOutputPath, outputPath);
+    renameWithRetry6(mixed.audioOutputPath, outputPath);
     return { hasAudio: true };
   } finally {
     rmSync9(c.workDir, { recursive: true, force: true });
@@ -9018,7 +9177,6 @@ import {
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync10,
   readdirSync as readdirSync7,
-  renameSync as renameSync6,
   rmSync as rmSync11,
   statSync as statSync6,
   writeFileSync as writeFileSync8
@@ -9026,7 +9184,7 @@ import {
 import { tmpdir } from "node:os";
 import { dirname as dirname11, isAbsolute as isAbsolute4, join as join24, relative as relative6, resolve as resolve8, sep as sep3 } from "node:path";
 import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
-import { createFrameLookupTable as createFrameLookupTable4 } from "@hyperframes/engine";
+import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry8 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
 import {
@@ -9035,11 +9193,11 @@ import {
   linkSync as linkSync2,
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync4,
-  renameSync as renameSync5,
   rmSync as rmSync10,
   statSync as statSync5,
   writeFileSync as writeFileSync7
 } from "node:fs";
+import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
 import { dirname as dirname10, join as join23 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
@@ -9128,7 +9286,7 @@ var LocalPlanV2ArtifactPublisher = class {
         if (!canFallbackToCopy(error)) throw error;
         copyFileSync6(blob.sourcePath, temporaryPath);
       }
-      renameSync5(temporaryPath, destinationPath);
+      renameWithRetry7(temporaryPath, destinationPath);
     } finally {
       rmSync10(stagingDir, { recursive: true, force: true });
     }
@@ -9142,7 +9300,7 @@ var LocalPlanV2ArtifactPublisher = class {
       }
     }
     writeFileSync7(join23(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-    renameSync5(this.temporaryDir, this.destinationDir);
+    renameWithRetry7(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
@@ -9409,7 +9567,7 @@ function writeBlob(sourcePath, destinationPath) {
   const temporaryPath = join24(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
-    renameSync6(temporaryPath, destinationPath);
+    renameWithRetry8(temporaryPath, destinationPath);
   } finally {
     rmSync11(temporaryDir, { recursive: true, force: true });
   }
@@ -9541,7 +9699,7 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
-    renameSync6(tempDir, planV2Dir);
+    renameWithRetry8(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
     rmSync11(tempDir, { recursive: true, force: true });
@@ -9826,7 +9984,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
       }),
       "utf-8"
     );
-    renameSync6(tempDir, destinationDir);
+    renameWithRetry8(tempDir, destinationDir);
   } catch (error) {
     rmSync11(tempDir, { recursive: true, force: true });
     throw error;
@@ -9904,7 +10062,6 @@ import {
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync11,
   readdirSync as readdirSync8,
-  renameSync as renameSync7,
   rmSync as rmSync12,
   statSync as statSync7,
   writeFileSync as writeFileSync9
@@ -9918,7 +10075,8 @@ import {
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig4,
   runFfmpeg as runFfmpeg7,
-  appendSoftwareEncoderThreadsArg
+  appendSoftwareEncoderThreadsArg,
+  renameWithRetry as renameWithRetry9
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -9975,7 +10133,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     const finalPath = join25(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync18(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
-    renameSync7(finalPath, outputPath);
+    renameWithRetry9(finalPath, outputPath);
     log.info("[assemble] stage timings", {
       ...stageMs,
       chunks: chunkPaths.length,
@@ -10045,7 +10203,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
     "-r",
     fpsArg
   ];
-  appendSoftwareEncoderThreadsArg(args);
+  appendSoftwareEncoderThreadsArg(args, "libx264");
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
@@ -10227,6 +10385,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync12, readdirSync as readdirSync9, rmSync as rmSync13, writeFileSync as writeFileSync10 } from "node:fs";
+import { cpus } from "node:os";
 import { join as join26 } from "node:path";
 import {
   assertSwiftShader,
@@ -10531,6 +10690,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     let forceScreenshotForChunk = encoder.forceScreenshot;
     let shownBoxes;
     let extraction;
+    const overlap = { current: null };
     try {
       if (chunkWorkerCount === 1 || !forceScreenshotForChunk) {
         const bootStarted = Date.now();
@@ -10618,6 +10778,59 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         videoFrameLookup,
         frameCacheOptions(cfg, chunkWorkerCount)
       );
+      const isPngSequence = plan2.dimensions.format === "png-sequence";
+      outputKind = isPngSequence ? "frame-dir" : "file";
+      const presetFormat = isPngSequence ? "mp4" : plan2.dimensions.format;
+      const basePreset = getEncoderPreset6(job.config.quality, presetFormat, void 0);
+      const preset = resolvePresetForLockedEncoder(basePreset, encoder.encoder);
+      const effectiveQuality = encoder.crf ?? preset.quality;
+      const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
+      const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
+      if (isPngSequence) {
+        if (!existsSync19(outputChunkPath)) mkdirSync14(outputChunkPath, { recursive: true });
+      } else {
+        const outDir = join26(outputChunkPath, "..");
+        if (!existsSync19(outDir)) mkdirSync14(outDir, { recursive: true });
+      }
+      const encodeInput = {
+        job,
+        log,
+        outputPath: videoOnlyPath,
+        framesDir,
+        videoOnlyPath,
+        width: Math.round(plan2.dimensions.width * encoder.deviceScaleFactor),
+        height: Math.round(plan2.dimensions.height * encoder.deviceScaleFactor),
+        needsAlpha: plan2.dimensions.format !== "mp4",
+        captureImageFormat: captureOptions.format ?? "jpeg",
+        // The encoder writes video only; audio joins at assemble time or in the
+        // chunk that carries audio. Suppressing `hasAudio` skips the png-sequence audio
+        // sidecar AND the mp4 audio mux.
+        hasAudio: false,
+        isPngSequence,
+        // `DistributedFormat` has no "gif" member — distributed chunks are
+        // always video segments (gif renders in-process only).
+        isGif: false,
+        preset,
+        effectiveQuality,
+        effectiveBitrate,
+        engineConfig: {
+          ffmpegEncodeTimeout: cfg.ffmpegEncodeTimeout,
+          vp9CpuUsed: resolveLockedVp9CpuUsed(encoder) ?? cfg.vp9CpuUsed
+        },
+        // Distributed chunks emit a single ffmpeg call per chunk; the
+        // in-process per-chunk-within-chunk path would re-split our
+        // already-chunked work.
+        enableChunkedEncode: false,
+        chunkedEncodeSize: framesInChunk,
+        abortSignal: void 0,
+        assertNotAborted: () => {
+        },
+        // GOP === framesInChunk + force-keyframe at frame 0 → the chunk's
+        // first frame is an IDR keyframe and concat-copy at assemble time
+        // round-trips losslessly.
+        lockGopForChunkConcat: !isPngSequence,
+        gopSize: framesInChunk
+      };
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
         forceScreenshot: forceScreenshotForChunk,
@@ -10650,6 +10863,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           }
           const captureSession = session;
           session = null;
+          overlap.current = canEncodeWhileCapturing(encodeInput, chunkWorkerCount, cpus().length) ? encodeWhileCapturing(encodeInput, framesInChunk) : null;
           await runCaptureStage({
             fileServer,
             workDir,
@@ -10669,7 +10883,12 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             abortSignal: void 0,
             assertNotAborted: () => {
             },
-            frameRange: range
+            frameRange: range,
+            onFrameLanded: (frame) => overlap.current?.onFrameLanded(frame)
+          }).catch(async (captureError) => {
+            await overlap.current?.abort();
+            overlap.current = null;
+            throw captureError;
           });
           return observedChunkCaptureMode(capturePerfs);
         },
@@ -10701,60 +10920,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         log
       );
       framesEncoded = framesInChunk;
-      const isPngSequence = plan2.dimensions.format === "png-sequence";
-      outputKind = isPngSequence ? "frame-dir" : "file";
-      const presetFormat = isPngSequence ? "mp4" : plan2.dimensions.format;
-      const basePreset = getEncoderPreset6(job.config.quality, presetFormat, void 0);
-      const preset = resolvePresetForLockedEncoder(basePreset, encoder.encoder);
-      const effectiveQuality = encoder.crf ?? preset.quality;
-      const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
-      const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
-      if (isPngSequence) {
-        if (!existsSync19(outputChunkPath)) mkdirSync14(outputChunkPath, { recursive: true });
-      } else {
-        const outDir = join26(outputChunkPath, "..");
-        if (!existsSync19(outDir)) mkdirSync14(outDir, { recursive: true });
-      }
       const encodeStarted = Date.now();
-      await runEncodeStage({
-        job,
-        log,
-        outputPath: videoOnlyPath,
-        framesDir,
-        videoOnlyPath,
-        width: Math.round(plan2.dimensions.width * encoder.deviceScaleFactor),
-        height: Math.round(plan2.dimensions.height * encoder.deviceScaleFactor),
-        needsAlpha: plan2.dimensions.format !== "mp4",
-        captureImageFormat: captureOptions.format ?? "jpeg",
-        // The encoder writes video only; audio joins at assemble time or in the
-        // chunk that carries audio. Suppressing `hasAudio` skips the png-sequence audio
-        // sidecar AND the mp4 audio mux.
-        hasAudio: false,
-        isPngSequence,
-        // `DistributedFormat` has no "gif" member — distributed chunks are
-        // always video segments (gif renders in-process only).
-        isGif: false,
-        preset,
-        effectiveQuality,
-        effectiveBitrate,
-        engineConfig: {
-          ffmpegEncodeTimeout: cfg.ffmpegEncodeTimeout,
-          vp9CpuUsed: resolveLockedVp9CpuUsed(encoder) ?? cfg.vp9CpuUsed
-        },
-        // Distributed chunks emit a single ffmpeg call per chunk; the
-        // in-process per-chunk-within-chunk path would re-split our
-        // already-chunked work.
-        enableChunkedEncode: false,
-        chunkedEncodeSize: framesInChunk,
-        abortSignal: void 0,
-        assertNotAborted: () => {
-        },
-        // GOP === framesInChunk + force-keyframe at frame 0 → the chunk's
-        // first frame is an IDR keyframe and concat-copy at assemble time
-        // round-trips losslessly.
-        lockGopForChunkConcat: !isPngSequence,
-        gopSize: framesInChunk
-      });
+      const overlapped = overlap.current;
+      overlap.current = null;
+      await (overlapped ? overlapped.finish() : runEncodeStage(encodeInput));
       if (encoder.chunksCarryAudio) {
         const audioScratchPath = `${outputChunkPath}.audio.m4a`;
         const audioChunks = options?.frameRange ? chunksWithSubRange(chunks, chunkIndex, range) : { chunks, index: chunkIndex };
@@ -10772,6 +10941,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
+      await overlap.current?.abort().catch(() => {
+      });
       await extraction?.catch(() => {
       });
       if (session) {
@@ -11201,6 +11372,24 @@ async function buildAudioSidecar(inputPath, outputPath, signal) {
 }
 var isMissing = (result) => result.error?.code === "ENOENT";
 var ffmpegIsMissing = async (signal) => isMissing(await runFfmpeg8(["-version"], { signal }));
+
+// src/services/distributed/probeFacts.ts
+import { writeFileSync as writeFileSync11 } from "node:fs";
+import { extname as extname6 } from "node:path";
+import { buildProbeFactsText } from "@hyperframes/engine";
+var PROBE_FACTS_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".m4v", ".webm", ".mkv"]);
+function wantsProbeFacts(path) {
+  return PROBE_FACTS_EXTENSIONS.has(extname6(path).toLowerCase());
+}
+async function buildProbeFacts(inputPath, outputPath, signal) {
+  try {
+    writeFileSync11(outputPath, await buildProbeFactsText(inputPath, signal));
+    return "built";
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return /ffprobe not found/i.test(String(error.message)) ? "unavailable" : "none";
+  }
+}
 export {
   AUDIO_SIDECAR_MIN_BYTES,
   CHUNK_EXCEEDS_WORKER_TIMEOUT,
@@ -11248,6 +11437,7 @@ export {
   buildAudioSidecar,
   buildChunkSlices,
   buildPlanAudio,
+  buildProbeFacts,
   buildStitchedHeader,
   chunksAreStitchedMp4,
   createPlanV2FromExecutionPlan,
@@ -11282,5 +11472,6 @@ export {
   validateDistributedRenderConfig,
   validatePlanV2MaterializedTarget,
   validateVariablesPayload,
-  wantsAudioSidecar
+  wantsAudioSidecar,
+  wantsProbeFacts
 };