@hyperframes/producer 0.8.197 → 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;
@@ -7309,8 +7298,72 @@ async function measurePlanSecondsPerFrame(input) {
   }
 }
 
+// src/services/distributed/chunkWeights.ts
+import { resolveFrameFormat } from "@hyperframes/engine";
+var PAGE_BASE_WEIGHT = 0.7;
+var PNG_WEIGHT_FACTOR = 1.5;
+function isUniformFrameCost(weights) {
+  let lightest = Infinity;
+  let heaviest = 0;
+  for (const weight of weights) {
+    lightest = Math.min(lightest, weight);
+    heaviest = Math.max(heaviest, weight);
+  }
+  return heaviest <= lightest * 1.05;
+}
+function planFrameWeights(input) {
+  const { totalFrames, fps } = input;
+  const delta = new Float64Array(totalFrames + 1);
+  const outputPixels = input.width * input.height;
+  const extractedById = new Map(input.extracted.map((entry) => [entry.videoId, entry]));
+  for (const video of input.videos) {
+    const entry = extractedById.get(video.id);
+    if (!entry || video.hidden) continue;
+    const start = Math.max(0, Math.round(video.start * fps));
+    const end = Math.min(totalFrames, Math.round(video.end * fps));
+    if (!(end > start)) continue;
+    const { width, height } = entry.metadata;
+    const factor = resolveFrameFormat(entry.metadata) === "png" ? PNG_WEIGHT_FACTOR : 1;
+    const weight = Math.min(width * height, outputPixels) / 1e6 * factor;
+    delta[start] = delta[start] + weight;
+    delta[end] = delta[end] - weight;
+  }
+  const weights = new Float64Array(totalFrames);
+  let active = 0;
+  for (let frame = 0; frame < totalFrames; frame++) {
+    active += delta[frame];
+    weights[frame] = PAGE_BASE_WEIGHT + active;
+  }
+  return weights;
+}
+function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
+  if (isUniformFrameCost(weights)) return null;
+  const totalFrames = weights.length;
+  const total = weights.reduce((sum2, weight) => sum2 + weight, 0);
+  const minSize = Math.max(1, Math.min(minFrames, Math.floor(totalFrames / chunkCount)));
+  const maxSize = Math.max(maxFrames, Math.ceil(totalFrames / chunkCount));
+  const slices = [];
+  let startFrame = 0;
+  let frame = 0;
+  let costBefore = 0;
+  for (let index = 0; index < chunkCount - 1; index++) {
+    const target = (index + 1) * total / chunkCount;
+    while (frame < totalFrames && costBefore + weights[frame] / 2 < target) {
+      costBefore += weights[frame++];
+    }
+    const remaining = chunkCount - index - 1;
+    const low = Math.max(startFrame + minSize, totalFrames - remaining * maxSize);
+    const high = Math.min(startFrame + maxSize, totalFrames - remaining * minSize);
+    const endFrame = Math.min(high, Math.max(low, frame));
+    slices.push({ index, startFrame, endFrame });
+    startFrame = endFrame;
+  }
+  slices.push({ index: chunkCount - 1, startFrame, endFrame: totalFrames });
+  return slices;
+}
+
 // 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
@@ -7410,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) {
@@ -7468,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 {
@@ -7476,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");
 }
@@ -7550,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;
@@ -7574,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");
@@ -7585,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,
@@ -7616,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)}
@@ -7692,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";
@@ -8065,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);
@@ -8076,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 });
   }
 }
 
@@ -8165,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;
@@ -8184,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(
@@ -8198,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;
 }
@@ -8424,6 +8477,7 @@ var PLAN_PROJECT_DIR_SKIP_SEGMENTS = /* @__PURE__ */ new Set([
 var DEFAULT_CHUNK_SIZE = 240;
 var DEFAULT_MAX_PARALLEL_CHUNKS = 16;
 var MIN_CHUNK_SIZE = 10;
+var MAX_CHUNK_SIZE = 3600;
 var MAX_PARALLEL_CHUNKS_CEILING = 256;
 var ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME = 0.11;
 var ESTIMATED_CHUNK_OVERHEAD_SECONDS = 60;
@@ -8450,6 +8504,11 @@ var ChunkExceedsWorkerTimeoutError = class extends Error {
     this.name = "ChunkExceedsWorkerTimeoutError";
   }
 };
+function framesWithinWorkerTimeout(workerTimeoutSeconds, secondsPerFrame) {
+  return Math.floor(
+    (workerTimeoutSeconds * WORKER_TIMEOUT_MARGIN - ESTIMATED_CHUNK_OVERHEAD_SECONDS) / secondsPerFrame
+  );
+}
 function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger, measuredSecondsPerFrame) {
   if (config.maxParallelChunks !== void 0) return config.maxParallelChunks;
   const { workerTimeoutSeconds, workerConcurrency } = config;
@@ -8462,9 +8521,7 @@ function resolveMaxParallelChunks(config, totalFrames, megapixels, log = default
   const minFramesPerChunk = Math.ceil(ESTIMATED_CHUNK_OVERHEAD_SECONDS / secondsPerFrame);
   const wide = Math.max(1, Math.min(wave, Math.floor(totalFrames / minFramesPerChunk)));
   if (workerTimeoutSeconds === void 0) return wide;
-  const maxFramesPerChunk = Math.floor(
-    (workerTimeoutSeconds * WORKER_TIMEOUT_MARGIN - ESTIMATED_CHUNK_OVERHEAD_SECONDS) / secondsPerFrame
-  );
+  const maxFramesPerChunk = framesWithinWorkerTimeout(workerTimeoutSeconds, secondsPerFrame);
   const needed = maxFramesPerChunk < 1 ? Infinity : Math.ceil(totalFrames / maxFramesPerChunk);
   if (needed > MAX_PARALLEL_CHUNKS_CEILING) {
     const framesAtCeiling = Math.ceil(totalFrames / MAX_PARALLEL_CHUNKS_CEILING);
@@ -8584,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) {
@@ -8596,6 +8653,15 @@ function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
   }
   return slices;
 }
+function buildPlanChunkSlices(frameWeights, config, chunkCount, effectiveChunkSize, maxFramesPerChunk = Infinity) {
+  const weighted = config.chunkSize === void 0 ? buildWeightedChunkSlices(
+    frameWeights,
+    chunkCount,
+    MIN_CHUNK_SIZE,
+    Math.min(config.targetChunkFrames ?? MAX_CHUNK_SIZE, MAX_CHUNK_SIZE, maxFramesPerChunk)
+  ) : null;
+  return weighted ?? buildChunkSlices(frameWeights.length, chunkCount, effectiveChunkSize);
+}
 async function readFontSnapshotSha() {
   const module = await import("@hyperframes/core/fonts/embedded-data");
   const data = module.EMBEDDED_FONT_DATA;
@@ -8729,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 {
@@ -8749,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;
@@ -8783,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,
@@ -8990,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,
@@ -9028,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 }]) => ({
@@ -9045,6 +9111,14 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const digests = options.digests ?? /* @__PURE__ */ new Map();
   const separateAudio = plansSeparateAudio(config, options);
   const chunksCarryAudio = !separateAudio && carriesChunkAudio(config, options);
+  const frameWeights = planFrameWeights({
+    videos: planVideosJson.videos,
+    extracted: planVideosJson.extracted,
+    totalFrames,
+    fps: config.fps,
+    width,
+    height
+  });
   stageStarted = Date.now();
   const [audioOutcome, overlapOutcome, frameCostOutcome] = await Promise.allSettled([
     separateAudio ? null : mixPlanAudio(c, finalCompiledDir).finally(() => logPlanStage(log, "audio", stageStarted)),
@@ -9095,7 +9169,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     maxParallel,
     config.targetChunkFrames
   );
-  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
+  const chunks = buildPlanChunkSlices(
+    frameWeights,
+    config,
+    chunkCount,
+    effectiveChunkSize,
+    chunkSizingUsesFrameCost(config) && config.workerTimeoutSeconds !== void 0 ? framesWithinWorkerTimeout(
+      config.workerTimeoutSeconds,
+      estimateFrameSeconds(megapixels, frameCostOutcome.value)
+    ) : void 0
+  );
   const audioResult = audioOutcome.value;
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
@@ -9149,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,
@@ -9219,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 = {}) {
@@ -9244,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";
@@ -9262,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";
@@ -9334,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");
@@ -9347,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 {
@@ -9359,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) {
@@ -9376,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 });
     }
   }
 };
@@ -9395,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;
@@ -9547,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) {
@@ -9633,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) {
@@ -9759,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));
@@ -9773,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;
   }
 }
@@ -9813,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, {
@@ -9840,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) {
@@ -10037,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);
@@ -10057,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 {
@@ -10121,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";
 
@@ -10129,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";
@@ -10179,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 = {
@@ -10212,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,
@@ -10234,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.`
@@ -10383,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") {
@@ -10401,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".`
@@ -10410,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()) {
@@ -10455,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 {
@@ -10573,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"));
 }
@@ -10602,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, {
@@ -10619,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(
@@ -10710,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 };
@@ -10736,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)
@@ -10859,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,
@@ -10965,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;
@@ -11008,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 {
@@ -11057,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,
@@ -11087,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(
@@ -11113,7 +11196,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync14(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -11147,7 +11230,6 @@ var ALLOWED_RUNTIME_CAPS = ["lambda", "temporal", "cloud-run-job", "k8s-job", "n
 var ALLOWED_HDR_MODES = ["auto", "force-sdr"];
 var MAX_DIMENSION = 7680;
 var MIN_DIMENSION = 16;
-var MAX_CHUNK_SIZE = 3600;
 function validateDistributedRenderConfig(config) {
   if (config === null || typeof config !== "object") {
     throw new InvalidConfigError("config", "must be an object");
@@ -11363,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";
@@ -11404,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);