hyperframes 0.8.192 → 0.8.193

package/dist/{chunk-ULTKB5FC.js → chunk-6DLCOQR4.js}

@@ -8,7 +8,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-YMQQXPD5.js";
+} from "./chunk-TY3LDJA3.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -74,6 +74,7 @@ import {
   createFrameReorderBuffer,
   createVideoFrameInjector,
   declareContentAddressedUrl,
+  declareProbeFactsUrl,
   decodePng,
   decodePngToRgb48le,
   deriveBeginFrameProbeTimeTicks,
@@ -137,6 +138,7 @@ import {
   readWebGlVendorInfoFromCanvas,
   recaptureDrawElementFrameForVerify,
   removeDomLayerMask,
+  renameWithRetry,
   resampleRgb48leObjectFit,
   resolveBrowserGpuMode,
   resolveConfig,
@@ -157,7 +159,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-QX4TB4NH.js";
+} from "./chunk-L4JB7LI4.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
@@ -172,7 +174,7 @@ import {
   parseVfxChain,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-MGBUWPXX.js";
+} from "./chunk-7HTH5PFK.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -185,7 +187,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-AEXVVABM.js";
+} from "./chunk-3W4B6G7Y.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -213,7 +215,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-B2XLXD7V.js";
+} from "./chunk-USWPZXEA.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-X7HBSTCZ.js";
@@ -1570,16 +1572,7 @@ var RenderExecutionContext = class {
 };
 
 // ../producer/src/services/render/artifactTransaction.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync5,
-  fstatSync as fstatSync2,
-  openSync as openSync2,
-  readSync,
-  readdirSync as readdirSync2,
-  renameSync,
-  rmSync as rmSync3
-} from "fs";
+import { closeSync as closeSync2, existsSync as existsSync5, fstatSync as fstatSync2, openSync as openSync2, readSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "fs";
 import { basename as basename3, dirname as dirname4, extname as extname2, join as join5, resolve as resolve4 } from "path";
 
 // ../producer/src/services/render/renderDirOwner.ts
@@ -1692,7 +1685,7 @@ function createRenderWorkDir(prefix, outputDir) {
 // ../producer/src/services/render/artifactTransaction.ts
 var defaultFileSystem = {
   existsSync: existsSync5,
-  renameSync,
+  renameSync: (source, destination) => renameWithRetry(source, destination),
   rmSync: rmSync3
 };
 async function defaultArtifactDurationProbe(path) {
@@ -2079,36 +2072,8 @@ function replanAfterFailure(plan2, failure) {
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, rmSync as rmSync5, statSync as statSync2 } from "fs";
 import { join as join9 } from "path";
 
-// ../producer/src/services/render/captureStageError.ts
-var CaptureStageError = class extends CaptureFailure {
-  browserConsole;
-  constructor(input) {
-    const classified = classifyCaptureFailure(input.cause);
-    super({
-      kind: classified.kind,
-      message: normalizeErrorMessage(input.cause),
-      cause: input.cause,
-      workerDiagnostics: classified.workerDiagnostics
-    });
-    this.name = "CaptureStageError";
-    this.browserConsole = input.browserConsole.slice();
-    if (input.cause instanceof Error && input.cause.stack) {
-      this.stack = input.cause.stack;
-    }
-  }
-};
-function wrapCaptureStageError(error, browserConsole) {
-  if (error instanceof CaptureStageError || error instanceof EncoderInterruptedError) return error;
-  return new CaptureStageError({ cause: error, browserConsole });
-}
-function getCaptureStageBrowserConsole(error) {
-  if (error instanceof CaptureStageError) return error.browserConsole;
-  return [];
-}
-
-// ../producer/src/services/hdrCompositor.ts
-import { readSync as readSync2, closeSync as closeSync3 } from "fs";
-import { join as join6 } from "path";
+// ../producer/src/services/render/perfSummary.ts
+import { arch, cpus, platform, totalmem } from "os";
 
 // ../producer/src/services/render/hdrPerf.ts
 function createHdrPerfCollector() {
@@ -2214,7 +2179,257 @@ function finalizeHdrPerf(perf) {
   };
 }
 
+// ../producer/src/services/render/perfSummary.ts
+function worstSubTimelineWaitOutcome(perfs) {
+  const outcomes = perfs.map((p) => p.subTimelineWaitOutcome).filter((o) => !!o);
+  if (outcomes.length === 0) return void 0;
+  if (outcomes.includes("script_failure")) return "script_failure";
+  if (outcomes.includes("timeout")) return "timeout";
+  return "ready";
+}
+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))];
+}
+function roundDb(value) {
+  return value === void 0 ? void 0 : Math.round(Math.min(value, 999) * 10) / 10;
+}
+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(
+      [de.probeGateReason, ...perfs.map((p) => p.deGateReason)].filter((r) => !!r)
+    )
+  ].sort();
+  const gpuRenderers = [
+    ...new Set(perfs.map((p) => p.gpuRenderer).filter((r) => !!r))
+  ].sort();
+  const drain = de.drainStats;
+  return {
+    mode: modes.join("|") || "unknown",
+    compileGate: de.compileGate,
+    clampReason: de.clampReason,
+    workerInversion: de.workerInversion ?? "none",
+    preInversionWorkers: de.preInversionWorkers,
+    compositionElementCount: de.compositionElementCount,
+    compositionElementCountSource: de.compositionElementCountSource,
+    compositionElementTags: de.compositionElementTags,
+    arollVideoCount: de.arollVideoCount,
+    heygenVideoCount: de.heygenVideoCount,
+    adaptersUsed: de.adaptersUsed,
+    audioCount: de.audioCount,
+    imageCount: de.imageCount,
+    subCompositionCount: de.subCompositionCount,
+    audioGroupCount: de.audioGroupCount,
+    colorGradingCount: de.colorGradingCount,
+    hasLut: de.hasLut,
+    rootBodyMismatch: de.rootBodyMismatch,
+    rootBodyDeltaPxBucket: de.rootBodyDeltaPxBucket,
+    vfxHostCount: de.vfxHostCount,
+    vfxCapture: de.vfxCapture,
+    vfxTypes: de.vfxTypes,
+    shortBand: de.shortBand,
+    parallelRouter: de.parallelRouter ?? "none",
+    preRouterWorkers: de.preRouterWorkers,
+    gateReason: gateReasons.length > 0 ? gateReasons.join("|") : void 0,
+    gpuRenderer: gpuRenderers.length > 0 ? gpuRenderers.join("|") : void 0,
+    workerEncode: perfs.some((p) => p.deWorkerEncode),
+    verifyArmed: perfs.reduce((sum2, p) => sum2 + (p.deVerifyArmed ?? 0), 0),
+    verifyChecked: drain?.verifyChecked ?? 0,
+    verifyMinDb: roundDb(drain?.verifyMinDb),
+    verifyInitMs: perfs.reduce((sum2, p) => sum2 + (p.deVerifyInitMs ?? 0), 0),
+    selfVerifyFallback: de.selfVerifyFallback,
+    fallbackReason: de.fallbackReason,
+    fallbackFailedDb: roundDb(de.fallbackFailedDb),
+    fallbackFrameIndex: de.fallbackFrameIndex,
+    fallbackThresholdDb: roundDb(de.fallbackThresholdDb),
+    blankSuspects: drain?.blankSuspects ?? 0,
+    blankDeterministicAccepts: drain?.blankDeterministicAccepts ?? 0,
+    blankRecaptures: drain?.blankRecaptures ?? 0,
+    boundaryFrames: perfs.reduce((sum2, p) => sum2 + (p.deBoundaryFrames ?? 0), 0),
+    ncprFallbacks: perfs.reduce((sum2, p) => sum2 + (p.deNcprFallbacks ?? 0), 0),
+    frameTimeouts: perfs.reduce((sum2, p) => sum2 + (p.deFrameTimeouts ?? 0), 0)
+  };
+}
+function maxDefined(values) {
+  const present = values.filter((v) => typeof v === "number");
+  return present.length > 0 ? Math.max(...present) : void 0;
+}
+function aggregateChromeMemory(perfs) {
+  const sampled = perfs.filter((p) => (p.chromeMemorySamples ?? 0) > 0);
+  if (sampled.length === 0) return void 0;
+  return {
+    browserRssPeakMb: maxDefined(sampled.map((p) => p.chromeBrowserRssPeakMb)),
+    rendererRssPeakMb: maxDefined(sampled.map((p) => p.chromeRendererRssPeakMb)),
+    // Last samples are per session; summing approximates the whole fleet's
+    // footprint at the end of capture (workers run concurrently).
+    rssLastMb: sampled.reduce((sum2, p) => sum2 + (p.chromeRssLastMb ?? 0), 0),
+    gpuProcessSeenLastSample: sampled.some((p) => p.chromeGpuProcessSeenLastSample === true),
+    samples: sampled.reduce((sum2, p) => sum2 + (p.chromeMemorySamples ?? 0), 0)
+  };
+}
+function aggregateDedup(perfs) {
+  if (perfs.length === 0) return void 0;
+  const armed = perfs.some((p) => p.staticDedupArmed);
+  const skipReasons = armed ? [] : [
+    ...new Set(perfs.map((p) => p.staticDedupSkipReason).filter((r) => !!r))
+  ].sort();
+  const verificationPerfs = perfs.filter((perf) => perf.staticDedupVerificationOutcome);
+  const verificationOutcomes = [
+    ...new Set(
+      verificationPerfs.map((perf) => perf.staticDedupVerificationOutcome).filter((outcome) => outcome != null)
+    )
+  ].sort();
+  return {
+    enabled: perfs.some((p) => p.staticDedupEnabled),
+    armed,
+    predictedFrames: perfs.reduce((sum2, p) => sum2 + (p.staticDedupPredicted ?? 0), 0),
+    reusedFrames: perfs.reduce((sum2, p) => sum2 + (p.staticDedupReused ?? 0), 0),
+    skipReason: skipReasons.length > 0 ? skipReasons.join("|") : void 0,
+    ...verificationPerfs.length === 0 ? {} : {
+      verifiedFrames: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerified ?? 0),
+        0
+      ),
+      verificationOutcomes,
+      plannedRuns: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationPlannedRuns ?? 0),
+        0
+      ),
+      completedRuns: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationCompletedRuns ?? 0),
+        0
+      ),
+      screenshots: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationScreenshots ?? 0),
+        0
+      ),
+      seeks: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationSeeks ?? 0),
+        0
+      ),
+      comparisons: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationComparisons ?? 0),
+        0
+      ),
+      verificationElapsedMs: verificationPerfs.reduce(
+        (sum2, perf) => sum2 + (perf.staticDedupVerificationElapsedMs ?? 0),
+        0
+      )
+    }
+  };
+}
+function aggregateBeginFrameReuse(perfs) {
+  const noDamageFrames = perfs.reduce((sum2, p) => sum2 + (p.beginFrameNoDamage ?? 0), 0);
+  const hasDamageFrames = perfs.reduce((sum2, p) => sum2 + (p.beginFrameHasDamage ?? 0), 0);
+  if (noDamageFrames + hasDamageFrames === 0) return void 0;
+  return { noDamageFrames, hasDamageFrames };
+}
+function buildRenderPerfSummary(input) {
+  return {
+    renderId: input.job.id,
+    totalElapsedMs: input.totalElapsedMs,
+    // RenderPerfSummary surfaces fps as a decimal because it lands in JSON
+    // payloads (CLI telemetry, regression-harness reports) where a single
+    // number is friendlier than `{num,den}`. Callers needing the rational
+    // back can read `job.config.fps`.
+    fps: fpsToNumber(input.job.config.fps),
+    quality: input.job.config.quality,
+    workers: input.workerCount,
+    workerSizing: input.workerSizing,
+    chunkedEncode: input.enableChunkedEncode,
+    chunkSizeFrames: input.enableChunkedEncode ? input.chunkedEncodeSize : null,
+    compositionDurationSeconds: input.compositionDurationSeconds,
+    totalFrames: input.totalFrames,
+    resolution: { width: input.outputWidth, height: input.outputHeight },
+    videoCount: input.videoCount,
+    audioCount: input.audioCount,
+    stages: input.perfStages,
+    videoExtractBreakdown: input.videoExtractBreakdown,
+    tmpPeakBytes: input.tmpPeakBytes,
+    captureCalibration: input.captureCalibration ? {
+      sampledFrames: input.captureCalibration.samples.map((sample) => sample.frameIndex),
+      p95Ms: input.captureCalibration.estimate.p95Ms,
+      multiplier: input.captureCalibration.estimate.multiplier,
+      reasons: input.captureCalibration.estimate.reasons
+    } : void 0,
+    captureAttempts: input.captureAttempts.length > 0 ? input.captureAttempts : void 0,
+    hdrDiagnostics: input.hdrDiagnostics.videoExtractionFailures > 0 || input.hdrDiagnostics.imageDecodeFailures > 0 ? { ...input.hdrDiagnostics } : void 0,
+    hdrPerf: input.hdrPerf ? finalizeHdrPerf(input.hdrPerf) : void 0,
+    observability: input.observability,
+    captureAvgMs: input.totalFrames > 0 ? Math.round(
+      (input.perfStages.captureFrameMs ?? input.perfStages.captureMs ?? 0) / input.totalFrames
+    ) : void 0,
+    subTimelineWait: worstSubTimelineWaitOutcome(input.dedupPerfs),
+    captureP50Ms: (() => {
+      const withSamples = input.dedupPerfs.filter((p) => (p.p50TotalMs ?? 0) > 0);
+      if (withSamples.length === 0) return void 0;
+      return withSamples.reduce((a, b) => b.frames > a.frames ? b : a).p50TotalMs;
+    })(),
+    peakRssMb: Math.round(input.peakRssBytes / (1024 * 1024)),
+    peakHeapUsedMb: Math.round(input.peakHeapUsedBytes / (1024 * 1024)),
+    staticDedup: aggregateDedup(input.dedupPerfs),
+    chromeMemory: aggregateChromeMemory(input.dedupPerfs),
+    beginFrameReuse: aggregateBeginFrameReuse(input.dedupPerfs),
+    drawElement: aggregateDrawElement(
+      input.dedupPerfs,
+      input.drawElement ?? { selfVerifyFallback: false }
+    ),
+    host: {
+      platform: platform(),
+      arch: arch(),
+      cpuCount: cpus().length,
+      totalMemMb: Math.round(totalmem() / (1024 * 1024)),
+      nodeVersion: process.version,
+      gpuDisabled: input.gpuDisabled
+    }
+  };
+}
+
+// ../producer/src/services/render/captureStageError.ts
+var CaptureStageError = class extends CaptureFailure {
+  browserConsole;
+  constructor(input) {
+    const classified = classifyCaptureFailure(input.cause);
+    super({
+      kind: classified.kind,
+      message: normalizeErrorMessage(input.cause),
+      cause: input.cause,
+      workerDiagnostics: classified.workerDiagnostics,
+      pageErrorLines: classified.pageErrorLines
+    });
+    this.name = "CaptureStageError";
+    this.browserConsole = withWorkerPageErrors(input.browserConsole, [
+      ...classified.pageErrorLines
+    ]);
+    if (input.cause instanceof Error && input.cause.stack) {
+      this.stack = input.cause.stack;
+    }
+  }
+};
+function wrapCaptureStageError(error, browserConsole) {
+  if (error instanceof CaptureStageError || error instanceof EncoderInterruptedError) return error;
+  return new CaptureStageError({ cause: error, browserConsole });
+}
+function getCaptureStageBrowserConsole(error) {
+  if (error instanceof CaptureStageError) return error.browserConsole;
+  if (error instanceof CaptureFailure) return [...error.pageErrorLines];
+  return [];
+}
+
 // ../producer/src/services/hdrCompositor.ts
+import { readSync as readSync2, closeSync as closeSync3 } from "fs";
+import { join as join6 } from "path";
 function countNonZeroAlpha(rgba) {
   let n = 0;
   for (let p = 3; p < rgba.length; p += 4) {
@@ -3249,309 +3464,100 @@ async function captureTransitionFrameOnWorker(a) {
 function ensureFrameWritten(frameWritten, frameIndex, encoder) {
   if (frameWritten) return;
   const reason = encoder?.getExitError();
-  const base = `Streaming encoder exited before frame ${frameIndex} was written`;
-  throw encoderFailureError(base, {
-    error: reason,
-    failureReason: encoder?.getExitFailureReason?.()
-  });
-}
-function cleanupEndedHdrVideos(args) {
-  if (process.env.KEEP_TEMP === "1") return;
-  const {
-    time,
-    activeTransition,
-    hdrVideoEndTimes,
-    cleanedUpVideos,
-    hdrVideoFrameSources,
-    sceneElements,
-    log
-  } = args;
-  for (const [videoId, endTime] of hdrVideoEndTimes) {
-    if (time > endTime && !cleanedUpVideos.has(videoId)) {
-      const stillNeeded = activeTransition && (sceneElements[activeTransition.fromScene]?.includes(videoId) || sceneElements[activeTransition.toScene]?.includes(videoId));
-      if (!stillNeeded) {
-        const frameSource = hdrVideoFrameSources.get(videoId);
-        if (frameSource) {
-          cleanupHdrVideoFrameSource(frameSource, log);
-          hdrVideoFrameSources.delete(videoId);
-        }
-        cleanedUpVideos.add(videoId);
-      }
-    }
-  }
-}
-
-// ../producer/src/services/render/segmentPlan.ts
-var DEFAULT_SEGMENT_FRAMES = 3e3;
-var MIN_SEGMENT_FRAMES = 30;
-function assertPositiveInteger(name, value) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`[segmentPlan] ${name} must be a positive integer (got ${String(value)})`);
-  }
-}
-function planSegments(totalFrames, segmentFrames) {
-  assertPositiveInteger("totalFrames", totalFrames);
-  assertPositiveInteger("segmentFrames", segmentFrames);
-  const slices = [];
-  for (let start = 0, index = 0; start < totalFrames; start += segmentFrames, index += 1) {
-    slices.push({
-      index,
-      startFrame: start,
-      endFrame: Math.min(totalFrames, start + segmentFrames)
-    });
-  }
-  return slices;
-}
-function resolveSegmentFrames(env) {
-  const raw = env.HF_SEGMENT_FRAMES;
-  if (raw === void 0 || raw.trim() === "") return DEFAULT_SEGMENT_FRAMES;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed)) return DEFAULT_SEGMENT_FRAMES;
-  return Math.max(MIN_SEGMENT_FRAMES, parsed);
-}
-
-// ../producer/src/services/render/segmentQueue.ts
-function createSegmentQueue(slices) {
-  let cursor = 0;
-  return {
-    next: () => slices[cursor++],
-    remaining: () => Math.max(0, slices.length - cursor)
-  };
-}
-
-// ../producer/src/services/render/segmentRecycle.ts
-var DEFAULT_SEGMENT_BROWSER_RECYCLE = 3;
-function resolveSegmentBrowserRecycle(env) {
-  const raw = env.HF_SEGMENT_BROWSER_RECYCLE;
-  if (raw === void 0 || raw.trim() === "") return DEFAULT_SEGMENT_BROWSER_RECYCLE;
-  const parsed = Number(raw);
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_SEGMENT_BROWSER_RECYCLE;
-}
-var TARGET_LOSS_PATTERNS = [/target closed/i, /detached frame/i, /session closed/i];
-function isTargetLossError(error) {
-  if (!(error instanceof Error)) return false;
-  return TARGET_LOSS_PATTERNS.some((re) => re.test(error.message));
-}
-
-// ../producer/src/services/render/stages/captureStreamingStage.ts
-import { mkdtemp, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join8 } from "path";
-
-// ../producer/src/services/render/perfSummary.ts
-import { arch, cpus, platform, totalmem } from "os";
-function worstSubTimelineWaitOutcome(perfs) {
-  const outcomes = perfs.map((p) => p.subTimelineWaitOutcome).filter((o) => !!o);
-  if (outcomes.length === 0) return void 0;
-  if (outcomes.includes("script_failure")) return "script_failure";
-  if (outcomes.includes("timeout")) return "timeout";
-  return "ready";
-}
-function pushWorkerDedupPerfs(results, sink) {
-  for (const r of results) {
-    if (r.perf) sink.push(r.perf);
-  }
-}
-function roundDb(value) {
-  return value === void 0 ? void 0 : Math.round(Math.min(value, 999) * 10) / 10;
-}
-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(
-      [de.probeGateReason, ...perfs.map((p) => p.deGateReason)].filter((r) => !!r)
-    )
-  ].sort();
-  const gpuRenderers = [
-    ...new Set(perfs.map((p) => p.gpuRenderer).filter((r) => !!r))
-  ].sort();
-  const drain = de.drainStats;
-  return {
-    mode: modes.join("|") || "unknown",
-    compileGate: de.compileGate,
-    clampReason: de.clampReason,
-    workerInversion: de.workerInversion ?? "none",
-    preInversionWorkers: de.preInversionWorkers,
-    compositionElementCount: de.compositionElementCount,
-    compositionElementCountSource: de.compositionElementCountSource,
-    compositionElementTags: de.compositionElementTags,
-    arollVideoCount: de.arollVideoCount,
-    heygenVideoCount: de.heygenVideoCount,
-    adaptersUsed: de.adaptersUsed,
-    audioCount: de.audioCount,
-    imageCount: de.imageCount,
-    subCompositionCount: de.subCompositionCount,
-    audioGroupCount: de.audioGroupCount,
-    colorGradingCount: de.colorGradingCount,
-    hasLut: de.hasLut,
-    rootBodyMismatch: de.rootBodyMismatch,
-    rootBodyDeltaPxBucket: de.rootBodyDeltaPxBucket,
-    vfxHostCount: de.vfxHostCount,
-    vfxCapture: de.vfxCapture,
-    vfxTypes: de.vfxTypes,
-    shortBand: de.shortBand,
-    parallelRouter: de.parallelRouter ?? "none",
-    preRouterWorkers: de.preRouterWorkers,
-    gateReason: gateReasons.length > 0 ? gateReasons.join("|") : void 0,
-    gpuRenderer: gpuRenderers.length > 0 ? gpuRenderers.join("|") : void 0,
-    workerEncode: perfs.some((p) => p.deWorkerEncode),
-    verifyArmed: perfs.reduce((sum2, p) => sum2 + (p.deVerifyArmed ?? 0), 0),
-    verifyChecked: drain?.verifyChecked ?? 0,
-    verifyMinDb: roundDb(drain?.verifyMinDb),
-    verifyInitMs: perfs.reduce((sum2, p) => sum2 + (p.deVerifyInitMs ?? 0), 0),
-    selfVerifyFallback: de.selfVerifyFallback,
-    fallbackReason: de.fallbackReason,
-    fallbackFailedDb: roundDb(de.fallbackFailedDb),
-    fallbackFrameIndex: de.fallbackFrameIndex,
-    fallbackThresholdDb: roundDb(de.fallbackThresholdDb),
-    blankSuspects: drain?.blankSuspects ?? 0,
-    blankDeterministicAccepts: drain?.blankDeterministicAccepts ?? 0,
-    blankRecaptures: drain?.blankRecaptures ?? 0,
-    boundaryFrames: perfs.reduce((sum2, p) => sum2 + (p.deBoundaryFrames ?? 0), 0),
-    ncprFallbacks: perfs.reduce((sum2, p) => sum2 + (p.deNcprFallbacks ?? 0), 0),
-    frameTimeouts: perfs.reduce((sum2, p) => sum2 + (p.deFrameTimeouts ?? 0), 0)
-  };
-}
-function maxDefined(values) {
-  const present = values.filter((v) => typeof v === "number");
-  return present.length > 0 ? Math.max(...present) : void 0;
-}
-function aggregateChromeMemory(perfs) {
-  const sampled = perfs.filter((p) => (p.chromeMemorySamples ?? 0) > 0);
-  if (sampled.length === 0) return void 0;
-  return {
-    browserRssPeakMb: maxDefined(sampled.map((p) => p.chromeBrowserRssPeakMb)),
-    rendererRssPeakMb: maxDefined(sampled.map((p) => p.chromeRendererRssPeakMb)),
-    // Last samples are per session; summing approximates the whole fleet's
-    // footprint at the end of capture (workers run concurrently).
-    rssLastMb: sampled.reduce((sum2, p) => sum2 + (p.chromeRssLastMb ?? 0), 0),
-    gpuProcessSeenLastSample: sampled.some((p) => p.chromeGpuProcessSeenLastSample === true),
-    samples: sampled.reduce((sum2, p) => sum2 + (p.chromeMemorySamples ?? 0), 0)
-  };
-}
-function aggregateDedup(perfs) {
-  if (perfs.length === 0) return void 0;
-  const armed = perfs.some((p) => p.staticDedupArmed);
-  const skipReasons = armed ? [] : [
-    ...new Set(perfs.map((p) => p.staticDedupSkipReason).filter((r) => !!r))
-  ].sort();
-  const verificationPerfs = perfs.filter((perf) => perf.staticDedupVerificationOutcome);
-  const verificationOutcomes = [
-    ...new Set(
-      verificationPerfs.map((perf) => perf.staticDedupVerificationOutcome).filter((outcome) => outcome != null)
-    )
-  ].sort();
-  return {
-    enabled: perfs.some((p) => p.staticDedupEnabled),
-    armed,
-    predictedFrames: perfs.reduce((sum2, p) => sum2 + (p.staticDedupPredicted ?? 0), 0),
-    reusedFrames: perfs.reduce((sum2, p) => sum2 + (p.staticDedupReused ?? 0), 0),
-    skipReason: skipReasons.length > 0 ? skipReasons.join("|") : void 0,
-    ...verificationPerfs.length === 0 ? {} : {
-      verifiedFrames: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerified ?? 0),
-        0
-      ),
-      verificationOutcomes,
-      plannedRuns: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationPlannedRuns ?? 0),
-        0
-      ),
-      completedRuns: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationCompletedRuns ?? 0),
-        0
-      ),
-      screenshots: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationScreenshots ?? 0),
-        0
-      ),
-      seeks: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationSeeks ?? 0),
-        0
-      ),
-      comparisons: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationComparisons ?? 0),
-        0
-      ),
-      verificationElapsedMs: verificationPerfs.reduce(
-        (sum2, perf) => sum2 + (perf.staticDedupVerificationElapsedMs ?? 0),
-        0
-      )
+  const base = `Streaming encoder exited before frame ${frameIndex} was written`;
+  throw encoderFailureError(base, {
+    error: reason,
+    failureReason: encoder?.getExitFailureReason?.()
+  });
+}
+function cleanupEndedHdrVideos(args) {
+  if (process.env.KEEP_TEMP === "1") return;
+  const {
+    time,
+    activeTransition,
+    hdrVideoEndTimes,
+    cleanedUpVideos,
+    hdrVideoFrameSources,
+    sceneElements,
+    log
+  } = args;
+  for (const [videoId, endTime] of hdrVideoEndTimes) {
+    if (time > endTime && !cleanedUpVideos.has(videoId)) {
+      const stillNeeded = activeTransition && (sceneElements[activeTransition.fromScene]?.includes(videoId) || sceneElements[activeTransition.toScene]?.includes(videoId));
+      if (!stillNeeded) {
+        const frameSource = hdrVideoFrameSources.get(videoId);
+        if (frameSource) {
+          cleanupHdrVideoFrameSource(frameSource, log);
+          hdrVideoFrameSources.delete(videoId);
+        }
+        cleanedUpVideos.add(videoId);
+      }
     }
-  };
+  }
 }
-function aggregateBeginFrameReuse(perfs) {
-  const noDamageFrames = perfs.reduce((sum2, p) => sum2 + (p.beginFrameNoDamage ?? 0), 0);
-  const hasDamageFrames = perfs.reduce((sum2, p) => sum2 + (p.beginFrameHasDamage ?? 0), 0);
-  if (noDamageFrames + hasDamageFrames === 0) return void 0;
-  return { noDamageFrames, hasDamageFrames };
+
+// ../producer/src/services/render/segmentPlan.ts
+var DEFAULT_SEGMENT_FRAMES = 3e3;
+var MIN_SEGMENT_FRAMES = 30;
+function assertPositiveInteger(name, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`[segmentPlan] ${name} must be a positive integer (got ${String(value)})`);
+  }
 }
-function buildRenderPerfSummary(input) {
+function planSegments(totalFrames, segmentFrames) {
+  assertPositiveInteger("totalFrames", totalFrames);
+  assertPositiveInteger("segmentFrames", segmentFrames);
+  const slices = [];
+  for (let start = 0, index = 0; start < totalFrames; start += segmentFrames, index += 1) {
+    slices.push({
+      index,
+      startFrame: start,
+      endFrame: Math.min(totalFrames, start + segmentFrames)
+    });
+  }
+  return slices;
+}
+function resolveSegmentFrames(env) {
+  const raw = env.HF_SEGMENT_FRAMES;
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_SEGMENT_FRAMES;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return DEFAULT_SEGMENT_FRAMES;
+  return Math.max(MIN_SEGMENT_FRAMES, parsed);
+}
+
+// ../producer/src/services/render/segmentQueue.ts
+function createSegmentQueue(slices) {
+  let cursor = 0;
   return {
-    renderId: input.job.id,
-    totalElapsedMs: input.totalElapsedMs,
-    // RenderPerfSummary surfaces fps as a decimal because it lands in JSON
-    // payloads (CLI telemetry, regression-harness reports) where a single
-    // number is friendlier than `{num,den}`. Callers needing the rational
-    // back can read `job.config.fps`.
-    fps: fpsToNumber(input.job.config.fps),
-    quality: input.job.config.quality,
-    workers: input.workerCount,
-    workerSizing: input.workerSizing,
-    chunkedEncode: input.enableChunkedEncode,
-    chunkSizeFrames: input.enableChunkedEncode ? input.chunkedEncodeSize : null,
-    compositionDurationSeconds: input.compositionDurationSeconds,
-    totalFrames: input.totalFrames,
-    resolution: { width: input.outputWidth, height: input.outputHeight },
-    videoCount: input.videoCount,
-    audioCount: input.audioCount,
-    stages: input.perfStages,
-    videoExtractBreakdown: input.videoExtractBreakdown,
-    tmpPeakBytes: input.tmpPeakBytes,
-    captureCalibration: input.captureCalibration ? {
-      sampledFrames: input.captureCalibration.samples.map((sample) => sample.frameIndex),
-      p95Ms: input.captureCalibration.estimate.p95Ms,
-      multiplier: input.captureCalibration.estimate.multiplier,
-      reasons: input.captureCalibration.estimate.reasons
-    } : void 0,
-    captureAttempts: input.captureAttempts.length > 0 ? input.captureAttempts : void 0,
-    hdrDiagnostics: input.hdrDiagnostics.videoExtractionFailures > 0 || input.hdrDiagnostics.imageDecodeFailures > 0 ? { ...input.hdrDiagnostics } : void 0,
-    hdrPerf: input.hdrPerf ? finalizeHdrPerf(input.hdrPerf) : void 0,
-    observability: input.observability,
-    captureAvgMs: input.totalFrames > 0 ? Math.round(
-      (input.perfStages.captureFrameMs ?? input.perfStages.captureMs ?? 0) / input.totalFrames
-    ) : void 0,
-    subTimelineWait: worstSubTimelineWaitOutcome(input.dedupPerfs),
-    captureP50Ms: (() => {
-      const withSamples = input.dedupPerfs.filter((p) => (p.p50TotalMs ?? 0) > 0);
-      if (withSamples.length === 0) return void 0;
-      return withSamples.reduce((a, b) => b.frames > a.frames ? b : a).p50TotalMs;
-    })(),
-    peakRssMb: Math.round(input.peakRssBytes / (1024 * 1024)),
-    peakHeapUsedMb: Math.round(input.peakHeapUsedBytes / (1024 * 1024)),
-    staticDedup: aggregateDedup(input.dedupPerfs),
-    chromeMemory: aggregateChromeMemory(input.dedupPerfs),
-    beginFrameReuse: aggregateBeginFrameReuse(input.dedupPerfs),
-    drawElement: aggregateDrawElement(
-      input.dedupPerfs,
-      input.drawElement ?? { selfVerifyFallback: false }
-    ),
-    host: {
-      platform: platform(),
-      arch: arch(),
-      cpuCount: cpus().length,
-      totalMemMb: Math.round(totalmem() / (1024 * 1024)),
-      nodeVersion: process.version,
-      gpuDisabled: input.gpuDisabled
-    }
+    next: () => slices[cursor++],
+    remaining: () => Math.max(0, slices.length - cursor)
   };
 }
 
+// ../producer/src/services/render/segmentRecycle.ts
+var DEFAULT_SEGMENT_BROWSER_RECYCLE = 3;
+function resolveSegmentBrowserRecycle(env) {
+  const raw = env.HF_SEGMENT_BROWSER_RECYCLE;
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_SEGMENT_BROWSER_RECYCLE;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_SEGMENT_BROWSER_RECYCLE;
+}
+var TARGET_LOSS_PATTERNS = [/target closed/i, /detached frame/i, /session closed/i];
+function isTargetLossError(error) {
+  if (!(error instanceof Error)) return false;
+  return TARGET_LOSS_PATTERNS.some((re) => re.test(error.message));
+}
+
 // ../producer/src/services/render/stages/captureStreamingStage.ts
+import { mkdtemp, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join8 } from "path";
 var DEFAULT_CAPTURE_STALL_MS = 6e4;
 var DE_STALL_POLL_MS = 5e3;
 var STALL_ADVICE = "Chrome stopped answering. If another app is keeping the GPU or CPU busy (a 3D render, a game, another export), let it finish or render one job at a time, then retry.";
+function poolFailure(error, probeSession) {
+  return wrapCaptureStageError(error, probeSession?.browserConsoleBuffer ?? []);
+}
 var ParallelCaptureStallError = class extends Error {
   variant;
   constructor(args) {
@@ -3998,7 +4004,7 @@ async function runCaptureStreamingStage(input) {
           }
         );
       } catch (err) {
-        if (parallelDrainError) throw parallelDrainError;
+        if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
         if (stalled && abortSignal?.aborted !== true) {
           throw new ParallelCaptureStallError({
             variant: "pool",
@@ -4009,13 +4015,15 @@ async function runCaptureStreamingStage(input) {
             phaseSummary: phaseSummary()
           });
         }
-        throw err;
+        throw poolFailure(err, probeSession);
       } finally {
         clearInterval(stallTimer);
         abortSignal?.removeEventListener("abort", forwardParentAbort);
       }
-      if (parallelDrainError) throw parallelDrainError;
+      if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
       pushWorkerDedupPerfs(workerResults, dedupPerfs);
+      const workerPageErrors = [];
+      pushWorkerPageErrors(workerResults, workerPageErrors);
       if (parallelGuardRan) {
         deDrainStats = parallelStats;
       }
@@ -4025,6 +4033,7 @@ async function runCaptureStreamingStage(input) {
         await closeCaptureSession(probeSession);
         probeSession = null;
       }
+      lastBrowserConsole = withWorkerPageErrors(lastBrowserConsole, workerPageErrors);
     } else {
       const videoInjector = createRenderVideoFrameInjector();
       const session = probeSession ?? await createCaptureSession(
@@ -4471,7 +4480,7 @@ async function runCaptureSegmentedStage(input) {
 
 // ../producer/src/services/render/segmentManifest.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join10 } from "path";
 var MANIFEST_FILENAME = "segments.json";
 function computeSegmentPlanHash(input) {
@@ -4528,7 +4537,7 @@ function writeSegmentManifest(segmentDir, manifest) {
   mkdirSync4(segmentDir, { recursive: true });
   const tmp = join10(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
   writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameSync2(tmp, join10(segmentDir, MANIFEST_FILENAME));
+  renameWithRetry(tmp, join10(segmentDir, MANIFEST_FILENAME));
 }
 async function probeSegmentFrameCount(path, probe) {
   try {
@@ -8401,7 +8410,7 @@ import { rmSync as rmSync7 } from "fs";
 
 // ../producer/src/services/render/audioPadTrim.ts
 import { spawn } from "child_process";
-import { mkdtempSync as mkdtempSync3, renameSync as renameSync3, rmSync as rmSync6 } from "fs";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync6 } from "fs";
 import { dirname as dirname6, join as join16 } from "path";
 
 // ../producer/src/services/render/audioTruePeak.ts
@@ -8648,7 +8657,7 @@ async function enforceAacTruePeak(input) {
       }
       if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
         if (measuredPath !== correctedPath) return { success: true };
-        renameSync3(correctedPath, input.audioPath);
+        renameWithRetry(correctedPath, input.audioPath);
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
@@ -8838,6 +8847,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,
@@ -8847,6 +8857,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 {
@@ -8872,6 +8883,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
   let hasAudio = false;
   let audioError;
   let audioFailures;
+  let audioPhaseMs;
   if (audios.length > 0) {
     let audioResult;
     try {
@@ -8921,6 +8933,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 ?? []) {
@@ -8939,7 +8952,8 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     audioOutputPath,
     hasAudio,
     audioError,
-    audioFailures
+    audioFailures,
+    audioPhaseMs
   };
 }
 
@@ -9054,6 +9068,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) {
@@ -9091,6 +9106,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);
@@ -9111,6 +9127,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];
@@ -9123,6 +9144,7 @@ async function runCaptureStage(input) {
       await closeCaptureSession(probeSession);
       probeSession = null;
     }
+    lastBrowserConsole = withWorkerPageErrors(lastBrowserConsole, workerPageErrors);
   } else {
     const sequential = await runSequentialDiskCapture(
       input,
@@ -10400,7 +10422,7 @@ function videoEncoderOptions(input, engineCfg) {
   };
 }
 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;
+  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) {
@@ -11055,6 +11077,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);
         }
@@ -13433,7 +13456,6 @@ import {
   existsSync as existsSync20,
   linkSync,
   mkdirSync as mkdirSync12,
-  renameSync as renameSync5,
   rmSync as rmSync11,
   writeFileSync as writeFileSync8
 } from "fs";
@@ -14360,14 +14382,7 @@ import { writeFileSync as writeFileSync7, writeSync } from "fs";
 import { join as join30 } from "path";
 
 // ../producer/src/services/distributed/mp4Stitch.ts
-import {
-  createReadStream as createReadStream4,
-  createWriteStream,
-  mkdirSync as mkdirSync10,
-  mkdtempSync as mkdtempSync4,
-  renameSync as renameSync4,
-  rmSync as rmSync10
-} from "fs";
+import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, rmSync as rmSync10 } from "fs";
 import { open } from "fs/promises";
 import { dirname as dirname11, join as join29 } from "path";
 import { finished, pipeline } from "stream/promises";
@@ -14741,7 +14756,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);
-    renameSync4(join29(workDir, "out.mp4"), outputPath);
+    renameWithRetry(join29(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync10(workDir, { recursive: true, force: true });
@@ -15467,7 +15482,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
   const remoteLocalPath = (rel) => join32(projectDir, ...rel.split("/"));
-  for (const [, file] of remoteFiles) declareContentAddressedUrl(file.url, file.sha256);
+  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])
   );
@@ -15542,7 +15560,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-SSV66L3F.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-BH5NICGQ.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -15589,7 +15607,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) {
@@ -15608,6 +15627,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;
 }
@@ -15653,12 +15673,12 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const videoSourcesDir = join32(planDir, "video-sources");
   rmSync11(videoSourcesDir, { recursive: true, force: true });
   if (existsSync20(stagedVideoFrames)) {
-    renameSync5(stagedVideoFrames, videoFramesDst);
+    renameWithRetry(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync12(videoFramesDst, { recursive: true });
   }
   if (existsSync20(finalCompiledDir)) rmSync11(finalCompiledDir, { recursive: true, force: true });
-  renameSync5(compiledDir, finalCompiledDir);
+  renameWithRetry(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
     projectDir,
@@ -15761,7 +15781,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   }
   const planAudioPath = join32(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync20(audioResult.audioOutputPath)) {
-    renameSync5(audioResult.audioOutputPath, planAudioPath);
+    renameWithRetry(audioResult.audioOutputPath, planAudioPath);
   }
   if (chunksCarryAudio && existsSync20(planAudioPath)) {
     if (options.sliceChunkAudio) {
@@ -17193,7 +17213,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-SSV66L3F.js");
+    const { drainBrowserPool } = await import("./src-BH5NICGQ.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -17237,7 +17257,6 @@ import {
   mkdtempSync as mkdtempSync7,
   readFileSync as readFileSync12,
   readdirSync as readdirSync9,
-  renameSync as renameSync7,
   rmSync as rmSync14,
   statSync as statSync9,
   writeFileSync as writeFileSync11
@@ -17252,7 +17271,6 @@ import {
   linkSync as linkSync2,
   mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync6,
-  renameSync as renameSync6,
   rmSync as rmSync13,
   statSync as statSync8,
   writeFileSync as writeFileSync10
@@ -17345,7 +17363,7 @@ var LocalPlanV2ArtifactPublisher = class {
         if (!canFallbackToCopy(error)) throw error;
         copyFileSync5(blob.sourcePath, temporaryPath);
       }
-      renameSync6(temporaryPath, destinationPath);
+      renameWithRetry(temporaryPath, destinationPath);
     } finally {
       rmSync13(stagingDir, { recursive: true, force: true });
     }
@@ -17359,7 +17377,7 @@ var LocalPlanV2ArtifactPublisher = class {
       }
     }
     writeFileSync10(join37(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-    renameSync6(this.temporaryDir, this.destinationDir);
+    renameWithRetry(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
@@ -17626,7 +17644,7 @@ function writeBlob(sourcePath, destinationPath) {
   const temporaryPath = join38(temporaryDir, "blob");
   try {
     copyFileSync6(sourcePath, temporaryPath);
-    renameSync7(temporaryPath, destinationPath);
+    renameWithRetry(temporaryPath, destinationPath);
   } finally {
     rmSync14(temporaryDir, { recursive: true, force: true });
   }
@@ -17758,7 +17776,7 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
-    renameSync7(tempDir, planV2Dir);
+    renameWithRetry(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
     rmSync14(tempDir, { recursive: true, force: true });
@@ -18043,7 +18061,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
       }),
       "utf-8"
     );
-    renameSync7(tempDir, destinationDir);
+    renameWithRetry(tempDir, destinationDir);
   } catch (error) {
     rmSync14(tempDir, { recursive: true, force: true });
     throw error;
@@ -18121,7 +18139,6 @@ import {
   mkdtempSync as mkdtempSync8,
   readFileSync as readFileSync13,
   readdirSync as readdirSync10,
-  renameSync as renameSync8,
   rmSync as rmSync15,
   statSync as statSync10,
   writeFileSync as writeFileSync12
@@ -18181,7 +18198,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     const finalPath = join39(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync26(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
-    renameSync8(finalPath, outputPath);
+    renameWithRetry(finalPath, outputPath);
     log.info("[assemble] stage timings", {
       ...stageMs,
       chunks: chunkPaths.length,
@@ -18433,6 +18450,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 // ../producer/src/services/distributed/renderChunk.ts
 import { randomBytes } from "crypto";
 import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync14, readdirSync as readdirSync11, rmSync as rmSync16, writeFileSync as writeFileSync13 } from "fs";
+import { cpus as cpus3 } from "os";
 import { join as join40 } from "path";
 var LEGACY_DISTRIBUTED_VP9_CPU_USED = 2;
 function validatePlanVideosForChunk(value) {
@@ -18721,6 +18739,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();
@@ -18808,6 +18827,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 = getEncoderPreset(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 (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
+      } else {
+        const outDir = join40(outputChunkPath, "..");
+        if (!existsSync27(outDir)) mkdirSync17(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,
@@ -18840,6 +18912,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           }
           const captureSession = session;
           session = null;
+          overlap.current = canEncodeWhileCapturing(encodeInput, chunkWorkerCount, cpus3().length) ? encodeWhileCapturing(encodeInput, framesInChunk) : null;
           await runCaptureStage({
             fileServer,
             workDir,
@@ -18859,7 +18932,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);
         },
@@ -18891,60 +18969,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 = getEncoderPreset(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 (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
-      } else {
-        const outDir = join40(outputChunkPath, "..");
-        if (!existsSync27(outDir)) mkdirSync17(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 };
@@ -18962,6 +18990,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
+      await overlap.current?.abort().catch(() => {
+      });
       await extraction?.catch(() => {
       });
       if (session) {
@@ -19074,6 +19104,10 @@ var READ_CHUNK_BYTES = 256 * 1024;
 import { extname as extname7 } from "path";
 var AUDIO_SIDECAR_MIN_BYTES = 32 * 1024 * 1024;
 
+// ../producer/src/services/distributed/probeFacts.ts
+import { writeFileSync as writeFileSync14 } from "fs";
+import { extname as extname8 } from "path";
+
 export {
   createConsoleLogger,
   defaultLogger,