@hyperframes/producer 0.9.14 → 0.9.15

package/dist/distributed.js

@@ -8,7 +8,7 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync6,
   cpSync as cpSync2,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   linkSync,
   mkdirSync as mkdirSync10,
   rmSync as rmSync7,
@@ -71,7 +71,7 @@ var defaultLogger = createConsoleLogger("info");
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync3,
   rmSync as rmSync5,
@@ -5927,6 +5927,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/render/stages/audioStage.ts
+import { existsSync as existsSync9 } from "node:fs";
 import { join as join12 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
@@ -6060,8 +6061,9 @@ 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;
+var gainFilter = (gainDb) => `volume=${gainDb.toFixed(3)}dB`;
 function aacTruePeakCorrectionFilter(targetDurationSeconds, attenuationDb) {
-  return `volume=${attenuationDb.toFixed(3)}dB,apad,atrim=0:${formatSeconds(targetDurationSeconds)}`;
+  return `${gainFilter(attenuationDb)},apad,atrim=0:${formatSeconds(targetDurationSeconds)}`;
 }
 function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
   const delta = targetDurationSeconds - sourceDurationSeconds;
@@ -6099,7 +6101,7 @@ 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 encode = input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal);
+  const encode = input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal, input.sourcePath);
   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),
@@ -6147,7 +6149,12 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   );
   try {
     for (const step of plan.steps) {
-      const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(input.audioPath, input.outputPath, targetDurationSeconds, step.filter);
+      const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(
+        input.sourcePath ?? input.audioPath,
+        input.outputPath,
+        targetDurationSeconds,
+        step.filter
+      );
       if (!ffmpegResult.success) {
         return {
           success: false,
@@ -6176,6 +6183,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
   if (probeTruePeak) {
     const correction = await enforceAacTruePeak({
       audioPath: input.outputPath,
+      sourcePath: input.sourcePath,
       targetDurationSeconds,
       signal: input.signal,
       probeTruePeak,
@@ -6211,9 +6219,27 @@ async function constrainAacTruePeak(input) {
     targetDurationSeconds: input.targetDurationSeconds,
     signal: input.signal,
     probeTruePeak: input.probeTruePeakDbfs ?? ((audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal })),
-    encode: input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
+    encode: input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal, input.sourcePath),
+    rewriteSource: input.rewriteSource ?? ((sourcePath, outputPath, filter) => defaultRunFfmpeg(
+      ["-i", sourcePath, "-af", filter, "-c:a", "pcm_f32le", "-y", outputPath],
+      timeoutMs,
+      input.signal
+    ))
   });
 }
+async function cutSource(input, scratchDir, attenuationDb) {
+  if (!input.sourcePath || !input.rewriteSource) return true;
+  const cutPath = join10(scratchDir, "source.wav");
+  try {
+    const result = await input.rewriteSource(input.sourcePath, cutPath, gainFilter(attenuationDb));
+    if (!result.success) throw new Error(result.error);
+    renameWithRetry5(cutPath, input.sourcePath, { copyFallback: true });
+    return true;
+  } catch {
+    removeScratch(input.sourcePath);
+    return false;
+  }
+}
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
@@ -6233,8 +6259,10 @@ async function enforceAacTruePeak(input) {
       }
       if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
         if (measuredPath !== correctedPath) return { success: true };
+        const sourceCut = await cutSource(input, scratchDir, attenuationDb);
         renameWithRetry5(correctedPath, input.audioPath, { copyFallback: true });
-        return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
+        const loweredDb = Number((-attenuationDb).toFixed(2));
+        return sourceCut ? { success: true, loweredDb } : { success: true, loweredDb, sourceStale: true };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
       const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
@@ -6244,7 +6272,7 @@ async function enforceAacTruePeak(input) {
       const referenceDbfs = Math.max(truePeakDbfs, (sourcePeakDbfs ?? -Infinity) + attenuationDb);
       attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - referenceDbfs;
       const result = await input.encode(
-        input.audioPath,
+        input.sourcePath ?? input.audioPath,
         correctedPath,
         input.targetDurationSeconds,
         aacTruePeakCorrectionFilter(input.targetDurationSeconds, attenuationDb)
@@ -6473,36 +6501,54 @@ async function runAudioStageScoped(input) {
   const stageStart = Date.now();
   const pcmSourcePath = join12(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
+  let deliverySourcePath;
   try {
     const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
     let audioLoweredDb;
     if (result.hasAudio) {
       const guardStart = Date.now();
-      const limited = await limitDeliveryPeaks({
-        audioPath: result.audioOutputPath,
-        sourcePath: pcmSourcePath,
-        targetDurationSeconds: duration,
-        signal: input.abortSignal,
-        timeoutMs: input.ffmpegProcessTimeout,
-        warn: (message, details) => input.log?.warn?.(message, details)
-      });
-      if (!limited.success) throw encoderFailureError("Audio true-peak limit failed", limited);
-      const peak = await constrainAacTruePeak({
-        audioPath: result.audioOutputPath,
-        sourcePath: pcmSourcePath,
-        targetDurationSeconds: duration,
-        signal: input.abortSignal,
-        timeoutMs: input.ffmpegProcessTimeout
-      });
-      if (!peak.success) throw encoderFailureError("Audio true-peak check failed", peak);
-      audioLoweredDb = peak.loweredDb;
+      const guard = await guardDeliveryPeaks(
+        input,
+        result.audioOutputPath,
+        pcmSourcePath,
+        duration
+      );
+      audioLoweredDb = guard.loweredDb;
       input.log?.info("[audio] phases", { ...result.audioPhaseMs, guard: Date.now() - guardStart });
+      if (input.keepDeliverySource && !guard.sourceStale && existsSync9(pcmSourcePath)) {
+        deliverySourcePath = pcmSourcePath;
+      }
     }
-    return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
+    return {
+      ...result,
+      audioLoweredDb,
+      deliverySourcePath,
+      audioProcessMs: Date.now() - stageStart
+    };
   } finally {
-    removeScratch2(pcmSourcePath);
+    if (!deliverySourcePath) removeScratch2(pcmSourcePath);
   }
 }
+async function guardDeliveryPeaks(input, audioPath, sourcePath, duration) {
+  const limited = await limitDeliveryPeaks({
+    audioPath,
+    sourcePath,
+    targetDurationSeconds: duration,
+    signal: input.abortSignal,
+    timeoutMs: input.ffmpegProcessTimeout,
+    warn: (message, details) => input.log?.warn?.(message, details)
+  });
+  if (!limited.success) throw encoderFailureError("Audio true-peak limit failed", limited);
+  const peak = await constrainAacTruePeak({
+    audioPath,
+    sourcePath,
+    targetDurationSeconds: duration,
+    signal: input.abortSignal,
+    timeoutMs: input.ffmpegProcessTimeout
+  });
+  if (!peak.success) throw encoderFailureError("Audio true-peak check failed", peak);
+  return { loweredDb: peak.loweredDb, sourceStale: peak.sourceStale };
+}
 async function mixAudioForDelivery(input, duration, pcmSourcePath) {
   const {
     projectDir,
@@ -6597,7 +6643,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync9, readdirSync, statfsSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync, statfsSync } from "node:fs";
 import { join as join13 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
@@ -6649,7 +6695,7 @@ function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remed
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
   let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync9(workDir)) return total;
+  if (!existsSync10(workDir)) return total;
   for (const attempt of readdirSync(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
       total += sampleDirectoryBytes(join13(workDir, attempt));
@@ -6986,7 +7032,7 @@ import {
 // src/services/render/stages/encodeStage.ts
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
   readFileSync as readFileSync5,
@@ -7120,7 +7166,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync10(outputPath) ? statSync4(outputPath).size : 0;
+    const fileSize = existsSync11(outputPath) ? statSync4(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -7281,7 +7327,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync10(outputPath)) mkdirSync5(outputPath, { recursive: true });
+    if (!existsSync11(outputPath)) mkdirSync5(outputPath, { recursive: true });
     const captured = readdirSync2(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -7292,7 +7338,7 @@ async function runEncodeStage(input) {
       const dst = join14(outputPath, formatExportFrameName(i, "png"));
       copyFileSync4(join14(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync10(audioOutputPath)) {
+    if (hasAudio && audioOutputPath && existsSync11(audioOutputPath)) {
       copyFileSync4(audioOutputPath, join14(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
@@ -7459,7 +7505,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join15(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync11(framePath) || statSync5(framePath).size <= 8;
+    const missing = !existsSync12(framePath) || statSync5(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -7549,7 +7595,7 @@ function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join15(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync11(framePath)) captured++;
+    if (existsSync12(framePath)) captured++;
   }
   return captured;
 }
@@ -7776,7 +7822,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/chunkFrames.ts
-import { existsSync as existsSync13, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync4 } from "node:fs";
 import { extname as extname2, join as join17 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
@@ -7788,7 +7834,7 @@ import {
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
 import { dirname as dirname10, join as join16 } from "node:path";
-import { existsSync as existsSync12, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync6 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -7804,7 +7850,7 @@ function isPlanAudioArtifactPath(path) {
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
     const candidate = join16(planDir, name);
-    if (existsSync12(candidate)) return candidate;
+    if (existsSync13(candidate)) return candidate;
   }
   return null;
 }
@@ -8065,7 +8111,7 @@ function readProducerVersion() {
   let current = startDir;
   for (let i = 0; i < 10; i++) {
     const candidate = join16(current, "package.json");
-    if (existsSync12(candidate)) {
+    if (existsSync13(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync6(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
@@ -8119,7 +8165,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
   const result = [];
   for (const v of videos) {
     const outputDir = join17(planDir, "video-frames", v.videoId);
-    if (!existsSync13(outputDir)) {
+    if (!existsSync14(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
       );
@@ -8235,7 +8281,7 @@ async function extractDeferredVideoFramesForChunk(input) {
       const range = video.deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
       const sourcePath = remoteUrl ?? join17(input.planDir, ...range.sourcePath.split("/"));
-      if (remoteUrl === void 0 && !existsSync13(sourcePath)) {
+      if (remoteUrl === void 0 && !existsSync14(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
           `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
@@ -8453,7 +8499,7 @@ async function readPlanReferenceBackground(input) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join20, relative as relative3, resolve as resolve8 } from "node:path";
 import {
   REFERENCE_BACKGROUND_FIELD,
@@ -8647,7 +8693,7 @@ function planFileSha256(absolutePath, digests) {
   return sha256;
 }
 async function prehashPlanFiles(dir, digests) {
-  if (!existsSync14(dir)) return;
+  if (!existsSync15(dir)) return;
   for (const { absolutePath } of listPlanFiles(dir)) {
     if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
   }
@@ -8717,15 +8763,15 @@ function writePlanRemoteFiles(planDir, files) {
 }
 function readPlanRemoteFiles(planDir) {
   const path = join20(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync14(path) ? JSON.parse(readFileSync7(path, "utf-8")) : [];
+  return existsSync15(path) ? JSON.parse(readFileSync7(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join20(planDir, "plan.json");
   const encoderJsonPath = join20(planDir, "meta", "encoder.json");
-  if (!existsSync14(planJsonPath)) {
+  if (!existsSync15(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  if (!existsSync14(encoderJsonPath)) {
+  if (!existsSync15(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
   const planJson = JSON.parse(readFileSync7(planJsonPath, "utf-8"));
@@ -8755,11 +8801,11 @@ async function freezePlan(input) {
     hasAudio,
     digests
   } = input;
-  if (!existsSync14(planDir)) {
+  if (!existsSync15(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
   const metaDir = join20(planDir, "meta");
-  if (!existsSync14(metaDir)) mkdirSync7(metaDir, { recursive: true });
+  if (!existsSync15(metaDir)) mkdirSync7(metaDir, { recursive: true });
   writeFileSync5(
     join20(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
@@ -8836,7 +8882,7 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync4, existsSync as existsSync15, ftruncateSync, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync8 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync16, ftruncateSync, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync8 } from "node:fs";
 import { writeFileSync as writeFileSync6, writeSync } from "node:fs";
 import { join as join22 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
@@ -9327,7 +9373,7 @@ async function writeChunkAudioSlices(input) {
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
   const layoutPath = join22(planDir, SLICE_LAYOUT);
-  if (!existsSync15(layoutPath)) return resolvePlanAudioPath(planDir);
+  if (!existsSync16(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync8(layoutPath, "utf-8"));
   const frame = readFileSync8(join22(planDir, SLICE_FRAME));
   const fd = openSync4(scratchPath, "w");
@@ -9891,7 +9937,7 @@ function createVideoSourceShipper(input) {
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync16(join24(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync17(join24(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
@@ -9919,7 +9965,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync16(planDir)) mkdirSync10(planDir, { recursive: true });
+  if (!existsSync17(planDir)) mkdirSync10(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -9949,7 +9995,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   });
   const entryFile = config.entryFile ?? "index.html";
   const htmlPath = join24(projectDir, entryFile);
-  if (!existsSync16(htmlPath)) {
+  if (!existsSync17(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
   const workDir = join24(planDir, ".plan-work");
@@ -10178,15 +10224,15 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   logPlanStage(log, "extract", stageStarted);
   const stagedVideoFrames = join24(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join24(planDir, "video-frames");
-  if (existsSync16(videoFramesDst)) rmSync7(videoFramesDst, { recursive: true, force: true });
+  if (existsSync17(videoFramesDst)) rmSync7(videoFramesDst, { recursive: true, force: true });
   const videoSourcesDir = join24(planDir, "video-sources");
   rmSync7(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync16(stagedVideoFrames)) {
+  if (existsSync17(stagedVideoFrames)) {
     renameWithRetry8(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync10(videoFramesDst, { recursive: true });
   }
-  if (existsSync16(finalCompiledDir)) rmSync7(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync17(finalCompiledDir)) rmSync7(finalCompiledDir, { recursive: true, force: true });
   renameWithRetry8(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -10306,10 +10352,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
   const planAudioPath = join24(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult?.hasAudio && existsSync16(audioResult.audioOutputPath)) {
+  if (audioResult?.hasAudio && existsSync17(audioResult.audioOutputPath)) {
     renameWithRetry8(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio && existsSync16(planAudioPath)) {
+  if (chunksCarryAudio && existsSync17(planAudioPath)) {
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
       await writeChunkAudioSlices({
@@ -10422,7 +10468,7 @@ async function buildPlanAudio(projectDir, config, workRoot, outputPath, options
     if (mixed.audioError) {
       applyDistributedAudioWarningPolicy(c.job, mixed.audioError, mixed.audioFailures, c.log);
     }
-    if (!mixed.hasAudio || !existsSync16(mixed.audioOutputPath)) return { hasAudio: false };
+    if (!mixed.hasAudio || !existsSync17(mixed.audioOutputPath)) return { hasAudio: false };
     renameWithRetry8(mixed.audioOutputPath, outputPath);
     return { hasAudio: true };
   } finally {
@@ -10437,7 +10483,7 @@ import {
 } from "@hyperframes/engine";
 import {
   copyFileSync as copyFileSync8,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync4,
@@ -10455,7 +10501,7 @@ import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as r
 // src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   linkSync as linkSync2,
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync3,
@@ -10524,7 +10570,7 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync17(destinationDir)) {
+    if (existsSync18(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
@@ -10541,7 +10587,7 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync17(destinationPath)) return;
+    if (existsSync18(destinationPath)) return;
     mkdirSync11(dirname12(destinationPath), { recursive: true });
     const stagingDir = mkdtempSync3(join26(dirname12(destinationPath), ".plan-v2-blob-"));
     const temporaryPath = join26(stagingDir, "blob");
@@ -10559,7 +10605,7 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync17(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync18(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
@@ -10638,7 +10684,7 @@ function assertValidExtractionCacheCompleteSentinel(path) {
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
   const videoRoot = join27(executionPlanDir, "video-frames");
-  if (!existsSync18(videoRoot)) return;
+  if (!existsSync19(videoRoot)) return;
   for (const videoEntry of readdirSync7(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
     const videoDir = join27(videoRoot, videoEntry.name);
@@ -10739,7 +10785,7 @@ function parsePlanVideosJson2(value) {
 }
 function materializeExtractedVideoDirectories(planDir) {
   const videosPath = join27(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync18(videosPath)) return;
+  if (!existsSync19(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync12(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
@@ -10773,9 +10819,9 @@ function parseChunkSlices(value) {
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
   const videoRoot = join27(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync18(videoRoot) && listFiles(videoRoot).length > 0;
+  const hasExtractedFrames = existsSync19(videoRoot) && listFiles(videoRoot).length > 0;
   const videosPath = join27(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync18(videosPath)) {
+  if (!existsSync19(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
   const chunksPath = join27(executionPlanDir, "meta", "chunks.json");
@@ -10832,7 +10878,7 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync18(destinationPath)) return;
+  if (existsSync19(destinationPath)) return;
   mkdirSync12(dirname13(destinationPath), { recursive: true });
   const temporaryDir = mkdtempSync4(join27(dirname13(destinationPath), ".plan-v2-blob-"));
   const temporaryPath = join27(temporaryDir, "blob");
@@ -10872,7 +10918,7 @@ async function putTasks(tasks) {
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
   const executionPlanPath = join27(executionPlanDir, "plan.json");
-  if (!existsSync18(executionPlanPath)) {
+  if (!existsSync19(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -10952,7 +10998,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync18(planV2Dir)) {
+  if (existsSync19(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
@@ -11038,7 +11084,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync18(planV2Dir)) {
+  if (existsSync19(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
@@ -11192,7 +11238,7 @@ function parsePlanV2Manifest(value) {
 }
 function readPlanV2Manifest(planV2Dir) {
   const manifestPath = join27(planV2Dir, "plan.json");
-  if (!existsSync18(manifestPath)) {
+  if (!existsSync19(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -11211,7 +11257,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync18(sourcePath)) {
+  if (!existsSync19(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync7(sourcePath);
@@ -11224,7 +11270,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
-  if (existsSync18(destinationDir)) {
+  if (existsSync19(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -11289,7 +11335,7 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   const markerPath = join27(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync18(markerPath)) return null;
+  if (!existsSync19(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -11307,7 +11353,7 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
     const path = join27(planDir, ...artifact.path.split("/"));
-    if (!existsSync18(path) || statSync7(path).size !== artifact.sizeBytes) {
+    if (!existsSync19(path) || statSync7(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -11331,7 +11377,7 @@ import {
 } from "@hyperframes/engine";
 import {
   cpSync as cpSync3,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync10,
@@ -11386,7 +11432,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   }
   const format = plan.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync19(dirname14(outputPath))) {
+  if (!existsSync20(dirname14(outputPath))) {
     mkdirSync13(dirname14(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
@@ -11410,7 +11456,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
     const finalPath = join28(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync19(audioPath) ? audioPath : null;
+    const audio = audioPath !== null && existsSync20(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameWithRetry11(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -11428,7 +11474,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync19(outputPath) ? statSync8(outputPath).size : 0;
+  const fileSize = existsSync20(outputPath) ? statSync8(outputPath).size : 0;
   return {
     ...referenceBackgroundResult6(plan[REFERENCE_BACKGROUND_FIELD4]),
     outputPath,
@@ -11440,13 +11486,13 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
 function readAssemblePlan(planDir, chunkPaths) {
   const planJsonPath = join28(planDir, "plan.json");
   const chunksJsonPath = join28(planDir, "meta", "chunks.json");
-  if (!existsSync19(planJsonPath)) {
+  if (!existsSync20(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync19(chunksJsonPath)) {
+  if (!existsSync20(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync10(chunksJsonPath, "utf-8"));
@@ -11461,7 +11507,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     }
   }
   for (const path of chunkPaths.flat()) {
-    if (!existsSync19(path)) {
+    if (!existsSync20(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -11600,7 +11646,7 @@ function planFormat(planDir) {
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join28(planDir, "meta", "encoder.json");
-  if (!existsSync19(encoderJsonPath)) return {};
+  if (!existsSync20(encoderJsonPath)) return {};
   return JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
@@ -11610,7 +11656,7 @@ function readCfrEncoder(planDir, format) {
     );
   }
   const encoderJsonPath = join28(planDir, "meta", "encoder.json");
-  if (!existsSync19(encoderJsonPath)) {
+  if (!existsSync20(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
@@ -11622,7 +11668,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync19(outputPath)) rmSync10(outputPath, { recursive: true, force: true });
+  if (existsSync20(outputPath)) rmSync10(outputPath, { recursive: true, force: true });
   mkdirSync13(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -11646,7 +11692,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       `[assemble] png-sequence frame count mismatch: merged ${globalIdx} frames vs plan.totalFrames=${totalFrames}. Using on-disk count.`
     );
   }
-  if (audioPath !== null && existsSync19(audioPath)) {
+  if (audioPath !== null && existsSync20(audioPath)) {
     const sidecar = join28(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
@@ -11667,7 +11713,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync11, readdirSync as readdirSync9, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync11, readdirSync as readdirSync9, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
 import { cpus } from "node:os";
 import { join as join29 } from "node:path";
 import {
@@ -11813,7 +11859,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const planJsonPath = join29(planDir, "plan.json");
   const encoderJsonPath = join29(planDir, "meta", "encoder.json");
   const chunksJsonPath = join29(planDir, "meta", "chunks.json");
-  if (!existsSync20(planJsonPath)) {
+  if (!existsSync21(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -11829,7 +11875,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const v2Manifest = v2Materialization?.manifest ?? null;
   const remoteSources = v2Materialization?.remoteSources ?? {};
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync20(required)) {
+    if (!existsSync21(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -11840,7 +11886,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
   const videosJsonPath = join29(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync20(videosJsonPath)) {
+  if (existsSync21(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync11(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -11871,7 +11917,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
   const compiledDir = join29(planDir, "compiled");
-  if (!existsSync20(compiledDir)) {
+  if (!existsSync21(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -12121,10 +12167,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
       const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
-        if (!existsSync20(outputChunkPath)) mkdirSync14(outputChunkPath, { recursive: true });
+        if (!existsSync21(outputChunkPath)) mkdirSync14(outputChunkPath, { recursive: true });
       } else {
         const outDir = join29(outputChunkPath, "..");
-        if (!existsSync20(outDir)) mkdirSync14(outDir, { recursive: true });
+        if (!existsSync21(outDir)) mkdirSync14(outDir, { recursive: true });
       }
       const encodeInput = {
         job,