@hyperframes/producer 0.9.15 → 0.9.16

package/dist/index.js

@@ -9,12 +9,12 @@ import {
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync5,
   rmSync as rmSync10,
   statSync as statSync8,
-  writeFileSync as writeFileSync6,
+  writeFileSync as writeFileSync7,
   copyFileSync as copyFileSync5,
   appendFileSync
 } from "fs";
@@ -29,9 +29,7 @@ import {
   toFps as toFps2
 } from "@hyperframes/core";
 import { HF_AUDIO_GROUP_TAG } from "@hyperframes/core/audio-groups";
-import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
 import { HTML_BODY_CSS_HEIGHT_FIRST_RE, HTML_BODY_CSS_WIDTH_FIRST_RE } from "@hyperframes/parsers";
-import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
 import {
   extractMediaMetadata as extractMediaMetadata4,
   resolveConfig as resolveConfig2,
@@ -62,7 +60,8 @@ import {
   isDrawElementCaptureError,
   getDrawElementVerificationDetails,
   augmentProtocolTimeoutError,
-  augmentPageNavigationTimeoutError
+  augmentPageNavigationTimeoutError,
+  displaySize
 } from "@hyperframes/engine";
 import {
   referenceBackgroundResult,
@@ -5895,8 +5894,11 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
+import { existsSync as existsSync11, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join16 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
+import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
+import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
 
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
@@ -8604,11 +8606,36 @@ function adaptAspectAgnosticResolution(requested, aspectAgnostic, width, height,
   });
   return flipped;
 }
+function resolveEntryHtmlPath(input) {
+  const { projectDir, workDir, entryFile, log } = input;
+  const htmlPath = join16(projectDir, entryFile);
+  const rawEntry = readTextFile2(htmlPath);
+  if (entryFile === "index.html" || !isTemplateEntry(rawEntry)) return htmlPath;
+  const projectIndexPath = join16(projectDir, "index.html");
+  if (!existsSync11(projectIndexPath)) {
+    throw new Error(
+      `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
+    );
+  }
+  const standaloneHtml = extractStandaloneEntryFromIndex(
+    readTextFile2(projectIndexPath),
+    entryFile,
+    rawEntry
+  );
+  if (!standaloneHtml) {
+    throw new Error(
+      `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
+    );
+  }
+  const wrapperPath = join16(workDir, "standalone-entry.html");
+  writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
+  log.info("Extracted standalone entry from index.html host context", { entryFile });
+  return wrapperPath;
+}
 async function runCompileStage(input) {
   const {
     projectDir,
     workDir,
-    htmlPath,
     entryFile,
     job,
     cfg,
@@ -8619,6 +8646,7 @@ async function runCompileStage(input) {
     allowSystemFontCapture,
     abortSignal
   } = input;
+  const htmlPath = resolveEntryHtmlPath({ projectDir, workDir, entryFile, log });
   const compileStart = Date.now();
   const compiled = await compileForRender(projectDir, htmlPath, join16(workDir, "downloads"), {
     log,
@@ -9450,7 +9478,7 @@ function validateDistributedDuration(input) {
 }
 
 // src/services/render/stages/extractVideosStage.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { join as join18 } from "node:path";
 import {
   classifyVideoExtractionError,
@@ -9725,7 +9753,7 @@ async function runExtractVideosStage(input) {
     const probeFailures = await Promise.all(
       composition.videos.map(async (v) => {
         const videoPath = resolveProjectRelativeSrc3(v.src, projectDir, compiledDir);
-        if (!existsSync11(videoPath)) return null;
+        if (!existsSync12(videoPath)) return null;
         try {
           const attempted = extractionPolicy.maxTransientRetries === 0 ? { result: await extractMediaMetadata3(videoPath), retries: 0 } : await runVideoExtractionWithRetry(() => extractMediaMetadata3(videoPath), {
             signal: abortSignal,
@@ -9763,7 +9791,7 @@ async function runExtractVideosStage(input) {
     const probed = await Promise.all(
       composition.images.map(async (img) => {
         const imgPath = resolveProjectRelativeSrc3(img.src, projectDir, compiledDir);
-        if (!existsSync11(imgPath)) return null;
+        if (!existsSync12(imgPath)) return null;
         const colorSpace = await probeColorSpaceSafely(imgPath, log);
         if (isHdrColorSpace2(colorSpace)) {
           nativeHdrImageIds.add(img.id);
@@ -9883,7 +9911,7 @@ async function appendVideoAudioFromProbe(input) {
     videos.map(async (video) => {
       const path = isHttpUrl2(video.src) ? video.src : resolveProjectRelativeSrc3(video.src, projectDir, compiledDir);
       const readFrom = urlByAbsentLocalPath?.get(path) ?? path;
-      if (!isHttpUrl2(readFrom) && !existsSync11(readFrom)) return null;
+      if (!isHttpUrl2(readFrom) && !existsSync12(readFrom)) return null;
       const metadata = await extractMediaMetadata3(readFrom);
       const window2 = await resolveFinalFrameExtractionWindow2(
         readFrom,
@@ -9903,7 +9931,7 @@ async function appendVideoAudioFromProbe(input) {
 }
 
 // src/services/render/videoLayerPassthroughPlan.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import {
   buildVideoLayerInput,
   isHttpUrl as isHttpUrl3,
@@ -9971,7 +9999,7 @@ async function planVideoLayerPassthrough(input) {
   const { video } = q;
   if (isHttpUrl3(video.src)) return { reason: "remote_source" };
   const path = resolveProjectRelativeSrc4(video.src, input.projectDir, input.compiledDir);
-  if (!existsSync12(path)) return { reason: "source_missing" };
+  if (!existsSync13(path)) return { reason: "source_missing" };
   const layout = await probeVideoLayout(input.page, video.id, input.canvas, input.duration);
   if ("reason" in layout) return layout;
   const layer = await buildVideoLayerInput(
@@ -9986,7 +10014,7 @@ async function planVideoLayerPassthrough(input) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { join as join21 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
@@ -9997,7 +10025,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/render/audioDeliveryLimit.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { dirname as dirname9, join as join20 } from "node:path";
 import {
   applyAudioFxChain,
@@ -10504,7 +10532,7 @@ async function limitDeliveryPeaks(input, deps = {
   applyChain: applyAudioFxChain,
   encode: encodeAac2,
   rename: renameWithRetry6,
-  sourceExists: existsSync13
+  sourceExists: existsSync14
 }) {
   const { audioPath, sourcePath, signal, timeoutMs } = input;
   if (!deps.sourceExists(sourcePath)) return { success: true };
@@ -10574,7 +10602,7 @@ async function runAudioStageScoped(input) {
       );
       audioLoweredDb = guard.loweredDb;
       input.log?.info("[audio] phases", { ...result.audioPhaseMs, guard: Date.now() - guardStart });
-      if (input.keepDeliverySource && !guard.sourceStale && existsSync14(pcmSourcePath)) {
+      if (input.keepDeliverySource && !guard.sourceStale && existsSync15(pcmSourcePath)) {
         deliverySourcePath = pcmSourcePath;
       }
     }
@@ -10702,7 +10730,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
+import { existsSync as existsSync16, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
 import { join as join22 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
@@ -10773,7 +10801,7 @@ function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remed
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
   let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync15(workDir)) return total;
+  if (!existsSync16(workDir)) return total;
   for (const attempt of readdirSync3(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
       total += sampleDirectoryBytes(join22(workDir, attempt));
@@ -11076,7 +11104,7 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join26 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
@@ -11322,7 +11350,7 @@ import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 import { dirname as dirname10, join as join24 } from "node:path";
 import { createRequire } from "node:module";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
 function resolveWorkerEntry(explicit) {
   if (explicit && explicit.length > 0) {
@@ -11335,7 +11363,7 @@ function resolveWorkerEntry(explicit) {
   }
   const moduleDir = dirname10(fileURLToPath3(import.meta.url));
   const jsPath = join24(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync16(jsPath)) return { path: jsPath, isTs: false };
+  if (existsSync17(jsPath)) return { path: jsPath, isTs: false };
   const tsPath = join24(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
@@ -11896,7 +11924,7 @@ async function runCaptureHdrStage(input) {
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
       const debugDumpDir = debugDumpEnabled ? join26(framesDir, "debug-composite") : null;
-      if (debugDumpDir && !existsSync17(debugDumpDir)) {
+      if (debugDumpDir && !existsSync18(debugDumpDir)) {
         mkdirSync8(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
@@ -12053,13 +12081,13 @@ async function runCaptureHdrStage(input) {
 // src/services/render/stages/encodeStage.ts
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
   readFileSync as readFileSync8,
   rmSync as rmSync9,
   statSync as statSync7,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join27 } from "node:path";
@@ -12155,7 +12183,7 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
   }
-  writeFileSync5(outputPath, gif);
+  writeFileSync6(outputPath, gif);
   return null;
 }
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
@@ -12187,7 +12215,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync18(outputPath) ? statSync7(outputPath).size : 0;
+    const fileSize = existsSync19(outputPath) ? statSync7(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -12348,7 +12376,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync18(outputPath)) mkdirSync9(outputPath, { recursive: true });
+    if (!existsSync19(outputPath)) mkdirSync9(outputPath, { recursive: true });
     const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -12359,7 +12387,7 @@ async function runEncodeStage(input) {
       const dst = join27(outputPath, formatExportFrameName(i, "png"));
       copyFileSync4(join27(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync18(audioOutputPath)) {
+    if (hasAudio && audioOutputPath && existsSync19(audioOutputPath)) {
       copyFileSync4(audioOutputPath, join27(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
@@ -12741,18 +12769,14 @@ function hasUsableVideoDimensions(metadata) {
   return Number.isFinite(metadata.width) && Number.isFinite(metadata.height) && metadata.width > 0 && metadata.height > 0;
 }
 function collectVideoMetadataHints(extractedVideos) {
-  return extractedVideos.filter((video) => hasUsableVideoDimensions(video.metadata)).map((video) => ({
-    id: video.videoId,
-    width: video.metadata.width,
-    height: video.metadata.height
-  })).sort((a, b) => a.id.localeCompare(b.id));
+  return extractedVideos.filter((video) => hasUsableVideoDimensions(video.metadata)).map((video) => ({ id: video.videoId, ...displaySize(video.metadata) })).sort((a, b) => a.id.localeCompare(b.id));
 }
 function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync19(framePath) || statSync8(framePath).size <= 8;
+    const missing = !existsSync20(framePath) || statSync8(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -12877,7 +12901,7 @@ function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync19(framePath)) captured++;
+    if (existsSync20(framePath)) captured++;
   }
   return captured;
 }
@@ -13542,7 +13566,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
   validateDeliveryEncoderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
   const outputDir = dirname12(outputPath);
-  if (!existsSync19(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  if (!existsSync20(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;
@@ -13684,7 +13708,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync19(workDir)) mkdirSync10(workDir, { recursive: true });
+    if (!existsSync20(workDir)) mkdirSync10(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -13713,36 +13737,11 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join28(projectDir, entryFile);
-    if (!existsSync19(htmlPath)) {
+    const htmlPath = join28(projectDir, entryFile);
+    if (!existsSync20(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readTextFile2(htmlPath);
-    if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join28(workDir, "standalone-entry.html");
-      const projectIndexPath = join28(projectDir, "index.html");
-      if (!existsSync19(projectIndexPath)) {
-        throw new Error(
-          `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
-        );
-      }
-      const standaloneHtml = extractStandaloneEntryFromIndex(
-        readTextFile2(projectIndexPath),
-        entryFile,
-        rawEntry
-      );
-      if (!standaloneHtml) {
-        throw new Error(
-          `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
-        );
-      }
-      writeFileSync6(wrapperPath, standaloneHtml, "utf-8");
-      htmlPath = wrapperPath;
-      log.info("Extracted standalone entry from index.html host context", {
-        entryFile
-      });
-    }
     const stage1Start = Date.now();
     updateJobStatus(job, "preprocessing", "Compiling composition", 5, onProgress, {
       code: "compile"
@@ -13754,7 +13753,6 @@ async function executeRenderPipeline(input) {
       () => runCompileStage({
         projectDir,
         workDir,
-        htmlPath,
         entryFile,
         job,
         cfg,
@@ -14066,7 +14064,7 @@ async function executeRenderPipeline(input) {
       throw new Error("File server failed to initialize before frame capture");
     }
     const framesDir = join28(workDir, "captured-frames");
-    if (!existsSync19(framesDir)) mkdirSync10(framesDir, { recursive: true });
+    if (!existsSync20(framesDir)) mkdirSync10(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -15394,7 +15392,7 @@ async function executeRenderPipeline(input) {
       })
     );
     const totalElapsed = Date.now() - pipelineStart;
-    const tmpPeakBytes = existsSync19(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync20(workDir) ? sampleDirectoryBytes(workDir) : 0;
     recordTransientRetryObservability();
     observability.checkpoint("pipeline", "artifact validated", { totalElapsedMs: totalElapsed });
     const observabilitySummary = observability.summary({
@@ -15466,7 +15464,7 @@ async function executeRenderPipeline(input) {
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync6(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync7(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -15475,7 +15473,7 @@ async function executeRenderPipeline(input) {
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && !isHls && existsSync19(stagedOutputPath)) {
+      if (!isPngSequence && !isHls && existsSync20(stagedOutputPath)) {
         const debugOutput = join28(workDir, `output${videoExt}`);
         copyFileSync5(stagedOutputPath, debugOutput);
       }
@@ -15987,11 +15985,11 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync6,
   cpSync as cpSync2,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   linkSync,
   mkdirSync as mkdirSync14,
   rmSync as rmSync12,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
 import { extname as extname6, isAbsolute as isAbsolute3, join as join37, relative as relative5, sep as sep2 } from "node:path";
 import {
@@ -16018,7 +16016,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/chunkFrames.ts
-import { existsSync as existsSync21, readdirSync as readdirSync6 } from "node:fs";
+import { existsSync as existsSync22, readdirSync as readdirSync6 } from "node:fs";
 import { extname as extname4, join as join31 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
@@ -16030,7 +16028,7 @@ import {
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
 import { dirname as dirname14, join as join30 } from "node:path";
-import { existsSync as existsSync20, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -16046,7 +16044,7 @@ function isPlanAudioArtifactPath(path) {
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
     const candidate = join30(planDir, name);
-    if (existsSync20(candidate)) return candidate;
+    if (existsSync21(candidate)) return candidate;
   }
   return null;
 }
@@ -16307,7 +16305,7 @@ function readProducerVersion() {
   let current = startDir;
   for (let i = 0; i < 10; i++) {
     const candidate = join30(current, "package.json");
-    if (existsSync20(candidate)) {
+    if (existsSync21(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
@@ -16361,7 +16359,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
   const result = [];
   for (const v of videos) {
     const outputDir = join31(planDir, "video-frames", v.videoId);
-    if (!existsSync21(outputDir)) {
+    if (!existsSync22(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.`
       );
@@ -16477,7 +16475,7 @@ async function extractDeferredVideoFramesForChunk(input) {
       const range = video.deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
       const sourcePath = remoteUrl ?? join31(input.planDir, ...range.sourcePath.split("/"));
-      if (remoteUrl === void 0 && !existsSync21(sourcePath)) {
+      if (remoteUrl === void 0 && !existsSync22(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
           `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
@@ -16695,7 +16693,7 @@ async function readPlanReferenceBackground(input) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join34, relative as relative3, resolve as resolve9 } from "node:path";
 import {
   REFERENCE_BACKGROUND_FIELD,
@@ -16889,7 +16887,7 @@ function planFileSha256(absolutePath, digests) {
   return sha256;
 }
 async function prehashPlanFiles(dir, digests) {
-  if (!existsSync22(dir)) return;
+  if (!existsSync23(dir)) return;
   for (const { absolutePath } of listPlanFiles(dir)) {
     if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
   }
@@ -16955,19 +16953,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(join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync8(join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
   const path = join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync22(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
+  return existsSync23(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join34(planDir, "plan.json");
   const encoderJsonPath = join34(planDir, "meta", "encoder.json");
-  if (!existsSync22(planJsonPath)) {
+  if (!existsSync23(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  if (!existsSync22(encoderJsonPath)) {
+  if (!existsSync23(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
   const planJson = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
@@ -16997,12 +16995,12 @@ async function freezePlan(input) {
     hasAudio,
     digests
   } = input;
-  if (!existsSync22(planDir)) {
+  if (!existsSync23(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
   const metaDir = join34(planDir, "meta");
-  if (!existsSync22(metaDir)) mkdirSync12(metaDir, { recursive: true });
-  writeFileSync7(
+  if (!existsSync23(metaDir)) mkdirSync12(metaDir, { recursive: true });
+  writeFileSync8(
     join34(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
@@ -17010,8 +17008,8 @@ async function freezePlan(input) {
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync7(join34(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync7(join34(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync8(join34(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync8(join34(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -17037,7 +17035,7 @@ async function freezePlan(input) {
     hasAudio
   };
   const planJsonPath = join34(planDir, "plan.json");
-  writeFileSync7(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+  writeFileSync8(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
 }
@@ -17078,8 +17076,8 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync6, existsSync as existsSync23, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync11 } from "node:fs";
-import { writeFileSync as writeFileSync8, writeSync } from "node:fs";
+import { closeSync as closeSync6, existsSync as existsSync24, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync11 } from "node:fs";
+import { writeFileSync as writeFileSync9, writeSync } from "node:fs";
 import { join as join35 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 function audioCutForChunk(grid, chunks, index, fps) {
@@ -17176,15 +17174,15 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync8(join35(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync9(join35(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync8(join35(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync8(join35(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  writeFileSync9(join35(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync9(join35(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
   const layoutPath = join35(planDir, SLICE_LAYOUT);
-  if (!existsSync23(layoutPath)) return resolvePlanAudioPath(planDir);
+  if (!existsSync24(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
   const frame = readFileSync11(join35(planDir, SLICE_FRAME));
   const fd = openSync6(scratchPath, "w");
@@ -17744,7 +17742,7 @@ function createVideoSourceShipper(input) {
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync24(join37(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync25(join37(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
@@ -17772,7 +17770,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync24(planDir)) mkdirSync14(planDir, { recursive: true });
+  if (!existsSync25(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;
@@ -17802,7 +17800,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   });
   const entryFile = config.entryFile ?? "index.html";
   const htmlPath = join37(projectDir, entryFile);
-  if (!existsSync24(htmlPath)) {
+  if (!existsSync25(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
   const workDir = join37(planDir, ".plan-work");
@@ -17846,7 +17844,6 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     urlByAbsentLocalPath,
     projectDir,
     workDir,
-    htmlPath,
     entryFile,
     job,
     cfg,
@@ -18031,15 +18028,15 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   logPlanStage(log, "extract", stageStarted);
   const stagedVideoFrames = join37(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join37(planDir, "video-frames");
-  if (existsSync24(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
+  if (existsSync25(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
   const videoSourcesDir = join37(planDir, "video-sources");
   rmSync12(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync24(stagedVideoFrames)) {
+  if (existsSync25(stagedVideoFrames)) {
     renameWithRetry8(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync14(videoFramesDst, { recursive: true });
   }
-  if (existsSync24(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync25(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
   renameWithRetry8(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -18078,7 +18075,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       sizeBytes
     }))
   );
-  writeFileSync9(
+  writeFileSync10(
     join37(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
@@ -18159,10 +18156,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
   const planAudioPath = join37(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult?.hasAudio && existsSync24(audioResult.audioOutputPath)) {
+  if (audioResult?.hasAudio && existsSync25(audioResult.audioOutputPath)) {
     renameWithRetry8(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio && existsSync24(planAudioPath)) {
+  if (chunksCarryAudio && existsSync25(planAudioPath)) {
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
       await writeChunkAudioSlices({
@@ -18280,7 +18277,7 @@ async function plan(projectDir, config, planDir, options = {}) {
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync13, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync13, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync13 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
 import { join as join41 } from "node:path";
 import {
@@ -18307,7 +18304,7 @@ import {
 } from "@hyperframes/engine";
 import {
   copyFileSync as copyFileSync8,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync16,
   mkdtempSync as mkdtempSync6,
@@ -18315,7 +18312,7 @@ import {
   readdirSync as readdirSync9,
   rmSync as rmSync14,
   statSync as statSync10,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname16, isAbsolute as isAbsolute4, join as join40, relative as relative6, resolve as resolve10, sep as sep3 } from "node:path";
@@ -18325,13 +18322,13 @@ import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as r
 // src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   linkSync as linkSync2,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync5,
   rmSync as rmSync13,
   statSync as statSync9,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
 import { dirname as dirname15, join as join39 } from "node:path";
@@ -18394,7 +18391,7 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync25(destinationDir)) {
+    if (existsSync26(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
@@ -18411,7 +18408,7 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync25(destinationPath)) return;
+    if (existsSync26(destinationPath)) return;
     mkdirSync15(dirname15(destinationPath), { recursive: true });
     const stagingDir = mkdtempSync5(join39(dirname15(destinationPath), ".plan-v2-blob-"));
     const temporaryPath = join39(stagingDir, "blob");
@@ -18429,13 +18426,13 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync25(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync26(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync10(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync11(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameWithRetry9(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
@@ -18508,7 +18505,7 @@ function assertValidExtractionCacheCompleteSentinel(path) {
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
   const videoRoot = join40(executionPlanDir, "video-frames");
-  if (!existsSync26(videoRoot)) return;
+  if (!existsSync27(videoRoot)) return;
   for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
     const videoDir = join40(videoRoot, videoEntry.name);
@@ -18609,7 +18606,7 @@ function parsePlanVideosJson2(value) {
 }
 function materializeExtractedVideoDirectories(planDir) {
   const videosPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync26(videosPath)) return;
+  if (!existsSync27(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 });
@@ -18643,9 +18640,9 @@ function parseChunkSlices(value) {
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
   const videoRoot = join40(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync26(videoRoot) && listFiles(videoRoot).length > 0;
+  const hasExtractedFrames = existsSync27(videoRoot) && listFiles(videoRoot).length > 0;
   const videosPath = join40(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync26(videosPath)) {
+  if (!existsSync27(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
   const chunksPath = join40(executionPlanDir, "meta", "chunks.json");
@@ -18702,7 +18699,7 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync26(destinationPath)) return;
+  if (existsSync27(destinationPath)) return;
   mkdirSync16(dirname16(destinationPath), { recursive: true });
   const temporaryDir = mkdtempSync6(join40(dirname16(destinationPath), ".plan-v2-blob-"));
   const temporaryPath = join40(temporaryDir, "blob");
@@ -18742,7 +18739,7 @@ async function putTasks(tasks) {
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
   const executionPlanPath = join40(executionPlanDir, "plan.json");
-  if (!existsSync26(executionPlanPath)) {
+  if (!existsSync27(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -18822,7 +18819,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync26(planV2Dir)) {
+  if (existsSync27(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
@@ -18835,7 +18832,7 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
-    writeFileSync11(
+    writeFileSync12(
       join40(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
@@ -18908,7 +18905,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync26(planV2Dir)) {
+  if (existsSync27(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
@@ -19062,7 +19059,7 @@ function parsePlanV2Manifest(value) {
 }
 function readPlanV2Manifest(planV2Dir) {
   const manifestPath = join40(planV2Dir, "plan.json");
-  if (!existsSync26(manifestPath)) {
+  if (!existsSync27(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -19081,7 +19078,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync26(sourcePath)) {
+  if (!existsSync27(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync10(sourcePath);
@@ -19094,7 +19091,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
-  if (existsSync26(destinationDir)) {
+  if (existsSync27(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -19115,7 +19112,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
       copyFileSync8(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
-    writeFileSync11(
+    writeFileSync12(
       join40(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
@@ -19159,7 +19156,7 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   const markerPath = join40(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync26(markerPath)) return null;
+  if (!existsSync27(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -19177,7 +19174,7 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
     const path = join40(planDir, ...artifact.path.split("/"));
-    if (!existsSync26(path) || statSync10(path).size !== artifact.sizeBytes) {
+    if (!existsSync27(path) || statSync10(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -19317,7 +19314,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const planJsonPath = join41(planDir, "plan.json");
   const encoderJsonPath = join41(planDir, "meta", "encoder.json");
   const chunksJsonPath = join41(planDir, "meta", "chunks.json");
-  if (!existsSync27(planJsonPath)) {
+  if (!existsSync28(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -19333,7 +19330,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const v2Manifest = v2Materialization?.manifest ?? null;
   const remoteSources = v2Materialization?.remoteSources ?? {};
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync27(required)) {
+    if (!existsSync28(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -19344,7 +19341,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
   const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync27(videosJsonPath)) {
+  if (existsSync28(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync13(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -19375,7 +19372,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
   const compiledDir = join41(planDir, "compiled");
-  if (!existsSync27(compiledDir)) {
+  if (!existsSync28(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -19625,10 +19622,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 (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
+        if (!existsSync28(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
       } else {
         const outDir = join41(outputChunkPath, "..");
-        if (!existsSync27(outDir)) mkdirSync17(outDir, { recursive: true });
+        if (!existsSync28(outDir)) mkdirSync17(outDir, { recursive: true });
       }
       const encodeInput = {
         job,
@@ -19838,7 +19835,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       producerVersion: plan2.producerVersion,
       ffmpegVersion
     };
-    writeFileSync12(perfPath, `${JSON.stringify(perfPayload, null, 2)}
+    writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
       rmSync15(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
@@ -20528,11 +20525,11 @@ import {
 
 // src/server.ts
 import {
-  existsSync as existsSync30,
+  existsSync as existsSync31,
   mkdirSync as mkdirSync19,
   statSync as statSync12,
   mkdtempSync as mkdtempSync8,
-  writeFileSync as writeFileSync13,
+  writeFileSync as writeFileSync14,
   rmSync as rmSync17,
   createReadStream as createReadStream5
 } from "node:fs";
@@ -20551,7 +20548,7 @@ import {
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   readFileSync as readFileSync15,
   statSync as statSync11,
   openSync as openSync7,
@@ -20605,7 +20602,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve11(projectDir);
-  if (!existsSync28(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+  if (!existsSync29(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -20674,7 +20671,7 @@ async function runHyperframeLint(prepared) {
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { dirname as dirname17, join as join44 } from "node:path";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -20751,7 +20748,7 @@ function resolveWorkerEntry2() {
   const here = dirname17(fileURLToPath6(import.meta.url));
   const candidates = [join44(here, "healthWorkerThread.js"), join44(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync29(candidate)) return candidate;
+    if (existsSync30(candidate)) return candidate;
   }
   return void 0;
 }
@@ -20897,7 +20894,7 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
   const outputDir = dirname18(absoluteOutputPath);
-  if (!existsSync30(outputDir)) mkdirSync19(outputDir, { recursive: true });
+  if (!existsSync31(outputDir)) mkdirSync19(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -20938,11 +20935,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve12(candidate);
-  if (!existsSync30(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
+  if (!existsSync31(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync30(resolve12(absProjectDir, entry))) {
+  if (!existsSync31(resolve12(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -20964,7 +20961,7 @@ async function resolveInlineRenderHtml(body) {
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir5();
   const tempProjectDir = mkdtempSync8(join45(tempRoot, "producer-project-"));
-  writeFileSync13(join45(tempProjectDir, "index.html"), html, "utf-8");
+  writeFileSync14(join45(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -21034,7 +21031,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync30(path) ? statSync12(path).size : 0;
+  return existsSync31(path) ? statSync12(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -21338,7 +21335,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync30(artifact.path)) {
+    if (!existsSync31(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -21444,14 +21441,14 @@ import {
 } from "@hyperframes/engine";
 import {
   cpSync as cpSync3,
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   mkdirSync as mkdirSync20,
   mkdtempSync as mkdtempSync9,
   readFileSync as readFileSync16,
   readdirSync as readdirSync11,
   rmSync as rmSync18,
   statSync as statSync13,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
 import { dirname as dirname19, join as join46 } from "node:path";
 import {
@@ -21499,7 +21496,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync31(dirname19(outputPath))) {
+  if (!existsSync32(dirname19(outputPath))) {
     mkdirSync20(dirname19(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync9(`${outputPath}.assemble-work-`);
@@ -21523,7 +21520,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
     const finalPath = join46(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync31(audioPath) ? audioPath : null;
+    const audio = audioPath !== null && existsSync32(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameWithRetry11(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -21541,7 +21538,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync31(outputPath) ? statSync13(outputPath).size : 0;
+  const fileSize = existsSync32(outputPath) ? statSync13(outputPath).size : 0;
   return {
     ...referenceBackgroundResult8(plan2[REFERENCE_BACKGROUND_FIELD6]),
     outputPath,
@@ -21553,13 +21550,13 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
 function readAssemblePlan(planDir, chunkPaths) {
   const planJsonPath = join46(planDir, "plan.json");
   const chunksJsonPath = join46(planDir, "meta", "chunks.json");
-  if (!existsSync31(planJsonPath)) {
+  if (!existsSync32(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync16(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync31(chunksJsonPath)) {
+  if (!existsSync32(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync16(chunksJsonPath, "utf-8"));
@@ -21574,7 +21571,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     }
   }
   for (const path of chunkPaths.flat()) {
-    if (!existsSync31(path)) {
+    if (!existsSync32(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -21672,7 +21669,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
   const listPath = join46(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync14(listPath, `${body}
+  writeFileSync15(listPath, `${body}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -21713,7 +21710,7 @@ function planFormat(planDir) {
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join46(planDir, "meta", "encoder.json");
-  if (!existsSync31(encoderJsonPath)) return {};
+  if (!existsSync32(encoderJsonPath)) return {};
   return JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
@@ -21723,7 +21720,7 @@ function readCfrEncoder(planDir, format) {
     );
   }
   const encoderJsonPath = join46(planDir, "meta", "encoder.json");
-  if (!existsSync31(encoderJsonPath)) {
+  if (!existsSync32(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
@@ -21735,7 +21732,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync31(outputPath)) rmSync18(outputPath, { recursive: true, force: true });
+  if (existsSync32(outputPath)) rmSync18(outputPath, { recursive: true, force: true });
   mkdirSync20(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -21759,7 +21756,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       `[assemble] png-sequence frame count mismatch: merged ${globalIdx} frames vs plan.totalFrames=${totalFrames}. Using on-disk count.`
     );
   }
-  if (audioPath !== null && existsSync31(audioPath)) {
+  if (audioPath !== null && existsSync32(audioPath)) {
     const sidecar = join46(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }