@hyperframes/producer 0.9.13 → 0.9.14

package/dist/index.js

@@ -3741,6 +3741,7 @@ function createStallClock(now = () => Date.now()) {
 
 // src/services/render/stages/captureStreamingStage.ts
 var DEFAULT_CAPTURE_STALL_MS = 6e4;
+var SESSION_INIT_STALL_MS = 3e5;
 var DE_STALL_POLL_MS = 5e3;
 var STALL_ADVICE = "Chrome stopped answering. If another app is keeping the GPU or CPU busy (a 3D render, a game, another export), let it finish or render one job at a time, then retry.";
 function poolFailure(error, probeSession) {
@@ -3771,6 +3772,14 @@ function captureModeLabel(mode) {
   if (mode === "beginframe") return "BeginFrame";
   return "screenshot";
 }
+var OPENING_CAPTURE_SESSION = {
+  captureMode: "screenshot",
+  captureStep: "opening the capture session"
+};
+var OPENING_RISK_SESSION = {
+  captureMode: "screenshot",
+  captureStep: "opening the screenshot session for effect frames"
+};
 var SequentialCaptureStallError = class extends Error {
   captureMode;
   constructor(session, stallTimeoutMs, frameIndex, totalFrames) {
@@ -3920,7 +3929,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   const guard = createDrainFrameGuard({ log, stats, frameTime });
   const guardFrame = (item, buf) => item.trusted ? Promise.resolve(buf) : guard(session, item.idx, buf);
   const captureRisk = async (idx) => {
-    await risk.open();
+    await raceAgainstStall(
+      risk.open(),
+      stallTimeoutMs - quiet.idle(0),
+      { session: OPENING_RISK_SESSION, frameIndex: idx, totalFrames, stallTimeoutMs },
+      abortSignal
+    );
     quiet.reset();
     return raceAgainstStall(
       risk.capture(idx, frameTime(idx)),
@@ -4279,19 +4293,38 @@ async function runCaptureStreamingStage(input) {
       let resumes = 0;
       for (; ; ) {
         const videoInjector = createRenderVideoFrameInjector();
-        const session = probeSession ?? await createCaptureSession(
-          fileServer.url,
-          framesDir,
-          buildCaptureOptions(),
-          videoInjector,
-          captureCfg
+        const initStallMs = Math.max(SESSION_INIT_STALL_MS, resolveCaptureStallTimeoutMs());
+        const setup = createStallClock();
+        const withinInitBudget = (work, stalled) => raceAgainstStall(
+          work,
+          initStallMs - setup.idle(0),
+          { session: stalled, frameIndex: resume.from, totalFrames, stallTimeoutMs: initStallMs },
+          abortSignal
         );
+        const openSession = async () => {
+          const opening = createCaptureSession(
+            fileServer.url,
+            framesDir,
+            buildCaptureOptions(),
+            videoInjector,
+            captureCfg
+          );
+          try {
+            return await withinInitBudget(opening, OPENING_CAPTURE_SESSION);
+          } catch (error) {
+            void opening.then(closeCaptureSession, () => {
+            });
+            throw error;
+          }
+        };
+        const session = probeSession ?? await openSession();
         captureBeyondViewport = session.options.captureBeyondViewport;
         if (probeSession) {
           prepareCaptureSessionForReuse(session, framesDir, videoInjector);
           probeSession = null;
         }
         let riskSession = null;
+        let attemptClosed = false;
         const openRiskSession = async () => {
           const opened = await createCaptureSession(
             fileServer.url,
@@ -4305,6 +4338,10 @@ async function runCaptureStreamingStage(input) {
               enableBrowserPool: false
             }
           );
+          if (attemptClosed) {
+            await closeCaptureSession(opened);
+            throw new Error("[Render] Capture attempt ended while its screenshot session opened");
+          }
           riskSession = opened;
           await initializeSession(opened);
           return opened;
@@ -4312,9 +4349,9 @@ async function runCaptureStreamingStage(input) {
         let resumed = false;
         try {
           if (!session.isInitialized) {
-            await initializeSession(session);
+            await withinInitBudget(initializeSession(session), session);
           }
-          await completeDeferredDrawElementInit(session);
+          await withinInitBudget(completeDeferredDrawElementInit(session), session);
           assertNotAborted();
           lastBrowserConsole = session.browserConsoleBuffer;
           if (session.workerEncodeEnabled) {
@@ -4397,6 +4434,7 @@ async function runCaptureStreamingStage(input) {
           resumes++;
           resumed = true;
         } finally {
+          attemptClosed = true;
           lastBrowserConsole = session.browserConsoleBuffer;
           await closeCaptureSession(session);
           if (riskSession) await closeCaptureSession(riskSession);
@@ -5863,7 +5901,7 @@ import { suggestMatchingPreset } from "@hyperframes/core";
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash6 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7 } from "fs";
 import { join as join15, dirname as dirname7, resolve as resolve7, basename as basename4, relative as relative2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
@@ -7838,6 +7876,25 @@ ${fontFaceBlocks.join("\n")}
   }
   return result;
 }
+function projectStylesheetFontFamilies(html, projectDir) {
+  const families = [];
+  for (const [tag] of html.matchAll(/<link\b[^>]*\brel=["']stylesheet["'][^>]*>/gi)) {
+    const href = /\bhref=["']([^"']+)["']/i.exec(tag)?.[1];
+    if (!href || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(href)) continue;
+    const sheet = resolve7(projectDir, decodedUrlPath(href).replace(/^(?:\.?\/)+/, ""));
+    if (!isPathInside2(sheet, projectDir) || !existsSync10(sheet)) continue;
+    for (const face of extractFontFaceBlocks(readFileSync7(sheet, "utf8"))) {
+      const family = /font-family\s*:\s*([^;}]+)/i.exec(face)?.[1]?.trim().replace(/^['"]|['"]$/g, "");
+      const shipsFile = [...face.matchAll(LOCAL_FONTFACE_URL_RE)].some(([, url = ""]) => {
+        const path = decodedUrlPath(url);
+        const file = path.startsWith("/") ? resolve7(projectDir, `.${path}`) : resolve7(dirname7(sheet), path);
+        return isPathInside2(file, projectDir) && existsSync10(file);
+      });
+      if (family && shipsFile) families.push(family);
+    }
+  }
+  return families;
+}
 function collectFontFaceUrls(html) {
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const urlSet = /* @__PURE__ */ new Set();
@@ -7869,11 +7926,12 @@ function collectFontFaceUrls(html) {
   return urlSet;
 }
 async function localizeRemoteFontFaces(html, downloadDir) {
-  const processed = await inlineExternalFontStylesheets(html);
-  const urlSet = collectFontFaceUrls(processed);
+  return localizeFontFaceUrls(await inlineExternalFontStylesheets(html), downloadDir);
+}
+function localizeFontFaceUrls(html, downloadDir) {
   return downloadAndRewriteUrls(
-    urlSet,
-    processed,
+    collectFontFaceUrls(html),
+    html,
     join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
@@ -8041,15 +8099,17 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   const hasShaderTransitions = detectShaderTransitionUsage(sanitizedHtml);
   const usesThreeDTransforms = detectThreeDTransformUsage(sanitizedHtml);
   const hasAncestorBackgroundImage = detectAncestorBackgroundImage(sanitizedHtml);
+  const fontSheetHtml = await inlineExternalFontStylesheets(
+    promoteCssImportsToLinkTags(sanitizedHtml)
+  );
   const normalizedFontHtml = normalizeSystemFontPrimaryFamilies(
-    injectTextRenderingRule(
-      coalesceHeadStylesAndBodyScripts(promoteCssImportsToLinkTags(sanitizedHtml))
-    )
+    injectTextRenderingRule(coalesceHeadStylesAndBodyScripts(fontSheetHtml))
   );
   const coalescedHtml = await injectDeterministicFontFaces(normalizedFontHtml, {
     logger: defaultLogger,
     failClosedFontFetch: options.failClosedFontFetch === true,
     allowSystemFontCapture: options.allowSystemFontCapture,
+    projectFontFamilies: projectStylesheetFontFamilies(fontSheetHtml, projectDir),
     abortSignal: options.abortSignal
   });
   const assembledHtml = await inlineExternalScripts(coalescedHtml);
@@ -8075,7 +8135,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   );
   const { html: htmlWithLocalImages, remoteMediaAssets: remoteImageAssets } = await localizeRemoteImageSources(htmlWithLocalMedia, downloadDir);
   const { html: htmlWithLocalBg, remoteMediaAssets: remoteBgAssets } = await localizeRemoteBackgroundImages(htmlWithLocalImages, downloadDir);
-  const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeRemoteFontFaces(htmlWithLocalBg, downloadDir);
+  const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeFontFaceUrls(htmlWithLocalBg, downloadDir);
   const {
     html: htmlWithJpegs,
     preparedAssets: preparedHeifAssets,
@@ -11950,7 +12010,7 @@ import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync as rmSync9,
   statSync as statSync7,
   writeFileSync as writeFileSync5
@@ -12044,7 +12104,7 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = formatFfmpegError(result.exitCode, result.stderr);
     return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
   }
-  const gif = readFileSync7(outputPath);
+  const gif = readFileSync8(outputPath);
   if (!clearGifFramesBeforeNext(gif)) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
@@ -12077,7 +12137,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
         return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
     }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync7(outputPath)) !== false) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync8(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
@@ -15481,7 +15541,7 @@ import {
   REFERENCE_BACKGROUND_FIELD as REFERENCE_BACKGROUND_FIELD4,
   referenceBackgroundResult as referenceBackgroundResult6
 } from "@hyperframes/engine";
-import { mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync7, readFileSync as readFileSync13, rmSync as rmSync16 } from "node:fs";
+import { mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync7, readFileSync as readFileSync14, rmSync as rmSync16 } from "node:fs";
 import { join as join42 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 
@@ -15921,7 +15981,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 existsSync19, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -16200,7 +16260,7 @@ function readProducerVersion() {
     const candidate = join30(current, "package.json");
     if (existsSync19(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
           cachedProducerVersion = pkg.version;
           return pkg.version;
@@ -16586,7 +16646,7 @@ async function readPlanReferenceBackground(input) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync9, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join34, relative as relative3, resolve as resolve9 } from "node:path";
 import {
   REFERENCE_BACKGROUND_FIELD,
@@ -16826,7 +16886,7 @@ function collectPlanAssetShas(planDir, digests) {
   const assets = [];
   for (const file of files) {
     if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync9(file.absolutePath);
+      compositionHtml = readFileSync10(file.absolutePath);
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
@@ -16850,7 +16910,7 @@ function writePlanRemoteFiles(planDir, files) {
 }
 function readPlanRemoteFiles(planDir) {
   const path = join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync21(path) ? JSON.parse(readFileSync9(path, "utf-8")) : [];
+  return existsSync21(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join34(planDir, "plan.json");
@@ -16861,8 +16921,8 @@ function recomputePlanHashFromPlanDir(planDir, digests) {
   if (!existsSync21(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
-  const planJson = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync9(encoderJsonPath, "utf-8");
+  const planJson = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync10(encoderJsonPath, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   return computePlanHash({
     compositionHtml,
@@ -16969,7 +17029,7 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync6, existsSync as existsSync22, 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 readFileSync11 } from "node:fs";
 import { writeFileSync as writeFileSync8, writeSync } from "node:fs";
 import { join as join35 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
@@ -17057,7 +17117,7 @@ async function writeChunkAudioSlices(input) {
       offset += track.sizes[offsets.length - 1];
     }
   });
-  const bytes = readFileSync10(input.audioPath);
+  const bytes = readFileSync11(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
   mkdirSync13(join35(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
@@ -17076,8 +17136,8 @@ async function writeChunkAudioSlices(input) {
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
   const layoutPath = join35(planDir, SLICE_LAYOUT);
   if (!existsSync22(layoutPath)) return resolvePlanAudioPath(planDir);
-  const layout = JSON.parse(readFileSync10(layoutPath, "utf-8"));
-  const frame = readFileSync10(join35(planDir, SLICE_FRAME));
+  const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
+  const frame = readFileSync11(join35(planDir, SLICE_FRAME));
   const fd = openSync6(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -17090,7 +17150,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync10(join35(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync11(join35(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -18171,7 +18231,7 @@ async function plan(projectDir, config, planDir, options = {}) {
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync26, 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 readFileSync13, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
 import { join as join41 } from "node:path";
 import {
@@ -18202,7 +18262,7 @@ import {
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync16,
   mkdtempSync as mkdtempSync6,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readdirSync as readdirSync9,
   rmSync as rmSync14,
   statSync as statSync10,
@@ -18351,7 +18411,7 @@ function isNonNegativeIntegerArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0);
 }
 function readJsonFile(path, label) {
-  const contents = readFileSync11(path, "utf-8");
+  const contents = readFileSync12(path, "utf-8");
   try {
     const parsed = JSON.parse(contents);
     return parsed;
@@ -19185,10 +19245,10 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function hashChunkOutput(outputPath, kind) {
-  if (kind === "file") return sha256Hex(readFileSync12(outputPath));
+  if (kind === "file") return sha256Hex(readFileSync13(outputPath));
   const entries = readdirSync10(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync12(join41(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync13(join41(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19214,7 +19274,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
     );
   }
-  const plan2 = JSON.parse(readFileSync12(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync13(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
@@ -19231,13 +19291,13 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       );
     }
   }
-  const encoder = JSON.parse(readFileSync12(encoderJsonPath, "utf-8"));
-  const chunks = JSON.parse(readFileSync12(chunksJsonPath, "utf-8"));
+  const encoder = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
   const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync26(videosJsonPath)) {
     try {
-      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync12(videosJsonPath, "utf-8")));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync13(videosJsonPath, "utf-8")));
     } catch (err) {
       if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
@@ -19348,7 +19408,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync12(join41(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync13(join41(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)
@@ -19810,7 +19870,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       planned.totalFrames
     );
     const slices = JSON.parse(
-      readFileSync13(join42(planDir, "meta", "chunks.json"), "utf-8")
+      readFileSync14(join42(planDir, "meta", "chunks.json"), "utf-8")
     );
     const parts = [];
     for (const slice of slices) {
@@ -20443,7 +20503,7 @@ import {
 // src/services/hyperframeLint.ts
 import {
   existsSync as existsSync27,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   statSync as statSync11,
   openSync as openSync7,
   fstatSync as fstatSync3,
@@ -20489,7 +20549,7 @@ function readEntryHtml(filePath) {
   }
   try {
     if (!fstatSync3(fd).isFile()) return null;
-    return readFileSync14(fd, "utf-8");
+    return readFileSync15(fd, "utf-8");
   } finally {
     closeSync7(fd);
   }
@@ -21338,7 +21398,7 @@ import {
   existsSync as existsSync30,
   mkdirSync as mkdirSync20,
   mkdtempSync as mkdtempSync9,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync11,
   rmSync as rmSync18,
   statSync as statSync13,
@@ -21447,13 +21507,13 @@ function readAssemblePlan(planDir, chunkPaths) {
   if (!existsSync30(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync15(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync16(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
   if (!existsSync30(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const chunks = JSON.parse(readFileSync15(chunksJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync16(chunksJsonPath, "utf-8"));
   if (chunkPaths.length !== chunks.length) {
     throw new Error(
       `[assemble] chunkPaths length (${chunkPaths.length}) does not match chunks.json length (${chunks.length}). Adapters must pass one path per chunk, ordered by index.`
@@ -21599,13 +21659,13 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync15(join46(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync16(join46(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join46(planDir, "meta", "encoder.json");
   if (!existsSync30(encoderJsonPath)) return {};
-  return JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
+  return JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -21617,7 +21677,7 @@ function readCfrEncoder(planDir, format) {
   if (!existsSync30(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
-  const encoderJson = JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
+  const encoderJson = JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
   if (encoderJson.encoder === "libx265-software") {
     throw new Error(
       `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`