@hyperframes/producer 0.8.198 → 0.8.199

package/dist/distributed.js

@@ -5,8 +5,8 @@ import {
   cpSync as cpSync2,
   existsSync as existsSync15,
   linkSync,
-  mkdirSync as mkdirSync10,
-  rmSync as rmSync9,
+  mkdirSync as mkdirSync9,
+  rmSync as rmSync8,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { extname as extname4, isAbsolute as isAbsolute3, join as join21, relative as relative5, sep as sep2 } from "node:path";
@@ -66,10 +66,10 @@ var defaultLogger = createConsoleLogger("info");
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
   existsSync as existsSync10,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync3,
-  rmSync as rmSync7,
+  rmSync as rmSync6,
   statSync as statSync4,
   writeFileSync as writeFileSync3,
   copyFileSync as copyFileSync4,
@@ -1297,17 +1297,6 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/render/stages/captureHdrResources.ts
-import {
-  closeSync as closeSync2,
-  constants as constants2,
-  fstatSync as fstatSync2,
-  mkdirSync as mkdirSync2,
-  mkdtempSync,
-  openSync as openSync2,
-  readFileSync as readFileSync2,
-  rmSync as rmSync2,
-  statfsSync
-} from "node:fs";
 import {
   decodePngToRgb48le,
   extractMediaMetadata as extractMediaMetadata2,
@@ -1321,8 +1310,8 @@ import {
   runFfmpeg
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg, fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
-var NO_FOLLOW_FLAG = constants2.O_NOFOLLOW ?? 0;
 var BYTES_PER_MIB = 1024 * 1024;
+var DEFAULT_HDR_WINDOW_BYTES = 512 * BYTES_PER_MIB;
 
 // src/services/render/stages/captureStreamingStage.ts
 import {
@@ -1476,7 +1465,7 @@ import { suggestMatchingPreset } from "@hyperframes/core";
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash3 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join5, dirname as dirname4, resolve as resolve5, basename as basename3, relative as relative2 } from "path";
 import { parseHTML as parseHTML4 } from "linkedom";
 import {
@@ -1704,7 +1693,7 @@ import {
 
 // src/services/animatedGifPrep.ts
 import { createHash as createHash2 } from "node:crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync2 } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, resolve as resolve4 } from "node:path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import { parseAnimatedGifMetadata } from "@hyperframes/core";
@@ -1862,10 +1851,10 @@ async function runAnimatedGifTranscode(request) {
 }
 async function ensurePreparedWebm(input) {
   if (!existsSync4(dirname3(input.cachePath))) {
-    mkdirSync3(dirname3(input.cachePath), { recursive: true });
+    mkdirSync2(dirname3(input.cachePath), { recursive: true });
   }
   if (!existsSync4(dirname3(input.outputPath))) {
-    mkdirSync3(dirname3(input.outputPath), { recursive: true });
+    mkdirSync2(dirname3(input.outputPath), { recursive: true });
   }
   if (!isUsableFile(input.cachePath)) {
     const tmpPath = `${input.cachePath}.tmp-${process.pid}-${Date.now()}`;
@@ -1889,10 +1878,10 @@ async function ensurePreparedWebm(input) {
       if (!isUsableFile(input.cachePath)) {
         renameWithRetry3(tmpPath, input.cachePath);
       } else {
-        rmSync3(tmpPath, { force: true });
+        rmSync2(tmpPath, { force: true });
       }
     } catch (error) {
-      rmSync3(tmpPath, { force: true });
+      rmSync2(tmpPath, { force: true });
       throw error;
     }
   }
@@ -1962,7 +1951,7 @@ async function prepareAnimatedGifInputs(html, options) {
     if (!hasGifExtension(src)) continue;
     const sourcePath = resolveGifSourcePath(src, options);
     if (!sourcePath) continue;
-    const bytes = readFileSync3(sourcePath);
+    const bytes = readFileSync2(sourcePath);
     const metadata = parseAnimatedGifMetadata(bytes);
     if (!metadata?.animated) continue;
     const loop = resolveLoop(metadata, readLoopOverride(img));
@@ -2375,7 +2364,7 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync6(downloadDir)) mkdirSync4(downloadDir, { recursive: true });
+    if (!existsSync6(downloadDir)) mkdirSync3(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -2958,7 +2947,7 @@ var REMOTE_SOURCE_TAG_RE = /<source\b[^>]*?\bsrc\s*=\s*["'](https?:\/\/[^"']+)["
 var REMOTE_IMG_TAG_RE = /<img\b[^>]*?(?<![\w-])src\s*=\s*["'](https?:\/\/[^"']+)["'][^>]*>/gi;
 async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLabel, extraRewrite) {
   if (urlSet.size === 0) return { html, remoteMediaAssets: /* @__PURE__ */ new Map() };
-  if (!existsSync6(remoteDir)) mkdirSync4(remoteDir, { recursive: true });
+  if (!existsSync6(remoteDir)) mkdirSync3(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -3304,7 +3293,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
   const entryHtml = rebaseDirectEntryAssetPaths(
-    readFileSync4(htmlPath, "utf-8"),
+    readFileSync3(htmlPath, "utf-8"),
     projectDir,
     htmlPath
   );
@@ -5073,7 +5062,7 @@ async function appendVideoAudioFromProbe(input) {
 
 // src/services/render/stages/audioStage.ts
 import { join as join10 } from "node:path";
-import { rmSync as rmSync5 } from "node:fs";
+import { rmSync as rmSync4 } from "node:fs";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -5082,7 +5071,7 @@ import {
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync4 } from "node:fs";
+import { mkdtempSync, rmSync as rmSync3 } from "node:fs";
 import { dirname as dirname5, join as join9 } from "node:path";
 import {
   DEFAULT_CONFIG,
@@ -5286,7 +5275,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    for (const path of plan2.cleanupPaths) rmSync4(path, { force: true });
+    for (const path of plan2.cleanupPaths) rmSync3(path, { force: true });
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -5332,7 +5321,7 @@ async function constrainAacTruePeak(input) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync2(join9(dirname5(input.audioPath), ".true-peak-"));
+    scratchDir = mkdtempSync(join9(dirname5(input.audioPath), ".true-peak-"));
     const correctedPath = join9(scratchDir, "audio.m4a");
     const measurements = [];
     let attenuationDb = 0;
@@ -5384,7 +5373,7 @@ async function enforceAacTruePeak(input) {
       )}`
     };
   } finally {
-    if (scratchDir) rmSync4(scratchDir, { recursive: true, force: true });
+    if (scratchDir) rmSync3(scratchDir, { recursive: true, force: true });
   }
 }
 function failResult(outputPath, target, source, error) {
@@ -5551,7 +5540,7 @@ async function runAudioStage(input) {
     }
     return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
   } finally {
-    rmSync5(pcmSourcePath, { force: true });
+    rmSync4(pcmSourcePath, { force: true });
   }
 }
 async function mixAudioForDelivery(input, duration, pcmSourcePath) {
@@ -5648,7 +5637,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync8, readdirSync, statfsSync as statfsSync2 } from "node:fs";
+import { existsSync as existsSync8, readdirSync, statfsSync } from "node:fs";
 import { join as join11 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
@@ -5670,7 +5659,7 @@ function shouldAllowAdaptiveCaptureRetry(workerCount, _explicitlyConfigured) {
 var DISK_PROJECTION_SAMPLE_FRAMES = 10;
 function freeDiskBytesAt(path) {
   try {
-    const stat = statfsSync2(path);
+    const stat = statfsSync(path);
     return stat.bavail * stat.bsize;
   } catch {
     return null;
@@ -6030,10 +6019,10 @@ import {
 import {
   copyFileSync as copyFileSync3,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
-  rmSync as rmSync6,
+  readFileSync as readFileSync4,
+  rmSync as rmSync5,
   statSync as statSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -6126,7 +6115,7 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = formatFfmpegError(result.exitCode, result.stderr);
     return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
   }
-  const gif = readFileSync5(outputPath);
+  const gif = readFileSync4(outputPath);
   if (!clearGifFramesBeforeNext(gif)) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
@@ -6159,7 +6148,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
         return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
     }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync5(outputPath)) !== false) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync4(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
@@ -6172,7 +6161,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync6(input.palettePath, { force: true });
+    rmSync5(input.palettePath, { force: true });
   }
 }
 function startEncodeProgress(job, stage, onProgress) {
@@ -6322,7 +6311,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync9(outputPath)) mkdirSync5(outputPath, { recursive: true });
+    if (!existsSync9(outputPath)) mkdirSync4(outputPath, { recursive: true });
     const captured = readdirSync2(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -6778,7 +6767,7 @@ import {
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
 import { dirname as dirname8, join as join14 } from "node:path";
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync6 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -7056,7 +7045,7 @@ function readProducerVersion() {
     const candidate = join14(current, "package.json");
     if (existsSync11(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync6(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
           cachedProducerVersion = pkg.version;
           return pkg.version;
@@ -7374,7 +7363,7 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join17, relative as relative3, resolve as resolve7 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
@@ -7474,7 +7463,7 @@ function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILI
 
 // src/services/render/stages/planHash.ts
 import { createHash as createHash4 } from "node:crypto";
-import { closeSync as closeSync3, createReadStream as createReadStream3, openSync as openSync3, readSync } from "node:fs";
+import { closeSync as closeSync2, createReadStream as createReadStream3, openSync as openSync2, readSync } from "node:fs";
 var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
 var FIELD_DELIMITER = Buffer.from([0]);
 function computePlanHash(input) {
@@ -7532,7 +7521,7 @@ function sha256Hex(bytes) {
 function sha256File(path) {
   const hash = createHash4("sha256");
   const buffer = Buffer.allocUnsafe(1024 * 1024);
-  const fd = openSync3(path, "r");
+  const fd = openSync2(path, "r");
   try {
     let bytesRead = 0;
     do {
@@ -7540,7 +7529,7 @@ function sha256File(path) {
       if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
     } while (bytesRead > 0);
   } finally {
-    closeSync3(fd);
+    closeSync2(fd);
   }
   return hash.digest("hex");
 }
@@ -7614,7 +7603,7 @@ function collectPlanAssetShas(planDir, digests) {
   const assets = [];
   for (const file of files) {
     if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync8(file.absolutePath);
+      compositionHtml = readFileSync7(file.absolutePath);
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
@@ -7638,7 +7627,7 @@ function writePlanRemoteFiles(planDir, files) {
 }
 function readPlanRemoteFiles(planDir) {
   const path = join17(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync13(path) ? JSON.parse(readFileSync8(path, "utf-8")) : [];
+  return existsSync13(path) ? JSON.parse(readFileSync7(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
   const planJsonPath = join17(planDir, "plan.json");
@@ -7649,8 +7638,8 @@ function recomputePlanHashFromPlanDir(planDir, digests) {
   if (!existsSync13(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
-  const planJson = JSON.parse(readFileSync8(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync8(encoderJsonPath, "utf-8");
+  const planJson = JSON.parse(readFileSync7(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync7(encoderJsonPath, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   return computePlanHash({
     compositionHtml,
@@ -7680,7 +7669,7 @@ async function freezePlan(input) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
   const metaDir = join17(planDir, "meta");
-  if (!existsSync13(metaDir)) mkdirSync7(metaDir, { recursive: true });
+  if (!existsSync13(metaDir)) mkdirSync6(metaDir, { recursive: true });
   writeFileSync4(
     join17(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
@@ -7756,13 +7745,13 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync4, existsSync as existsSync14, ftruncateSync, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync9 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync14, ftruncateSync, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync8 } from "node:fs";
 import { writeFileSync as writeFileSync5, writeSync } from "node:fs";
 import { join as join19 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg6 } from "@hyperframes/engine";
 
 // src/services/distributed/mp4Stitch.ts
-import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
+import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync7 } from "node:fs";
 import { open } from "node:fs/promises";
 import { renameWithRetry as renameWithRetry5 } from "@hyperframes/engine";
 import { dirname as dirname9, join as join18 } from "node:path";
@@ -8129,8 +8118,8 @@ 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);
-  mkdirSync8(dirname9(outputPath), { recursive: true });
-  const workDir = mkdtempSync3(`${outputPath}.stitch-`);
+  mkdirSync7(dirname9(outputPath), { recursive: true });
+  const workDir = mkdtempSync2(`${outputPath}.stitch-`);
   const out = createWriteStream(join18(workDir, "out.mp4"));
   try {
     out.write(header);
@@ -8140,7 +8129,7 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
     renameWithRetry5(join18(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
-    rmSync8(workDir, { recursive: true, force: true });
+    rmSync7(workDir, { recursive: true, force: true });
   }
 }
 
@@ -8229,9 +8218,9 @@ async function writeChunkAudioSlices(input) {
       offset += track.sizes[offsets.length - 1];
     }
   });
-  const bytes = readFileSync9(input.audioPath);
+  const bytes = readFileSync8(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync9(join19(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync8(join19(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -8248,9 +8237,9 @@ async function writeChunkAudioSlices(input) {
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
   const layoutPath = join19(planDir, SLICE_LAYOUT);
   if (!existsSync14(layoutPath)) return resolvePlanAudioPath(planDir);
-  const layout = JSON.parse(readFileSync9(layoutPath, "utf-8"));
-  const frame = readFileSync9(join19(planDir, SLICE_FRAME));
-  const fd = openSync4(scratchPath, "w");
+  const layout = JSON.parse(readFileSync8(layoutPath, "utf-8"));
+  const frame = readFileSync8(join19(planDir, SLICE_FRAME));
+  const fd = openSync3(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
     writeSync(
@@ -8262,12 +8251,12 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync9(join19(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync8(join19(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
   } finally {
-    closeSync4(fd);
+    closeSync3(fd);
   }
   return scratchPath;
 }
@@ -8652,7 +8641,7 @@ var FREEZE_OWNED_PLAN_FILES = [
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync9(join21(planDir, relativePath), { force: true });
+    rmSync8(join21(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -8806,7 +8795,7 @@ function createVideoSourceShipper(input) {
     if (result === null) {
       result = `video-sources/${shipped.size}${extname4(current)}`;
       const destination = join21(input.planDir, ...result.split("/"));
-      mkdirSync10(join21(input.planDir, "video-sources"), { recursive: true });
+      mkdirSync9(join21(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -8826,7 +8815,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync15(planDir)) mkdirSync10(planDir, { recursive: true });
+  if (!existsSync15(planDir)) mkdirSync9(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -8860,10 +8849,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
   const workDir = join21(planDir, ".plan-work");
-  rmSync9(workDir, { recursive: true, force: true });
-  mkdirSync10(workDir, { recursive: true });
+  rmSync8(workDir, { recursive: true, force: true });
+  mkdirSync9(workDir, { recursive: true });
   const compiledDir = join21(workDir, "compiled");
-  mkdirSync10(compiledDir, { recursive: true });
+  mkdirSync9(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
     recursive: true,
@@ -9067,15 +9056,15 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   logPlanStage(log, "extract", stageStarted);
   const stagedVideoFrames = join21(compiledDir, "__hyperframes_video_frames");
   const videoFramesDst = join21(planDir, "video-frames");
-  if (existsSync15(videoFramesDst)) rmSync9(videoFramesDst, { recursive: true, force: true });
+  if (existsSync15(videoFramesDst)) rmSync8(videoFramesDst, { recursive: true, force: true });
   const videoSourcesDir = join21(planDir, "video-sources");
-  rmSync9(videoSourcesDir, { recursive: true, force: true });
+  rmSync8(videoSourcesDir, { recursive: true, force: true });
   if (existsSync15(stagedVideoFrames)) {
     renameWithRetry6(stagedVideoFrames, videoFramesDst);
   } else {
-    mkdirSync10(videoFramesDst, { recursive: true });
+    mkdirSync9(videoFramesDst, { recursive: true });
   }
-  if (existsSync15(finalCompiledDir)) rmSync9(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync15(finalCompiledDir)) rmSync8(finalCompiledDir, { recursive: true, force: true });
   renameWithRetry6(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -9105,7 +9094,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync10(join21(planDir, "meta"), { recursive: true });
+  mkdirSync9(join21(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -9243,7 +9232,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync9(workDir, { recursive: true, force: true });
+    rmSync8(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -9313,7 +9302,7 @@ async function buildPlanAudio(projectDir, config, workRoot, outputPath, options
     renameWithRetry6(mixed.audioOutputPath, outputPath);
     return { hasAudio: true };
   } finally {
-    rmSync9(c.workDir, { recursive: true, force: true });
+    rmSync8(c.workDir, { recursive: true, force: true });
   }
 }
 async function plan(projectDir, config, planDir, options = {}) {
@@ -9338,11 +9327,11 @@ import {
   copyFileSync as copyFileSync7,
   existsSync as existsSync17,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync12,
-  mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync10,
+  mkdirSync as mkdirSync11,
+  mkdtempSync as mkdtempSync4,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync7,
-  rmSync as rmSync11,
+  rmSync as rmSync10,
   statSync as statSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
@@ -9356,9 +9345,9 @@ import {
   copyFileSync as copyFileSync6,
   existsSync as existsSync16,
   linkSync as linkSync2,
-  mkdirSync as mkdirSync11,
-  mkdtempSync as mkdtempSync4,
-  rmSync as rmSync10,
+  mkdirSync as mkdirSync10,
+  mkdtempSync as mkdtempSync3,
+  rmSync as rmSync9,
   statSync as statSync5,
   writeFileSync as writeFileSync7
 } from "node:fs";
@@ -9428,8 +9417,8 @@ var LocalPlanV2ArtifactPublisher = class {
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
-    mkdirSync11(dirname10(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync4(join23(dirname10(destinationDir), ".plan-v2-publish-"));
+    mkdirSync10(dirname10(destinationDir), { recursive: true });
+    this.temporaryDir = mkdtempSync3(join23(dirname10(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -9441,8 +9430,8 @@ var LocalPlanV2ArtifactPublisher = class {
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
     if (existsSync16(destinationPath)) return;
-    mkdirSync11(dirname10(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync4(join23(dirname10(destinationPath), ".plan-v2-blob-"));
+    mkdirSync10(dirname10(destinationPath), { recursive: true });
+    const stagingDir = mkdtempSync3(join23(dirname10(destinationPath), ".plan-v2-blob-"));
     const temporaryPath = join23(stagingDir, "blob");
     try {
       try {
@@ -9453,7 +9442,7 @@ var LocalPlanV2ArtifactPublisher = class {
       }
       renameWithRetry7(temporaryPath, destinationPath);
     } finally {
-      rmSync10(stagingDir, { recursive: true, force: true });
+      rmSync9(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
@@ -9470,7 +9459,7 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async abort() {
     if (!this.#committed) {
-      rmSync10(this.temporaryDir, { recursive: true, force: true });
+      rmSync9(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -9489,7 +9478,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 = readFileSync10(path, "utf-8");
+  const contents = readFileSync9(path, "utf-8");
   try {
     const parsed = JSON.parse(contents);
     return parsed;
@@ -9641,7 +9630,7 @@ function materializeExtractedVideoDirectories(planDir) {
   if (!existsSync17(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
-    mkdirSync12(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
+    mkdirSync11(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
   }
 }
 function parseChunkSlices(value) {
@@ -9727,14 +9716,14 @@ function computeManifestHash(manifest) {
 }
 function writeBlob(sourcePath, destinationPath) {
   if (existsSync17(destinationPath)) return;
-  mkdirSync12(dirname11(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync5(join24(dirname11(destinationPath), ".plan-v2-blob-"));
+  mkdirSync11(dirname11(destinationPath), { recursive: true });
+  const temporaryDir = mkdtempSync4(join24(dirname11(destinationPath), ".plan-v2-blob-"));
   const temporaryPath = join24(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
     renameWithRetry8(temporaryPath, destinationPath);
   } finally {
-    rmSync11(temporaryDir, { recursive: true, force: true });
+    rmSync10(temporaryDir, { recursive: true, force: true });
   }
 }
 function publishBlobFor(absolutePath, digests) {
@@ -9853,8 +9842,8 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
   if (publication.storedBlobs.length > 0) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
-  mkdirSync12(dirname11(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync5(join24(dirname11(planV2Dir), ".plan-v2-build-"));
+  mkdirSync11(dirname11(planV2Dir), { recursive: true });
+  const tempDir = mkdtempSync4(join24(dirname11(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
@@ -9867,7 +9856,7 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     renameWithRetry8(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
-    rmSync11(tempDir, { recursive: true, force: true });
+    rmSync10(tempDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -9907,7 +9896,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync5(join24(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync4(join24(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -9934,7 +9923,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
     }
     throw error;
   } finally {
-    rmSync11(stagingRoot, { recursive: true, force: true });
+    rmSync10(stagingRoot, { recursive: true, force: true });
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
@@ -10131,12 +10120,12 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     artifact,
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
-  mkdirSync12(dirname11(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync5(join24(dirname11(destinationDir), ".plan-v2-materialize-"));
+  mkdirSync11(dirname11(destinationDir), { recursive: true });
+  const tempDir = mkdtempSync4(join24(dirname11(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
       const destinationPath = join24(tempDir, ...artifact.path.split("/"));
-      mkdirSync12(dirname11(destinationPath), { recursive: true });
+      mkdirSync11(dirname11(destinationPath), { recursive: true });
       copyFileSync7(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
@@ -10151,7 +10140,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     );
     renameWithRetry8(tempDir, destinationDir);
   } catch (error) {
-    rmSync11(tempDir, { recursive: true, force: true });
+    rmSync10(tempDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -10215,7 +10204,7 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
 }
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync7, rmSync as rmSync14 } from "node:fs";
+import { mkdtempSync as mkdtempSync6, rmSync as rmSync13 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join27 } from "node:path";
 
@@ -10223,11 +10212,11 @@ import { join as join27 } from "node:path";
 import {
   cpSync as cpSync3,
   existsSync as existsSync18,
-  mkdirSync as mkdirSync13,
-  mkdtempSync as mkdtempSync6,
-  readFileSync as readFileSync11,
+  mkdirSync as mkdirSync12,
+  mkdtempSync as mkdtempSync5,
+  readFileSync as readFileSync10,
   readdirSync as readdirSync8,
-  rmSync as rmSync12,
+  rmSync as rmSync11,
   statSync as statSync7,
   writeFileSync as writeFileSync9
 } from "node:fs";
@@ -10273,9 +10262,9 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
   if (!existsSync18(dirname12(outputPath))) {
-    mkdirSync13(dirname12(outputPath), { recursive: true });
+    mkdirSync12(dirname12(outputPath), { recursive: true });
   }
-  const workDir = mkdtempSync6(`${outputPath}.assemble-work-`);
+  const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
   const stageMs = {};
   const ctx = {
@@ -10306,7 +10295,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync12(workDir, { recursive: true, force: true });
+      rmSync11(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -10328,13 +10317,13 @@ function readAssemblePlan(planDir, chunkPaths) {
   if (!existsSync18(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync11(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
   if (!existsSync18(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync10(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.`
@@ -10477,13 +10466,13 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync11(join25(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync10(join25(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join25(planDir, "meta", "encoder.json");
   if (!existsSync18(encoderJsonPath)) return {};
-  return JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
+  return JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -10495,7 +10484,7 @@ function readCfrEncoder(planDir, format) {
   if (!existsSync18(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
-  const encoderJson = JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
+  const encoderJson = JSON.parse(readFileSync10(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".`
@@ -10504,8 +10493,8 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync18(outputPath)) rmSync12(outputPath, { recursive: true, force: true });
-  mkdirSync13(outputPath, { recursive: true });
+  if (existsSync18(outputPath)) rmSync11(outputPath, { recursive: true, force: true });
+  mkdirSync12(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
     if (!statSync7(chunkDir).isDirectory()) {
@@ -10549,7 +10538,7 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync12, readdirSync as readdirSync9, rmSync as rmSync13, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync13, readFileSync as readFileSync11, readdirSync as readdirSync9, rmSync as rmSync12, writeFileSync as writeFileSync10 } from "node:fs";
 import { cpus } from "node:os";
 import { join as join26 } from "node:path";
 import {
@@ -10667,10 +10656,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(readFileSync11(outputPath));
   const entries = readdirSync9(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync12(join26(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync11(join26(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -10696,7 +10685,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(readFileSync11(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
@@ -10713,13 +10702,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(readFileSync11(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
   const videosJsonPath = join26(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync19(videosJsonPath)) {
     try {
-      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync12(videosJsonPath, "utf-8")));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync11(videosJsonPath, "utf-8")));
     } catch (err) {
       if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
@@ -10804,9 +10793,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       forceScreenshotExplicitlyOptedOut: !encoder.forceScreenshot
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
-    mkdirSync14(workDir, { recursive: true });
+    mkdirSync13(workDir, { recursive: true });
     const framesDir = join26(workDir, "captured-frames");
-    mkdirSync14(framesDir, { recursive: true });
+    mkdirSync13(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
     const chunkFps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -10830,7 +10819,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync12(join26(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync11(join26(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)
@@ -10953,10 +10942,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 (!existsSync19(outputChunkPath)) mkdirSync14(outputChunkPath, { recursive: true });
+        if (!existsSync19(outputChunkPath)) mkdirSync13(outputChunkPath, { recursive: true });
       } else {
         const outDir = join26(outputChunkPath, "..");
-        if (!existsSync19(outDir)) mkdirSync14(outDir, { recursive: true });
+        if (!existsSync19(outDir)) mkdirSync13(outDir, { recursive: true });
       }
       const encodeInput = {
         job,
@@ -11059,8 +11048,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
-          rmSync13(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          mkdirSync14(framesDir, { recursive: true });
+          rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          mkdirSync13(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
           job.framesRendered = 0;
@@ -11102,8 +11091,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync13(videoOnlyPath, { force: true });
-        rmSync13(audioScratchPath, { force: true });
+        rmSync12(videoOnlyPath, { force: true });
+        rmSync12(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -11151,8 +11140,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     writeFileSync10(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync13(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync13(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync12(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     } catch (err) {
       log.warn("[renderChunk] failed to remove work dir", {
         workDir,
@@ -11181,17 +11170,17 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync7(join27(tmpdir2(), "hf-plan-v2-chunk-"));
+  const workRoot = mkdtempSync6(join27(tmpdir2(), "hf-plan-v2-chunk-"));
   const materializedPlanDir = join27(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
   } finally {
-    rmSync14(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync7(join27(tmpdir2(), "hf-plan-v2-assembler-"));
+  const workRoot = mkdtempSync6(join27(tmpdir2(), "hf-plan-v2-assembler-"));
   const materializedPlanDir = join27(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
@@ -11207,7 +11196,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync14(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -11456,7 +11445,7 @@ function validateIntDimension(field, value) {
 }
 
 // src/services/distributed/projectHash.ts
-import { closeSync as closeSync5, openSync as openSync5, readdirSync as readdirSync10, readSync as readSync3, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
+import { closeSync as closeSync4, openSync as openSync4, readdirSync as readdirSync10, readSync as readSync3, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
 import { join as join28 } from "node:path";
 var SITE_ID_SCHEME = "site-v2\0";
@@ -11497,14 +11486,14 @@ function hashProjectDir(projectDir, files = listSiteFiles(projectDir)) {
   for (const rel of files) {
     hash.update(rel);
     hash.update("\0");
-    const fd = openSync5(join28(projectDir, rel), "r");
+    const fd = openSync4(join28(projectDir, rel), "r");
     try {
       let read;
       while ((read = readSync3(fd, chunk, 0, chunk.length, null)) > 0) {
         hash.update(chunk.subarray(0, read));
       }
     } finally {
-      closeSync5(fd);
+      closeSync4(fd);
     }
   }
   return hash.digest("hex").slice(0, 16);