@hyperframes/producer 0.8.227 → 0.8.228

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync5,
   rmSync as rmSync10,
@@ -56,7 +56,7 @@ import {
   augmentProtocolTimeoutError,
   augmentPageNavigationTimeoutError
 } from "@hyperframes/engine";
-import { join as join27, dirname as dirname11, resolve as resolve8 } from "path";
+import { join as join28, dirname as dirname12, resolve as resolve8 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -9829,7 +9829,7 @@ async function planVideoLayerPassthrough(input) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -9838,6 +9838,16 @@ import {
   collectScratchLeftovers
 } from "@hyperframes/engine";
 
+// src/services/render/audioDeliveryLimit.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { dirname as dirname9, join as join20 } from "node:path";
+import {
+  applyAudioFxChain,
+  describeFfmpegFailure as describeFfmpegFailure3,
+  encodeAac as encodeAac2,
+  renameWithRetry as renameWithRetry6
+} from "@hyperframes/engine";
+
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
 import { mkdtempSync as mkdtempSync3 } from "node:fs";
@@ -10298,6 +10308,48 @@ async function runFfprobeJson(args, signal) {
   }
 }
 
+// src/services/render/audioDeliveryLimit.ts
+var LIMIT_CEILING_DBTP = AAC_DELIVERY_TRUE_PEAK_DBFS - 2;
+var LIMIT_CHAIN = {
+  version: 1,
+  nodes: [{ type: "truepeak", id: "delivery", params: { ceiling: LIMIT_CEILING_DBTP } }]
+};
+async function limitDeliveryPeaks(input, deps = {
+  measure: measureTruePeakDbfs,
+  applyChain: applyAudioFxChain,
+  encode: encodeAac2,
+  rename: renameWithRetry6,
+  sourceExists: existsSync13
+}) {
+  const { audioPath, sourcePath, signal, timeoutMs } = input;
+  if (!deps.sourceExists(sourcePath)) return { success: true };
+  const peak = await deps.measure(audioPath, { timeoutMs, signal });
+  if (peak <= AAC_DELIVERY_TRUE_PEAK_DBFS) return { success: true };
+  const limitedPath = join20(dirname9(sourcePath), "audio-source-limited.wav");
+  try {
+    await deps.applyChain(sourcePath, LIMIT_CHAIN, limitedPath, { trackId: "delivery", signal });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    input.warn?.("[audio] true-peak limit failed, the whole-mix cut applies", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { success: true };
+  }
+  const encoded = await deps.encode(limitedPath, audioPath, input.targetDurationSeconds, {
+    signal,
+    timeout: timeoutMs
+  });
+  if (!encoded.success) {
+    return {
+      success: false,
+      error: `[audioDeliveryLimit] ${describeFfmpegFailure3(encoded, timeoutMs)}`,
+      failureReason: encoded.failureReason
+    };
+  }
+  deps.rename(limitedPath, sourcePath, { copyFallback: true });
+  return { success: true };
+}
+
 // src/services/render/stages/audioStage.ts
 function assertAudioNotInterrupted(failures) {
   const interrupted = failures?.find((failure) => failure.reason === "external_interruption");
@@ -10321,13 +10373,22 @@ function runAudioStage(input) {
 }
 async function runAudioStageScoped(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join20(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join21(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   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,
@@ -10359,7 +10420,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join20(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join21(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -10370,7 +10431,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join20(workDir, "audio-work"),
+        join21(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -10438,8 +10499,8 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync13, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
+import { join as join22 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -10509,16 +10570,16 @@ function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remed
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
   let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync13(workDir)) return total;
+  if (!existsSync14(workDir)) return total;
   for (const attempt of readdirSync3(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join21(workDir, attempt));
+      total += sampleDirectoryBytes(join22(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join21(workDir, attempt);
+    const attemptDir = join22(workDir, attempt);
     for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join21(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join22(attemptDir, name));
     }
   }
   return total;
@@ -10812,8 +10873,8 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join26 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -10885,7 +10946,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -11010,7 +11071,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join22(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join23(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -11042,7 +11103,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -11056,9 +11117,9 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname9, join as join23 } from "node:path";
+import { dirname as dirname10, join as join24 } from "node:path";
 import { createRequire } from "node:module";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
 function resolveWorkerEntry(explicit) {
   if (explicit && explicit.length > 0) {
@@ -11069,10 +11130,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname9(fileURLToPath3(import.meta.url));
-  const jsPath = join23(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync14(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join23(moduleDir, "shaderTransitionWorker.ts");
+  const moduleDir = dirname10(fileURLToPath3(import.meta.url));
+  const jsPath = join24(moduleDir, "shaderTransitionWorker.js");
+  if (existsSync15(jsPath)) return { path: jsPath, isTs: false };
+  const tsPath = join24(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -11440,7 +11501,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join24(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join25(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -11631,8 +11692,8 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join25(framesDir, "debug-composite") : null;
-      if (debugDumpDir && !existsSync15(debugDumpDir)) {
+      const debugDumpDir = debugDumpEnabled ? join26(framesDir, "debug-composite") : null;
+      if (debugDumpDir && !existsSync16(debugDumpDir)) {
         mkdirSync8(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
@@ -11789,7 +11850,7 @@ async function runCaptureHdrStage(input) {
 // src/services/render/stages/encodeStage.ts
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
   readFileSync as readFileSync7,
@@ -11798,7 +11859,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname10, join as join26 } from "node:path";
+import { dirname as dirname11, join as join27 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
@@ -11923,7 +11984,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync16(outputPath) ? statSync7(outputPath).size : 0;
+    const fileSize = existsSync17(outputPath) ? statSync7(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -12009,7 +12070,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve13) => wake = resolve13);
       }
       if (signal.aborted) return;
-      const mergedPath = join26(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join27(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -12084,7 +12145,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync16(outputPath)) mkdirSync9(outputPath, { recursive: true });
+    if (!existsSync17(outputPath)) mkdirSync9(outputPath, { recursive: true });
     const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -12092,11 +12153,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join26(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync4(join26(framesDir, name), dst);
+      const dst = join27(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync4(join27(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync16(audioOutputPath)) {
-      copyFileSync4(audioOutputPath, join26(outputPath, MIXED_AUDIO_FILENAME2));
+    if (hasAudio && audioOutputPath && existsSync17(audioOutputPath)) {
+      copyFileSync4(audioOutputPath, join27(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -12116,7 +12177,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join26(dirname10(videoOnlyPath), "gif-palette.png"),
+      palettePath: join27(dirname11(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -12326,7 +12387,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join27(current, name);
+      const full = join28(current, name);
       try {
         const st = statSync8(full);
         if (st.isDirectory()) {
@@ -12475,8 +12536,8 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync17(framePath) || statSync8(framePath).size <= 8;
+    const framePath = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync18(framePath) || statSync8(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -12492,7 +12553,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
 function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0, stride = 1) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
-  const outputDirFor = (batchIndex, workerId) => join27(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  const outputDirFor = (batchIndex, workerId) => join28(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
   if (stride > 1) {
     const spans = /* @__PURE__ */ new Map();
     for (const range of ranges) {
@@ -12552,8 +12613,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32" || platform2 === "darwin") return join27(systemTempDir, "hf-render-");
-  return join27(dirname11(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join28(systemTempDir, "hf-render-");
+  return join28(dirname12(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -12600,8 +12661,8 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync17(framePath)) captured++;
+    const framePath = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    if (existsSync18(framePath)) captured++;
   }
   return captured;
 }
@@ -12626,7 +12687,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join27(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join28(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -13256,19 +13317,19 @@ function deVerifyFallbackTelemetry(err) {
   };
 }
 function resolveRenderDebugDir() {
-  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname11(fileURLToPath4(import.meta.url)), "../..");
-  return join27(producerRoot, ".debug");
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname12(fileURLToPath4(import.meta.url)), "../..");
+  return join28(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
   validateDeliveryEncoderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
-  const outputDir = dirname11(outputPath);
-  if (!existsSync17(outputDir)) mkdirSync10(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join27(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const outputDir = dirname12(outputPath);
+  if (!existsSync18(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  const workDir = job.config.debug ? join28(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join27(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join28(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -13329,7 +13390,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join27(workDir, "perf-summary.json");
+  const perfOutputPath = join28(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -13405,7 +13466,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync17(workDir)) mkdirSync10(workDir, { recursive: true });
+    if (!existsSync18(workDir)) mkdirSync10(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -13434,16 +13495,16 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join27(projectDir, entryFile);
-    if (!existsSync17(htmlPath)) {
+    let htmlPath = join28(projectDir, entryFile);
+    if (!existsSync18(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readTextFile2(htmlPath);
     if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join27(workDir, "standalone-entry.html");
-      const projectIndexPath = join27(projectDir, "index.html");
-      if (!existsSync17(projectIndexPath)) {
+      const wrapperPath = join28(workDir, "standalone-entry.html");
+      const projectIndexPath = join28(projectDir, "index.html");
+      if (!existsSync18(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -13633,7 +13694,7 @@ async function executeRenderPipeline(input) {
           canvas: { width, height },
           page: probeSession.page,
           projectDir,
-          compiledDir: join27(workDir, "compiled")
+          compiledDir: join28(workDir, "compiled")
         });
         if (videoLayerPlan.videoId === void 0) {
           log.info(`[Render] Video layer passthrough off: ${videoLayerPlan.reason}`);
@@ -13651,7 +13712,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join27(workDir, "compiled");
+    const compiledDir = join28(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -13763,7 +13824,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join27(workDir, "compiled"),
+          compiledDir: join28(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -13781,8 +13842,8 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join27(workDir, "captured-frames");
-    if (!existsSync17(framesDir)) mkdirSync10(framesDir, { recursive: true });
+    const framesDir = join28(workDir, "captured-frames");
+    if (!existsSync18(framesDir)) mkdirSync10(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -14279,7 +14340,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join27(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join28(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -14567,7 +14628,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join27(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join28(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -15104,7 +15165,7 @@ async function executeRenderPipeline(input) {
       })
     );
     const totalElapsed = Date.now() - pipelineStart;
-    const tmpPeakBytes = existsSync17(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync18(workDir) ? sampleDirectoryBytes(workDir) : 0;
     recordTransientRetryObservability();
     observability.checkpoint("pipeline", "artifact validated", { totalElapsedMs: totalElapsed });
     const observabilitySummary = observability.summary({
@@ -15185,8 +15246,8 @@ async function executeRenderPipeline(input) {
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && !isHls && existsSync17(stagedOutputPath)) {
-        const debugOutput = join27(workDir, `output${videoExt}`);
+      if (!isPngSequence && !isHls && existsSync18(stagedOutputPath)) {
+        const debugOutput = join28(workDir, `output${videoExt}`);
         copyFileSync5(stagedOutputPath, debugOutput);
       }
     }
@@ -15292,14 +15353,14 @@ async function executeRenderPipeline(input) {
 
 // src/services/distributed/renderSpan.ts
 import { mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync7, readFileSync as readFileSync13, rmSync as rmSync16 } from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 
 // src/services/distributed/mp4Stitch.ts
 import { createReadStream as createReadStream3, createWriteStream, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, rmSync as rmSync11 } from "node:fs";
 import { open } from "node:fs/promises";
-import { renameWithRetry as renameWithRetry6 } from "@hyperframes/engine";
-import { dirname as dirname12, join as join28 } from "node:path";
+import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
+import { dirname as dirname13, join as join29 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -15663,15 +15724,15 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
   const sourcePaths = audioPath ? [audioPath, ...chunkPaths] : chunkPaths;
   const layouts = await Promise.all(sourcePaths.map((path) => readMp4Layout(fileRange(path))));
   const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
-  mkdirSync11(dirname12(outputPath), { recursive: true });
+  mkdirSync11(dirname13(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join28(workDir, "out.mp4"));
+  const out = createWriteStream(join29(workDir, "out.mp4"));
   try {
     out.write(header);
     for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameWithRetry6(join28(workDir, "out.mp4"), outputPath);
+    renameWithRetry7(join29(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync11(workDir, { recursive: true, force: true });
@@ -15683,13 +15744,13 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync6,
   cpSync as cpSync2,
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   linkSync,
   mkdirSync as mkdirSync14,
   rmSync as rmSync12,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { extname as extname6, isAbsolute as isAbsolute3, join as join35, relative as relative5, sep as sep2 } from "node:path";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join36, relative as relative5, sep as sep2 } from "node:path";
 import {
   fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -15700,12 +15761,12 @@ import {
   normalizeVp9CpuUsed,
   resolveConfig as resolveConfig3,
   declareContentAddressedUrl,
-  renameWithRetry as renameWithRetry7,
+  renameWithRetry as renameWithRetry8,
   declareProbeFactsUrl
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
@@ -15714,8 +15775,8 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/chunkFrames.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6 } from "node:fs";
-import { extname as extname4, join as join30 } from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync6 } from "node:fs";
+import { extname as extname4, join as join31 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
   createFrameLookupTable as createFrameLookupTable2,
@@ -15725,8 +15786,8 @@ import {
 
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname13, join as join29 } from "node:path";
-import { existsSync as existsSync18, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname14, join as join30 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync8 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -15741,8 +15802,8 @@ function isPlanAudioArtifactPath(path) {
 }
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join29(planDir, name);
-    if (existsSync18(candidate)) return candidate;
+    const candidate = join30(planDir, name);
+    if (existsSync19(candidate)) return candidate;
   }
   return null;
 }
@@ -15999,11 +16060,11 @@ function buildSyntheticRenderJob(input) {
 var cachedProducerVersion = null;
 function readProducerVersion() {
   if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname13(fileURLToPath5(import.meta.url));
+  const startDir = dirname14(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join29(current, "package.json");
-    if (existsSync18(candidate)) {
+    const candidate = join30(current, "package.json");
+    if (existsSync19(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
@@ -16013,7 +16074,7 @@ function readProducerVersion() {
       } catch {
       }
     }
-    const parent = dirname13(current);
+    const parent = dirname14(current);
     if (parent === current) break;
     current = parent;
   }
@@ -16056,8 +16117,8 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join30(planDir, "video-frames", v.videoId);
-    if (!existsSync19(outputDir)) {
+    const outputDir = join31(planDir, "video-frames", v.videoId);
+    if (!existsSync20(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.`
       );
@@ -16075,7 +16136,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
       if (!frameName) continue;
       const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
       const frameIndex = frameNumber === null ? i : frameNumber - 1;
-      framePaths.set(frameIndex, join30(outputDir, frameName));
+      framePaths.set(frameIndex, join31(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -16165,15 +16226,15 @@ async function extractDeferredVideoFramesForChunk(input) {
   const shown = shownDeferredFrameIndexes(input.planVideos, input.frames, input.fps);
   return Promise.all(
     deferred.map(async (video) => {
-      const outputDir = join30(input.outputRoot, video.videoId);
+      const outputDir = join31(input.outputRoot, video.videoId);
       const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
       if (indexes.length === 0) {
         return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
       }
       const range = video.deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
-      const sourcePath = remoteUrl ?? join30(input.planDir, ...range.sourcePath.split("/"));
-      if (remoteUrl === void 0 && !existsSync19(sourcePath)) {
+      const sourcePath = remoteUrl ?? join31(input.planDir, ...range.sourcePath.split("/"));
+      if (remoteUrl === void 0 && !existsSync20(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
           `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
@@ -16221,12 +16282,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join31(workDir, "frame-cost-video-frames"),
+      outputRoot: join32(workDir, "frame-cost-video-frames"),
       cfg: input.cfg
     })
   ];
   const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
-  const compiledDir = join31(planDir, "compiled");
+  const compiledDir = join32(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -16238,7 +16299,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join31(workDir, "frame-cost"),
+      join32(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -16335,8 +16396,8 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync9, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join32, relative as relative3, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync9, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join33, relative as relative3, resolve as resolve9 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -16529,7 +16590,7 @@ function planFileSha256(absolutePath, digests) {
   return sha256;
 }
 async function prehashPlanFiles(dir, digests) {
-  if (!existsSync20(dir)) return;
+  if (!existsSync21(dir)) return;
   for (const { absolutePath } of listPlanFiles(dir)) {
     if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
   }
@@ -16554,7 +16615,7 @@ function listPlanFiles(planDir) {
   function walk(dir) {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join32(dir, entry.name);
+      const full = join33(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -16595,19 +16656,19 @@ var PLAN_REMOTE_FILES_RELATIVE_PATH = "meta/remote-files.json";
 function writePlanRemoteFiles(planDir, files) {
   if (files.length === 0) return;
   const sorted = [...files].sort((a, b) => a.path < b.path ? -1 : 1);
-  writeFileSync7(join32(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync7(join33(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join32(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync20(path) ? JSON.parse(readFileSync9(path, "utf-8")) : [];
+  const path = join33(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  return existsSync21(path) ? JSON.parse(readFileSync9(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join32(planDir, "plan.json");
-  const encoderJsonPath = join32(planDir, "meta", "encoder.json");
-  if (!existsSync20(planJsonPath)) {
+  const planJsonPath = join33(planDir, "plan.json");
+  const encoderJsonPath = join33(planDir, "meta", "encoder.json");
+  if (!existsSync21(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  if (!existsSync20(encoderJsonPath)) {
+  if (!existsSync21(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
   const planJson = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
@@ -16637,21 +16698,21 @@ async function freezePlan(input) {
     hasAudio,
     digests
   } = input;
-  if (!existsSync20(planDir)) {
+  if (!existsSync21(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join32(planDir, "meta");
-  if (!existsSync20(metaDir)) mkdirSync12(metaDir, { recursive: true });
+  const metaDir = join33(planDir, "meta");
+  if (!existsSync21(metaDir)) mkdirSync12(metaDir, { recursive: true });
   writeFileSync7(
-    join32(metaDir, "composition.json"),
+    join33(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
     "utf-8"
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync7(join32(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync7(join32(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync7(join33(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync7(join33(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -16675,7 +16736,7 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join32(planDir, "plan.json");
+  const planJsonPath = join33(planDir, "plan.json");
   writeFileSync7(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
@@ -16717,10 +16778,10 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync6, existsSync as existsSync21, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync10 } from "node:fs";
+import { closeSync as closeSync6, existsSync as existsSync22, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync10 } from "node:fs";
 import { writeFileSync as writeFileSync8, writeSync } from "node:fs";
-import { join as join33 } from "node:path";
-import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
+import { join as join34 } from "node:path";
+import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 function audioCutForChunk(grid, chunks, index, fps) {
   const firstPacketAt = (frame) => Math.min(
     grid.packetCount,
@@ -16807,7 +16868,7 @@ async function writeChunkAudioSlices(input) {
   });
   const bytes = readFileSync10(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync13(join33(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync13(join34(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -16815,17 +16876,17 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync8(join33(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync8(join34(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync8(join33(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync8(join33(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  writeFileSync8(join34(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync8(join34(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
-  const layoutPath = join33(planDir, SLICE_LAYOUT);
-  if (!existsSync21(layoutPath)) return resolvePlanAudioPath(planDir);
+  const layoutPath = join34(planDir, SLICE_LAYOUT);
+  if (!existsSync22(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync10(layoutPath, "utf-8"));
-  const frame = readFileSync10(join33(planDir, SLICE_FRAME));
+  const frame = readFileSync10(join34(planDir, SLICE_FRAME));
   const fd = openSync6(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -16838,7 +16899,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync10(join33(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync10(join34(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -16866,7 +16927,7 @@ async function muxChunkWithAudio(input) {
   const result = await runFfmpeg7(args, { signal: input.signal, timeout: input.timeoutMs });
   if (!result.success) {
     throw new Error(
-      `[chunkAudio] chunk mux failed: ${describeFfmpegFailure3(result, input.timeoutMs)}`
+      `[chunkAudio] chunk mux failed: ${describeFfmpegFailure4(result, input.timeoutMs)}`
     );
   }
   const slice = input.chunks[input.chunkIndex];
@@ -16894,7 +16955,7 @@ async function muxChunkWithAudio(input) {
 // src/services/distributed/planSize.ts
 import { createHash as createHash9 } from "node:crypto";
 import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "node:fs";
-import { extname as extname5, join as join34, relative as relative4 } from "node:path";
+import { extname as extname5, join as join35, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -17006,7 +17067,7 @@ function walkRegularFiles(dir, visit) {
     return;
   }
   for (const entry of entries) {
-    const full = join34(dir, entry.name);
+    const full = join35(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -17218,13 +17279,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join35("meta", "composition.json"),
-  join35("meta", "encoder.json"),
-  join35("meta", "chunks.json")
+  join36("meta", "composition.json"),
+  join36("meta", "encoder.json"),
+  join36("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync12(join35(planDir, relativePath), { force: true });
+    rmSync12(join36(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -17379,19 +17440,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join35(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join36(input.planDir, "video-frames", stagedRel);
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync22(join35(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync23(join36(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
       result = `video-sources/${shipped.size}${extname6(current)}`;
-      const destination = join35(input.planDir, ...result.split("/"));
-      mkdirSync14(join35(input.planDir, "video-sources"), { recursive: true });
+      const destination = join36(input.planDir, ...result.split("/"));
+      mkdirSync14(join36(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -17411,7 +17472,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync22(planDir)) mkdirSync14(planDir, { recursive: true });
+  if (!existsSync23(planDir)) mkdirSync14(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -17440,14 +17501,14 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join35(projectDir, entryFile);
-  if (!existsSync22(htmlPath)) {
+  const htmlPath = join36(projectDir, entryFile);
+  if (!existsSync23(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join35(planDir, ".plan-work");
+  const workDir = join36(planDir, ".plan-work");
   rmSync12(workDir, { recursive: true, force: true });
   mkdirSync14(workDir, { recursive: true });
-  const compiledDir = join35(workDir, "compiled");
+  const compiledDir = join36(workDir, "compiled");
   mkdirSync14(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -17461,10 +17522,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join35(planDir, "compiled");
+  const finalCompiledDir = join36(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join35(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join36(projectDir, ...rel.split("/"));
   for (const [, file] of remoteFiles) {
     declareContentAddressedUrl(file.url, file.sha256);
     if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
@@ -17650,18 +17711,18 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   let stageStarted = Date.now();
   const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  const stagedVideoFrames = join35(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join35(planDir, "video-frames");
-  if (existsSync22(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join35(planDir, "video-sources");
+  const stagedVideoFrames = join36(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join36(planDir, "video-frames");
+  if (existsSync23(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join36(planDir, "video-sources");
   rmSync12(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync22(stagedVideoFrames)) {
-    renameWithRetry7(stagedVideoFrames, videoFramesDst);
+  if (existsSync23(stagedVideoFrames)) {
+    renameWithRetry8(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync14(videoFramesDst, { recursive: true });
   }
-  if (existsSync22(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
-  renameWithRetry7(compiledDir, finalCompiledDir);
+  if (existsSync23(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
+  renameWithRetry8(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
     projectDir,
@@ -17690,7 +17751,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync14(join35(planDir, "meta"), { recursive: true });
+  mkdirSync14(join36(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -17700,7 +17761,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }))
   );
   writeFileSync9(
-    join35(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join36(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -17779,11 +17840,11 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join35(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult?.hasAudio && existsSync22(audioResult.audioOutputPath)) {
-    renameWithRetry7(audioResult.audioOutputPath, planAudioPath);
+  const planAudioPath = join36(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult?.hasAudio && existsSync23(audioResult.audioOutputPath)) {
+    renameWithRetry8(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio && existsSync22(planAudioPath)) {
+  if (chunksCarryAudio && existsSync23(planAudioPath)) {
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
       await writeChunkAudioSlices({
@@ -17898,9 +17959,9 @@ async function plan(projectDir, config, planDir, options = {}) {
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync25, mkdirSync as mkdirSync17, readFileSync as readFileSync12, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync12, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -17921,7 +17982,7 @@ import {
 // src/services/distributed/planV2.ts
 import {
   copyFileSync as copyFileSync8,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync16,
   mkdtempSync as mkdtempSync6,
@@ -17932,14 +17993,14 @@ import {
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname15, isAbsolute as isAbsolute4, join as join38, relative as relative6, resolve as resolve10, sep as sep3 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute4, join as join39, relative as relative6, resolve as resolve10, sep as sep3 } from "node:path";
 import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
-import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
+import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry10 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   linkSync as linkSync2,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync5,
@@ -17947,8 +18008,8 @@ import {
   statSync as statSync9,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { renameWithRetry as renameWithRetry8 } from "@hyperframes/engine";
-import { dirname as dirname14, join as join37 } from "node:path";
+import { renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
+import { dirname as dirname15, join as join38 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -17963,7 +18024,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -17973,7 +18034,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join36(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join37(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -18008,13 +18069,13 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync23(destinationDir)) {
+    if (existsSync24(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
-    mkdirSync15(dirname14(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join37(dirname14(destinationDir), ".plan-v2-publish-"));
+    mkdirSync15(dirname15(destinationDir), { recursive: true });
+    this.temporaryDir = mkdtempSync5(join38(dirname15(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -18025,10 +18086,10 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync23(destinationPath)) return;
-    mkdirSync15(dirname14(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join37(dirname14(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join37(stagingDir, "blob");
+    if (existsSync24(destinationPath)) return;
+    mkdirSync15(dirname15(destinationPath), { recursive: true });
+    const stagingDir = mkdtempSync5(join38(dirname15(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join38(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -18036,21 +18097,21 @@ var LocalPlanV2ArtifactPublisher = class {
         if (!canFallbackToCopy(error)) throw error;
         copyFileSync7(blob.sourcePath, temporaryPath);
       }
-      renameWithRetry8(temporaryPath, destinationPath);
+      renameWithRetry9(temporaryPath, destinationPath);
     } finally {
       rmSync13(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync23(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync24(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync10(join37(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-    renameWithRetry8(this.temporaryDir, this.destinationDir);
+    writeFileSync10(join38(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    renameWithRetry9(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
@@ -18094,7 +18155,7 @@ function listFiles(root) {
   const rootResolved = resolve10(root);
   function walk(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join38(dir, entry.name);
+      const absolutePath = join39(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -18121,13 +18182,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join38(executionPlanDir, "video-frames");
-  if (!existsSync24(videoRoot)) return;
+  const videoRoot = join39(executionPlanDir, "video-frames");
+  if (!existsSync25(videoRoot)) return;
   for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join38(videoRoot, videoEntry.name);
+    const videoDir = join39(videoRoot, videoEntry.name);
     if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join38(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join39(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -18174,7 +18235,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join38(outputDir, String(index)));
+        framePaths2.set(index, join39(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -18182,7 +18243,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join38(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join39(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -18201,7 +18262,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join38(outputDir, frameName));
+      framePaths.set(frameIndex, join39(outputDir, frameName));
     }
     return {
       ...video,
@@ -18222,8 +18283,8 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join38(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync24(videosPath)) return;
+  const videosPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync16(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
@@ -18256,13 +18317,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join38(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync24(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join38(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync24(videosPath)) {
+  const videoRoot = join39(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync25(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join39(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join38(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join39(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -18316,13 +18377,13 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync24(destinationPath)) return;
-  mkdirSync16(dirname15(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join38(dirname15(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join38(temporaryDir, "blob");
+  if (existsSync25(destinationPath)) return;
+  mkdirSync16(dirname16(destinationPath), { recursive: true });
+  const temporaryDir = mkdtempSync6(join39(dirname16(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join39(temporaryDir, "blob");
   try {
     copyFileSync8(sourcePath, temporaryPath);
-    renameWithRetry9(temporaryPath, destinationPath);
+    renameWithRetry10(temporaryPath, destinationPath);
   } finally {
     rmSync14(temporaryDir, { recursive: true, force: true });
   }
@@ -18355,8 +18416,8 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join38(executionPlanDir, "plan.json");
-  if (!existsSync24(executionPlanPath)) {
+  const executionPlanPath = join39(executionPlanDir, "plan.json");
+  if (!existsSync25(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -18383,7 +18444,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join38(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join39(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
   const files = listFiles(executionPlanDir);
   const chunkAudio = !isRecord3(encoder) || encoder.chunksCarryAudio !== true ? "none" : files.some((file) => chunkAudioSliceTarget(file.path) !== null) ? "sliced" : "whole";
   for (const file of files) {
@@ -18436,25 +18497,25 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
+  if (existsSync25(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
   if (publication.storedBlobs.length > 0) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
-  mkdirSync16(dirname15(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join38(dirname15(planV2Dir), ".plan-v2-build-"));
+  mkdirSync16(dirname16(planV2Dir), { recursive: true });
+  const tempDir = mkdtempSync6(join39(dirname16(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync11(
-      join38(tempDir, "plan.json"),
+      join39(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
-    renameWithRetry9(tempDir, planV2Dir);
+    renameWithRetry10(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
     rmSync14(tempDir, { recursive: true, force: true });
@@ -18497,7 +18558,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join38(options.stagingParentDir ?? tmpdir3(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync6(join39(options.stagingParentDir ?? tmpdir3(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -18508,7 +18569,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
       // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
       whileAudioMixes: () => putBlobs(
         publisher,
-        listFiles(join38(stagingRoot, "compiled")).map(
+        listFiles(join39(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -18528,19 +18589,19 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
+  if (existsSync25(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
   const manifest = await planV2WithPublisher(projectDir, config, publisher, {
-    stagingParentDir: dirname15(planV2Dir)
+    stagingParentDir: dirname16(planV2Dir)
   });
   return resultFromManifest(planV2Dir, manifest);
 }
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join38(planV2Dir, "plan.json"),
+    manifestPath: join39(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -18676,8 +18737,8 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join38(planV2Dir, "plan.json");
-  if (!existsSync24(manifestPath)) {
+  const manifestPath = join39(planV2Dir, "plan.json");
+  if (!existsSync25(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -18696,7 +18757,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync24(sourcePath)) {
+  if (!existsSync25(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync10(sourcePath);
@@ -18709,7 +18770,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
-  if (existsSync24(destinationDir)) {
+  if (existsSync25(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -18721,17 +18782,17 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     artifact,
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
-  mkdirSync16(dirname15(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join38(dirname15(destinationDir), ".plan-v2-materialize-"));
+  mkdirSync16(dirname16(destinationDir), { recursive: true });
+  const tempDir = mkdtempSync6(join39(dirname16(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join38(tempDir, ...artifact.path.split("/"));
-      mkdirSync16(dirname15(destinationPath), { recursive: true });
+      const destinationPath = join39(tempDir, ...artifact.path.split("/"));
+      mkdirSync16(dirname16(destinationPath), { recursive: true });
       copyFileSync8(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync11(
-      join38(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join39(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -18739,7 +18800,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
       }),
       "utf-8"
     );
-    renameWithRetry9(tempDir, destinationDir);
+    renameWithRetry10(tempDir, destinationDir);
   } catch (error) {
     rmSync14(tempDir, { recursive: true, force: true });
     throw error;
@@ -18754,7 +18815,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     // Join the artifact's OWN name, not the current constant: a plan written
     // before the container change carries the legacy name, and materializing it
     // under the new one would point at a file that was never written.
-    audioPath: target.role === "assembler" ? audioArtifact ? join38(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join39(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -18773,8 +18834,8 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  const markerPath = join38(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync24(markerPath)) return null;
+  const markerPath = join39(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync25(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -18791,8 +18852,8 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   assertRemoteSources(remoteSources, required);
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
-    const path = join38(planDir, ...artifact.path.split("/"));
-    if (!existsSync24(path) || statSync10(path).size !== artifact.sizeBytes) {
+    const path = join39(planDir, ...artifact.path.split("/"));
+    if (!existsSync25(path) || statSync10(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -18912,7 +18973,7 @@ function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync12(outputPath));
   const entries = readdirSync10(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync12(join39(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync12(join40(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -18929,10 +18990,10 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join39(planDir, "plan.json");
-  const encoderJsonPath = join39(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join39(planDir, "meta", "chunks.json");
-  if (!existsSync25(planJsonPath)) {
+  const planJsonPath = join40(planDir, "plan.json");
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
+  if (!existsSync26(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -18948,7 +19009,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const v2Manifest = v2Materialization?.manifest ?? null;
   const remoteSources = v2Materialization?.remoteSources ?? {};
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync25(required)) {
+    if (!existsSync26(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -18957,9 +19018,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const encoder = JSON.parse(readFileSync12(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync12(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync25(videosJsonPath)) {
+  if (existsSync26(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync12(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -18989,8 +19050,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
-  const compiledDir = join39(planDir, "compiled");
-  if (!existsSync25(compiledDir)) {
+  const compiledDir = join40(planDir, "compiled");
+  if (!existsSync26(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -19047,7 +19108,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync17(workDir, { recursive: true });
-    const framesDir = join39(workDir, "captured-frames");
+    const framesDir = join40(workDir, "captured-frames");
     mkdirSync17(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
@@ -19072,7 +19133,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync12(join39(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync12(join40(compiledDir, "index.html"), "utf-8"),
       // The plan ships a deferred source only to chunks that show it; don't wait on the rest.
       skipReadinessVideoIds: deferredVideos.filter(
         (video) => !shownFrames.get(video.videoId)?.size || remoteVideoIds.has(video.videoId)
@@ -19240,10 +19301,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 (!existsSync25(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
+        if (!existsSync26(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join39(outputChunkPath, "..");
-        if (!existsSync25(outDir)) mkdirSync17(outDir, { recursive: true });
+        const outDir = join40(outputChunkPath, "..");
+        if (!existsSync26(outDir)) mkdirSync17(outDir, { recursive: true });
       }
       const encodeInput = {
         job,
@@ -19516,10 +19577,10 @@ async function renderSpan(projectDir, config, span, outputPath) {
   if (config.cfr === true) {
     throw new RenderSpanUnsupportedError("--start/--end cannot be combined with a cfr re-encode.");
   }
-  const workDir = mkdtempSync7(join40(tmpdir4(), "hf-render-span-"));
+  const workDir = mkdtempSync7(join41(tmpdir4(), "hf-render-span-"));
   try {
-    const planDir = join40(workDir, "plan");
-    const partsDir = join40(workDir, "parts");
+    const planDir = join41(workDir, "plan");
+    const partsDir = join41(workDir, "parts");
     mkdirSync18(partsDir, { recursive: true });
     const planned = await plan(
       projectDir,
@@ -19534,7 +19595,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       planned.totalFrames
     );
     const slices = JSON.parse(
-      readFileSync13(join40(planDir, "meta", "chunks.json"), "utf-8")
+      readFileSync13(join41(planDir, "meta", "chunks.json"), "utf-8")
     );
     const parts = [];
     for (const slice of slices) {
@@ -19544,7 +19605,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       };
       if (range.endFrame <= range.startFrame) continue;
       throwIfAborted(config.abortSignal);
-      const part = join40(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
+      const part = join41(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
       await renderChunk(planDir, slice.index, part, { frameRange: range });
       parts.push(part);
     }
@@ -20137,7 +20198,7 @@ import {
 
 // src/server.ts
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync19,
   statSync as statSync12,
   mkdtempSync as mkdtempSync8,
@@ -20145,7 +20206,7 @@ import {
   rmSync as rmSync17,
   createReadStream as createReadStream5
 } from "node:fs";
-import { resolve as resolve12, dirname as dirname17, join as join43 } from "node:path";
+import { resolve as resolve12, dirname as dirname18, join as join44 } from "node:path";
 import { tmpdir as tmpdir5 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -20156,7 +20217,7 @@ import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engi
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   readFileSync as readFileSync14,
   statSync as statSync11,
   openSync as openSync7,
@@ -20164,7 +20225,7 @@ import {
   closeSync as closeSync7,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve11, join as join41, relative as relative7, isAbsolute as isAbsolute5, sep as sep4 } from "node:path";
+import { resolve as resolve11, join as join42, relative as relative7, isAbsolute as isAbsolute5, sep as sep4 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -20210,7 +20271,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve11(projectDir);
-  if (!existsSync26(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+  if (!existsSync27(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -20232,7 +20293,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join41(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join42(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -20278,8 +20339,8 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname16, join as join42 } from "node:path";
-import { existsSync as existsSync27 } from "node:fs";
+import { dirname as dirname17, join as join43 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -20353,10 +20414,10 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname16(fileURLToPath6(import.meta.url));
-  const candidates = [join42(here, "healthWorkerThread.js"), join42(here, "healthWorkerThread.ts")];
+  const here = dirname17(fileURLToPath6(import.meta.url));
+  const candidates = [join43(here, "healthWorkerThread.js"), join43(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync27(candidate)) return candidate;
+    if (existsSync28(candidate)) return candidate;
   }
   return void 0;
 }
@@ -20498,8 +20559,8 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname17(absoluteOutputPath);
-  if (!existsSync28(outputDir)) mkdirSync19(outputDir, { recursive: true });
+  const outputDir = dirname18(absoluteOutputPath);
+  if (!existsSync29(outputDir)) mkdirSync19(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -20540,11 +20601,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve12(candidate);
-  if (!existsSync28(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
+  if (!existsSync29(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync28(resolve12(absProjectDir, entry))) {
+  if (!existsSync29(resolve12(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -20565,8 +20626,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir5();
-  const tempProjectDir = mkdtempSync8(join43(tempRoot, "producer-project-"));
-  writeFileSync13(join43(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync8(join44(tempRoot, "producer-project-"));
+  writeFileSync13(join44(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -20636,7 +20697,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync28(path) ? statSync12(path).size : 0;
+  return existsSync29(path) ? statSync12(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -20938,7 +20999,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync28(artifact.path)) {
+    if (!existsSync29(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -21035,12 +21096,12 @@ import { quantizeTimeToFrame, MEDIA_VISUAL_STYLE_PROPERTIES } from "@hyperframes
 // src/services/distributed/planV2Execution.ts
 import { mkdtempSync as mkdtempSync10, rmSync as rmSync19 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   mkdirSync as mkdirSync20,
   mkdtempSync as mkdtempSync9,
   readFileSync as readFileSync15,
@@ -21049,18 +21110,18 @@ import {
   statSync as statSync13,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname18, join as join44 } from "node:path";
+import { dirname as dirname19, join as join45 } from "node:path";
 import {
   appendRateCapArgs as appendRateCapArgs2,
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
-  describeFfmpegFailure as describeFfmpegFailure4,
+  describeFfmpegFailure as describeFfmpegFailure5,
   getEncoderPreset as getEncoderPreset6,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig7,
   runFfmpeg as runFfmpeg8,
   appendSoftwareEncoderThreadsArg,
-  renameWithRetry as renameWithRetry10
+  renameWithRetry as renameWithRetry11
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -21091,8 +21152,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync29(dirname18(outputPath))) {
-    mkdirSync20(dirname18(outputPath), { recursive: true });
+  if (!existsSync30(dirname19(outputPath))) {
+    mkdirSync20(dirname19(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync9(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -21114,10 +21175,10 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join44(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync29(audioPath) ? audioPath : null;
+    const finalPath = join45(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync30(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
-    renameWithRetry10(finalPath, outputPath);
+    renameWithRetry11(finalPath, outputPath);
     log.info("[assemble] stage timings", {
       ...stageMs,
       chunks: chunkPaths.length,
@@ -21133,7 +21194,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync29(outputPath) ? statSync13(outputPath).size : 0;
+  const fileSize = existsSync30(outputPath) ? statSync13(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -21142,15 +21203,15 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join44(planDir, "plan.json");
-  const chunksJsonPath = join44(planDir, "meta", "chunks.json");
-  if (!existsSync29(planJsonPath)) {
+  const planJsonPath = join45(planDir, "plan.json");
+  const chunksJsonPath = join45(planDir, "meta", "chunks.json");
+  if (!existsSync30(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync15(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync29(chunksJsonPath)) {
+  if (!existsSync30(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync15(chunksJsonPath, "utf-8"));
@@ -21165,7 +21226,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     }
   }
   for (const path of chunkPaths.flat()) {
-    if (!existsSync29(path)) {
+    if (!existsSync30(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -21194,7 +21255,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join44(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join45(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
@@ -21221,7 +21282,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join44(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join45(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -21261,7 +21322,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join44(workDir, "concat-list.txt");
+  const listPath = join45(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync14(listPath, `${body}
 `, "utf-8");
@@ -21281,7 +21342,7 @@ async function runAssembleFfmpeg(args, step, signal, timeout) {
   const result = await runFfmpeg8(args, { signal, timeout });
   if (!result.success) {
     throw encoderFailureError(`[assemble] ffmpeg ${step} failed`, {
-      error: describeFfmpegFailure4(result, timeout),
+      error: describeFfmpegFailure5(result, timeout),
       failureReason: result.failureReason
     });
   }
@@ -21299,12 +21360,12 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync15(join44(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync15(join45(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
-  const encoderJsonPath = join44(planDir, "meta", "encoder.json");
-  if (!existsSync29(encoderJsonPath)) return {};
+  const encoderJsonPath = join45(planDir, "meta", "encoder.json");
+  if (!existsSync30(encoderJsonPath)) return {};
   return JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
@@ -21313,8 +21374,8 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join44(planDir, "meta", "encoder.json");
-  if (!existsSync29(encoderJsonPath)) {
+  const encoderJsonPath = join45(planDir, "meta", "encoder.json");
+  if (!existsSync30(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
@@ -21326,7 +21387,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync29(outputPath)) rmSync18(outputPath, { recursive: true, force: true });
+  if (existsSync30(outputPath)) rmSync18(outputPath, { recursive: true, force: true });
   mkdirSync20(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -21340,8 +21401,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join44(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join44(chunkDir, frame), dst);
+      const dst = join45(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join45(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -21350,14 +21411,14 @@ 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 && existsSync29(audioPath)) {
-    const sidecar = join44(outputPath, MIXED_AUDIO_FILENAME4);
+  if (audioPath !== null && existsSync30(audioPath)) {
+    const sidecar = join45(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync11(outputPath)) {
     try {
-      fileSize += statSync13(join44(outputPath, name)).size;
+      fileSize += statSync13(join45(outputPath, name)).size;
     } catch {
     }
   }
@@ -21371,8 +21432,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync10(join45(tmpdir6(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join45(workRoot, "plan");
+  const workRoot = mkdtempSync10(join46(tmpdir6(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join46(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
@@ -21381,8 +21442,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync10(join45(tmpdir6(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join45(workRoot, "plan");
+  const workRoot = mkdtempSync10(join46(tmpdir6(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join46(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,