@hyperframes/producer 0.8.198 → 0.8.200

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));
@@ -2322,10 +2311,6 @@ var THREE_D_CONTEXT_PATTERN = /transform-style\s*:\s*preserve-3d|backface-visibi
 function detectThreeDTransformUsage(html) {
   return THREE_D_CONTEXT_PATTERN.test(html);
 }
-var MIX_BLEND_MODE_PATTERN = /mix-blend-mode\s*:/i;
-function detectMixBlendModeUsage(html) {
-  return MIX_BLEND_MODE_PATTERN.test(html);
-}
 var BACKGROUND_IMAGE_DECL_PATTERN = /(?:^|;|\{)\s*background(?:-image)?\s*:[^;}]*(?:\bgradient\s*\(|url\s*\()/i;
 function detectAncestorBackgroundImage(html) {
   const { document: document2 } = parseHTML4(html);
@@ -2375,7 +2360,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 +2943,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 +3289,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
   );
@@ -3338,7 +3323,6 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   const renderModeHints = detectRenderModeHints(sanitizedHtml, options.pageMotionBlur);
   const hasShaderTransitions = detectShaderTransitionUsage(sanitizedHtml);
   const usesThreeDTransforms = detectThreeDTransformUsage(sanitizedHtml);
-  const usesMixBlendMode = detectMixBlendModeUsage(sanitizedHtml);
   const hasAncestorBackgroundImage = detectAncestorBackgroundImage(sanitizedHtml);
   const normalizedFontHtml = normalizeSystemFontPrimaryFamilies(
     injectTextRenderingRule(
@@ -3452,7 +3436,6 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     renderModeHints,
     hasShaderTransitions,
     usesThreeDTransforms,
-    usesMixBlendMode,
     hasAncestorBackgroundImage
   };
 }
@@ -3859,13 +3842,6 @@ async function runCompileStage(input) {
       "[Render] Fast capture: composition uses a CSS 3D rendering context (perspective / preserve-3d / backface-visibility), so disabling drawElementImage for this render. Capture uses the platform's baseline route."
     );
   }
-  if (cfg.useDrawElement && process.env.HF_FAST_CAPTURE_BLEND !== "true" && compiled.usesMixBlendMode) {
-    cfg.useDrawElement = false;
-    deCompileGate = "mix_blend_mode";
-    log.info(
-      "[Render] Fast capture: composition uses mix-blend-mode, so disabling drawElementImage for this render. Capture uses the platform's baseline route."
-    );
-  }
   if (cfg.useDrawElement && process.env.HF_FAST_CAPTURE_ANCESTOR_BG !== "true" && compiled.hasAncestorBackgroundImage) {
     cfg.useDrawElement = false;
     deCompileGate = "ancestor_background_image";
@@ -5073,7 +5049,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 +5058,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 +5262,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) {
@@ -5323,19 +5299,21 @@ async function constrainAacTruePeak(input) {
   const timeoutMs = input.timeoutMs ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   return enforceAacTruePeak({
     audioPath: input.audioPath,
+    sourcePath: input.sourcePath,
     targetDurationSeconds: input.targetDurationSeconds,
     signal: input.signal,
-    probeTruePeak: (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }),
-    encode: defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
+    probeTruePeak: input.probeTruePeakDbfs ?? ((audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal })),
+    encode: input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
   });
 }
 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;
+    let sourcePeakDbfs;
     let measuredPath = input.audioPath;
     for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
       const truePeakDbfs = await input.probeTruePeak(measuredPath, input.signal);
@@ -5352,7 +5330,11 @@ async function enforceAacTruePeak(input) {
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
       const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
-      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - truePeakDbfs;
+      if (input.sourcePath && sourcePeakDbfs === void 0) {
+        sourcePeakDbfs = await input.probeTruePeak(input.sourcePath, input.signal);
+      }
+      const referenceDbfs = Math.max(truePeakDbfs, (sourcePeakDbfs ?? -Infinity) + attenuationDb);
+      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - referenceDbfs;
       const result = await input.encode(
         input.audioPath,
         correctedPath,
@@ -5384,7 +5366,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 +5533,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 +5630,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 +5652,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;
@@ -5769,7 +5751,7 @@ async function runCaptureStage(input) {
       );
     }
   }
-  const captureOptions = buildCaptureOptions();
+  const captureOptions = { ...buildCaptureOptions(), deFrameFallback: false };
   const remedy = diskCaptureRemedy(cfg, job.config.format ?? "mp4", job.duration ?? 0, workerCount);
   const checkDiskProjection = createDiskCaptureProjection({
     framesDir,
@@ -6030,10 +6012,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 +6108,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 +6141,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 +6154,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 +6304,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 +6760,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 +7038,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;
@@ -7347,6 +7329,18 @@ function planFrameWeights(input) {
   }
   return weights;
 }
+function withChunkCaptureCost(slices, weights) {
+  const lightest = weights.reduce((least, weight) => Math.min(least, weight), Infinity);
+  return slices.map((slice) => {
+    let sum2 = 0;
+    for (let frame = slice.startFrame; frame < slice.endFrame; frame++) sum2 += weights[frame];
+    const cost = Math.round(sum2 / (slice.endFrame - slice.startFrame) / lightest * 100) / 100;
+    return cost > 1 ? { ...slice, captureCost: cost } : slice;
+  });
+}
+function effectiveChunkFrames(frames, captureCost = 1) {
+  return Math.round(frames * captureCost);
+}
 function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
   if (isUniformFrameCost(weights)) return null;
   const totalFrames = weights.length;
@@ -7374,7 +7368,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 +7468,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 +7526,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 +7534,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 +7608,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 +7632,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 +7643,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 +7674,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 +7750,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 +8123,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 +8134,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 +8223,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 +8242,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 +8256,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 +8646,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) {
@@ -8671,7 +8665,10 @@ function buildPlanChunkSlices(frameWeights, config, chunkCount, effectiveChunkSi
     MIN_CHUNK_SIZE,
     Math.min(config.targetChunkFrames ?? MAX_CHUNK_SIZE, MAX_CHUNK_SIZE, maxFramesPerChunk)
   ) : null;
-  return weighted ?? buildChunkSlices(frameWeights.length, chunkCount, effectiveChunkSize);
+  return withChunkCaptureCost(
+    weighted ?? buildChunkSlices(frameWeights.length, chunkCount, effectiveChunkSize),
+    frameWeights
+  );
 }
 async function readFontSnapshotSha() {
   const module = await import("@hyperframes/core/fonts/embedded-data");
@@ -8806,7 +8803,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 +8823,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 +8857,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 +9064,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 +9102,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 +9240,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 +9310,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 +9335,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 +9353,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 +9425,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 +9438,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 +9450,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 +9467,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 +9486,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 +9638,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) {
@@ -9662,7 +9659,12 @@ function parseChunkSlices(value) {
       throw new PlanV2IntegrityError(`meta/chunks.json contains duplicate chunk index ${index}`);
     }
     indexes.add(index);
-    return { index, startFrame, endFrame };
+    if (chunk.captureCost === void 0) return { index, startFrame, endFrame };
+    const captureCost = chunk.captureCost;
+    if (typeof captureCost !== "number" || !Number.isFinite(captureCost) || captureCost <= 1) {
+      throw new PlanV2IntegrityError(`${field}.captureCost must be a number above 1`);
+    }
+    return { index, startFrame, endFrame, captureCost };
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
@@ -9727,14 +9729,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 +9855,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 +9869,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 +9909,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 +9936,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 +10133,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 +10153,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 +10217,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 +10225,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 +10275,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 +10308,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 +10330,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 +10479,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 +10497,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 +10506,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 +10551,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 +10669,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 +10698,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 +10715,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 +10806,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 +10832,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)
@@ -10839,15 +10841,17 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         deferredVideos.filter((video) => remoteVideoIds.has(video.videoId))
       )
     });
+    const captureFrames = effectiveChunkFrames(framesInChunk, slice.captureCost);
     const chunkWorkerCount = resolveChunkCaptureWorkers(
-      framesInChunk,
-      calculateOptimalWorkers2(framesInChunk, void 0, cfg),
+      captureFrames,
+      calculateOptimalWorkers2(captureFrames, void 0, cfg),
       options?.maxCaptureWorkers
     );
     let session = null;
     let outputKind;
     let framesEncoded = 0;
     let sessionBootMs = 0;
+    let videoExtractMs = 0;
     let captureStageMs = 0;
     let encodeStageMs = 0;
     let captureMode;
@@ -10913,6 +10917,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           session = null;
         }
       }
+      const extractStarted = Date.now();
       const deferredVideoFrames = planVideos ? extractDeferredVideoFramesForChunk({
         planDir,
         planVideos,
@@ -10922,6 +10927,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         cfg,
         remoteSources,
         shownBoxes
+      }).then((frames) => {
+        videoExtractMs = Date.now() - extractStarted;
+        return frames;
       }) : Promise.resolve([]);
       extraction = deferredVideoFrames;
       const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? deferredVideoFrames.then(
@@ -10953,10 +10961,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 +11067,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 +11110,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 {
@@ -11139,6 +11147,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       sessionBootMs,
       captureStageMs,
       encodeStageMs,
+      // Wall time of the chunk's own video frame extraction; it overlaps captureStageMs, so do not add them.
+      videoExtractMs,
       workers: chunkWorkerCount,
       captureMode,
       // Device-pixel box each video's frames were extracted to cover; a video not listed kept full size.
@@ -11151,8 +11161,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 +11191,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 +11217,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync14(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -11456,7 +11466,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 +11507,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);