@hyperframes/producer 0.8.198 → 0.8.200

package/dist/index.js

@@ -5,8 +5,8 @@ import {
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync8,
   readdirSync as readdirSync5,
-  rmSync as rmSync10,
-  statSync as statSync6,
+  rmSync as rmSync11,
+  statSync as statSync7,
   writeFileSync as writeFileSync5,
   copyFileSync as copyFileSync4,
   appendFileSync
@@ -55,7 +55,7 @@ import {
   augmentProtocolTimeoutError,
   augmentPageNavigationTimeoutError
 } from "@hyperframes/engine";
-import { join as join25, dirname as dirname10, resolve as resolve7 } from "path";
+import { join as join26, dirname as dirname10, resolve as resolve7 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -1890,8 +1890,8 @@ function replanAfterFailure(plan2, failure) {
 }
 
 // src/services/render/stages/captureSegmentedStage.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, rmSync as rmSync5, statSync as statSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, rmSync as rmSync6, statSync as statSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 import {
   captureFrameToBuffer as captureFrameToBuffer2,
   closeCaptureSession as closeCaptureSession2,
@@ -2094,6 +2094,7 @@ function aggregateDrawElement(perfs, de) {
     blankDeterministicAccepts: drain?.blankDeterministicAccepts ?? 0,
     blankRecaptures: drain?.blankRecaptures ?? 0,
     boundaryFrames: perfs.reduce((sum2, p) => sum2 + (p.deBoundaryFrames ?? 0), 0),
+    riskFrames: perfs.reduce((sum2, p) => sum2 + (p.deRiskFrames ?? 0), 0),
     ncprFallbacks: perfs.reduce((sum2, p) => sum2 + (p.deNcprFallbacks ?? 0), 0),
     frameTimeouts: perfs.reduce((sum2, p) => sum2 + (p.deFrameTimeouts ?? 0), 0)
   };
@@ -2275,7 +2276,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/hdrCompositor.ts
-import { readSync as readSync2, closeSync as closeSync3 } from "fs";
+import { readSync as readSync2 } from "fs";
 import { join as join6 } from "path";
 import {
   captureAlphaPng,
@@ -2328,10 +2329,10 @@ function cropRgb48le(src, srcW, srcH, cropX, cropY, cropW, cropH) {
 }
 function closeHdrVideoFrameSource(source, log) {
   try {
-    closeSync3(source.fd);
+    source.windows.close();
   } catch (err) {
-    log?.warn("Failed to close HDR raw frame file", {
-      rawPath: source.rawPath,
+    log?.warn("Failed to close HDR raw frame windows", {
+      dir: source.dir,
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -2341,7 +2342,7 @@ function resolveHdrVideoFrameIndex(time, startTime, fps, frameCount, loop = fals
   if (frameIndex < 0 || frameCount < 1) return null;
   return loop ? frameIndex % frameCount : Math.min(frameIndex, frameCount - 1);
 }
-function blitHdrVideoLayer(canvas, el, time, fps, hdrVideoFrameSources, hdrStartTimes, width, height, log, sourceTransfer, targetTransfer, hdrPerf) {
+async function blitHdrVideoLayer(canvas, el, time, fps, hdrVideoFrameSources, hdrStartTimes, width, height, log, sourceTransfer, targetTransfer, hdrPerf) {
   const frameSource = hdrVideoFrameSources.get(el.id);
   const startTime = hdrStartTimes.get(el.id);
   if (!frameSource || startTime === void 0 || el.opacity <= 0) {
@@ -2357,13 +2358,32 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrVideoFrameSources, hdrStart
   if (effectiveIndex === null) return;
   const mediaTime = (frameSource.mediaStart ?? 0) + effectiveIndex / fps;
   if (isVideoHiddenBeforeStreamStart(frameSource.videoStreamLeadSeconds, mediaTime)) return;
-  const frameOffset = effectiveIndex * frameSource.frameSize;
+  if (hdrPerf) hdrPerf.hdrVideoLayerBlits += 1;
+  const lease = await frameSource.windows.lease(effectiveIndex);
+  if (!lease) return;
+  try {
+    blitScratchFrameWithoutYielding(
+      canvas,
+      el,
+      frameSource,
+      lease,
+      width,
+      height,
+      log,
+      sourceTransfer,
+      targetTransfer,
+      hdrPerf
+    );
+  } finally {
+    lease.release();
+  }
+}
+function blitScratchFrameWithoutYielding(canvas, el, frameSource, lease, width, height, log, sourceTransfer, targetTransfer, hdrPerf) {
   try {
-    if (hdrPerf) hdrPerf.hdrVideoLayerBlits += 1;
     const bytesRead = timeHdrPhase(
       hdrPerf,
       "hdrVideoReadDecodeMs",
-      () => readSync2(frameSource.fd, frameSource.scratch, 0, frameSource.frameSize, frameOffset)
+      () => readSync2(lease.fd, frameSource.scratch, 0, frameSource.frameSize, lease.offset)
     );
     if (bytesRead !== frameSource.frameSize) return;
     const hdrRgb = frameSource.scratch;
@@ -2592,7 +2612,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           hdrPerf
         );
       } else {
-        blitHdrVideoLayer(
+        await blitHdrVideoLayer(
           canvas,
           layer.element,
           time,
@@ -2636,7 +2656,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
             startTime,
             localTime: localTime.toFixed(3),
             hdrFrameNum: frameNum,
-            rawPath: frameSource?.rawPath ?? null,
+            dir: frameSource?.dir ?? null,
             frameCount: frameSource?.frameCount ?? null
           });
         }
@@ -2732,18 +2752,8 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
 }
 
 // src/services/render/stages/captureHdrResources.ts
-import {
-  closeSync as closeSync4,
-  constants as constants2,
-  fstatSync as fstatSync3,
-  mkdirSync as mkdirSync2,
-  mkdtempSync as mkdtempSync2,
-  openSync as openSync3,
-  readFileSync as readFileSync3,
-  rmSync as rmSync4,
-  statfsSync
-} from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync3, rmSync as rmSync5, statSync as statSync2, statfsSync } from "node:fs";
+import { join as join8 } from "node:path";
 import {
   decodePngToRgb48le,
   extractMediaMetadata as extractMediaMetadata2,
@@ -2757,7 +2767,90 @@ import {
   runFfmpeg
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg, fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
-var NO_FOLLOW_FLAG = constants2.O_NOFOLLOW ?? 0;
+
+// src/services/hdrFrameWindows.ts
+import { closeSync as closeSync3, constants as constants2, openSync as openSync3, rmSync as rmSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+function createHdrFrameWindows(opts) {
+  const { dir, frameSize, windowFrames, maxResident, extract } = opts;
+  let totalFrames = opts.totalFrames;
+  const windows = /* @__PURE__ */ new Map();
+  const drop = (index, w) => {
+    windows.delete(index);
+    if (w.fd >= 0) closeSync3(w.fd);
+    rmSync4(w.path, { force: true });
+  };
+  const open2 = (index) => {
+    const known = windows.get(index);
+    if (known) {
+      windows.delete(index);
+      windows.set(index, known);
+      return known;
+    }
+    for (const [i, w2] of windows) {
+      if (windows.size < maxResident) break;
+      if (w2.pins === 0) drop(i, w2);
+    }
+    const firstFrame = index * windowFrames;
+    const w = {
+      firstFrame,
+      path: join7(dir, `window-${index}.rgb48le`),
+      frames: 0,
+      fd: -1,
+      pins: 0,
+      ready: Promise.resolve()
+    };
+    w.ready = extract({
+      firstFrame,
+      frames: Math.min(windowFrames, totalFrames - firstFrame),
+      path: w.path
+    }).then((produced) => {
+      if (produced < 1) return;
+      w.fd = openSync3(w.path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+      w.frames = produced;
+    });
+    windows.set(index, w);
+    return w;
+  };
+  return {
+    get totalFrames() {
+      return totalFrames;
+    },
+    async lease(frameIndex) {
+      for (; ; ) {
+        if (totalFrames < 1) return null;
+        const index = Math.min(Math.max(0, frameIndex), totalFrames - 1);
+        const key = Math.floor(index / windowFrames);
+        const w = open2(key);
+        w.pins += 1;
+        try {
+          await w.ready;
+        } catch (error) {
+          w.pins -= 1;
+          windows.delete(key);
+          throw error;
+        }
+        const local = index - w.firstFrame;
+        if (local < w.frames) {
+          return {
+            fd: w.fd,
+            offset: local * frameSize,
+            release: () => {
+              w.pins -= 1;
+            }
+          };
+        }
+        w.pins -= 1;
+        totalFrames = Math.min(totalFrames, w.firstFrame + w.frames);
+      }
+    },
+    close() {
+      for (const [i, w] of [...windows]) drop(i, w);
+    }
+  };
+}
+
+// src/services/render/stages/captureHdrResources.ts
 function tempDirSafePrefix(id) {
   const safe = id.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
   return safe || "video";
@@ -2802,10 +2895,16 @@ async function probeHdrExtractionDims(args) {
     const stacking = await queryElementStacking(domSession.page, nativeHdrIds);
     for (const el of stacking) {
       if (el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0 && !prep.hdrExtractionDims.has(el.id)) {
-        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+        prep.hdrExtractionDims.set(el.id, {
+          width: el.layoutWidth,
+          height: el.layoutHeight
+        });
       }
       if (el.isHdr && nativeHdrImageIds.has(el.id) && !prep.hdrImageFitInfo.has(el.id)) {
-        prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
+        prep.hdrImageFitInfo.set(el.id, {
+          fit: el.objectFit,
+          position: el.objectPosition
+        });
       }
     }
   }
@@ -2824,23 +2923,21 @@ async function probeHdrExtractionDims(args) {
     const retryStacking = await queryElementStacking(domSession.page, nativeHdrIds);
     for (const el of retryStacking) {
       if (el.id === imageId && el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0) {
-        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+        prep.hdrExtractionDims.set(el.id, {
+          width: el.layoutWidth,
+          height: el.layoutHeight
+        });
         if (!prep.hdrImageFitInfo.has(el.id)) {
-          prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
+          prep.hdrImageFitInfo.set(el.id, {
+            fit: el.objectFit,
+            position: el.objectPosition
+          });
         }
         break;
       }
     }
   }
 }
-function estimateHdrExtractionBytes(videos, fps) {
-  let total = 0;
-  for (const v of videos) {
-    const frames = Math.ceil(Math.max(0, v.durationSeconds) * fps);
-    total += frames * v.width * v.height * 6;
-  }
-  return total;
-}
 var HDR_EXTRACTION_HEADROOM_FRACTION = 0.9;
 var HDR_EXTRACTION_CGROUP_BUDGET_FRACTION = 0.5;
 var HDR_EXTRACTION_WARN_BYTES = 1e10;
@@ -2904,24 +3001,22 @@ function resolveHdrExtractionWindow(video, compositionDuration, metadata) {
   }
   return window2;
 }
-function cleanupHdrFrameDirectory(frameDir, rawPath, log) {
+function cleanupHdrFrameDirectory(frameDir, log) {
   if (process.env.KEEP_TEMP === "1") return;
   try {
-    rmSync4(frameDir, { recursive: true, force: true });
+    rmSync5(frameDir, { recursive: true, force: true });
   } catch (err) {
     log?.warn("Failed to clean up HDR raw frame directory", {
       frameDir,
-      rawPath,
       error: err instanceof Error ? err.message : String(err)
     });
   }
 }
 function cleanupHdrVideoFrameSource(source, log) {
   closeHdrVideoFrameSource(source, log);
-  cleanupHdrFrameDirectory(source.dir, source.rawPath, log);
+  cleanupHdrFrameDirectory(source.dir, log);
 }
-function assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fps, log) {
-  const estimatedBytes = estimateHdrExtractionBytes(plannedVideos, fps);
+function assertHdrExtractionDiskHeadroom(framesDir, estimatedBytes, log) {
   const configuredBudget = resolveHdrExtractionBudgetBytes(
     process.env[HDR_EXTRACTION_MAX_BYTES_ENV]
   );
@@ -2955,14 +3050,29 @@ function assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fps, log) {
     budgetBytes: resolveHdrExtractionActiveBudgetBytes(configuredBudget, freeBytes)
   };
 }
+var DEFAULT_HDR_WINDOW_BYTES = 512 * BYTES_PER_MIB;
+function hdrWindowFrames(frameSize, windowBytes) {
+  return Math.max(8, Math.floor(windowBytes / frameSize));
+}
+async function probeFirstTick(srcPath, mediaStart, fps, runFfmpegImpl, abortSignal) {
+  const args = ["-ss", String(mediaStart), "-i", srcPath, "-frames:v", "1"];
+  const result = await runFfmpegImpl([...args, ...["-vf", "showinfo", "-f", "null", "-"]], {
+    signal: abortSignal
+  });
+  const match = /pts_time:(-?[\d.]+)/.exec(result.stderr);
+  return match ? Math.max(0, Math.floor(Number(match[1]) * fps + 0.5)) : 0;
+}
 async function extractHdrVideoFrames(args) {
   const { job, log, framesDir, composition, prep, width, height, abortSignal, hdrDiagnostics } = args;
+  const maxResident = Math.max(2, args.maxResidentWindows ?? 2);
+  const windowBytes = args.windowBytes ?? DEFAULT_HDR_WINDOW_BYTES;
   const runFfmpegImpl = args.runFfmpegImpl ?? runFfmpeg;
   const extractMediaMetadataImpl = args.extractMediaMetadataImpl ?? extractMediaMetadata2;
   const resolveFinalFrameExtractionWindowImpl = args.resolveFinalFrameExtractionWindowImpl ?? resolveFinalFrameExtractionWindow;
+  const fps = fpsToNumber4(job.config.fps);
   const out = /* @__PURE__ */ new Map();
   mkdirSync2(framesDir, { recursive: true });
-  const plannedVideos = [];
+  let scratchBytes = 0;
   const extractionWindows = /* @__PURE__ */ new Map();
   for (const [videoId, srcPath] of prep.hdrVideoSrcPaths) {
     const video = composition.videos.find((v) => v.id === videoId);
@@ -2983,16 +3093,13 @@ async function extractHdrVideoFrames(args) {
       videoStreamLeadSeconds: metadata.videoStreamLeadSeconds
     });
     prep.hdrVideoStartTimes.set(videoId, window2.compositionStart);
-    plannedVideos.push({
-      durationSeconds: window2.durationSeconds,
-      width: dims.width,
-      height: dims.height
-    });
+    const frameSize = dims.width * dims.height * 6;
+    const frames = window2.finalFrameOnly ? 1 : Math.ceil(window2.durationSeconds * fps);
+    scratchBytes += Math.min(frames, maxResident * hdrWindowFrames(frameSize, windowBytes)) * frameSize;
   }
   const { estimatedBytes, budgetBytes } = assertHdrExtractionDiskHeadroom(
     framesDir,
-    plannedVideos,
-    fpsToNumber4(job.config.fps),
+    scratchBytes,
     log
   );
   const releaseReservation = reserveHdrExtractionBytes(estimatedBytes, budgetBytes);
@@ -3004,79 +3111,79 @@ async function extractHdrVideoFrames(args) {
       if (!video || !planned) continue;
       const { window: window2 } = planned;
       mkdirSync2(framesDir, { recursive: true });
-      const frameDir = mkdtempSync2(join7(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      const frameDir = mkdtempSync2(join8(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
-      const rawPath = join7(frameDir, "frames.rgb48le");
-      const extractionMediaStart = window2.extractionMediaStart ?? window2.mediaStart;
-      const extractionStart = String(extractionMediaStart);
-      const ffmpegArgs = [];
-      if (window2.finalFrameOnly) {
-        ffmpegArgs.push("-i", srcPath, "-ss", extractionStart, "-frames:v", "1");
-      } else {
-        ffmpegArgs.push(
-          "-ss",
-          extractionStart,
-          "-i",
-          srcPath,
-          "-t",
-          String(window2.durationSeconds)
-        );
-      }
-      if (!window2.finalFrameOnly) {
-        ffmpegArgs.push("-r", fpsToFfmpegArg(job.config.fps));
-      }
-      ffmpegArgs.push(
-        "-vf",
-        `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`,
-        "-pix_fmt",
-        "rgb48le",
-        "-f",
-        "rawvideo",
-        "-y",
-        rawPath
-      );
-      const result = await runFfmpegImpl(ffmpegArgs, { signal: abortSignal });
-      if (!result.success) {
-        hdrDiagnostics.videoExtractionFailures += 1;
-        log.error("HDR frame pre-extraction failed; aborting render", {
-          videoId,
-          srcPath,
-          stderr: result.stderr.slice(-400)
-        });
-        throw encoderFailureError(`HDR frame extraction failed for video "${videoId}"`, {
-          error: `Aborting render to avoid shipping black HDR layers: ${result.stderr.slice(-400)}`,
-          failureReason: result.failureReason
-        });
-      }
       const frameSize = dims.width * dims.height * 6;
-      const fd = openSync3(rawPath, constants2.O_RDONLY | NO_FOLLOW_FLAG);
-      let handedOff = false;
-      try {
-        const frameCount = Math.floor(fstatSync3(fd).size / frameSize);
-        if (frameCount < 1) {
-          hdrDiagnostics.videoExtractionFailures += 1;
-          throw new Error(
-            `HDR frame extraction produced no frames for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
+      const extractionMediaStart = window2.extractionMediaStart ?? window2.mediaStart;
+      const scale = `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`;
+      const firstTick = window2.finalFrameOnly ? 0 : await probeFirstTick(srcPath, extractionMediaStart, fps, runFfmpegImpl, abortSignal);
+      const totalFrames = window2.finalFrameOnly ? 1 : Math.max(1, Math.ceil(window2.durationSeconds * fps - firstTick - 1e-9)) + Number(video.loop);
+      const windowFrames = Math.min(totalFrames, hdrWindowFrames(frameSize, windowBytes));
+      const windows = createHdrFrameWindows({
+        dir: frameDir,
+        frameSize,
+        totalFrames,
+        windowFrames,
+        maxResident,
+        extract: async (spec) => {
+          const ffmpegArgs = window2.finalFrameOnly ? (
+            // Decode before seeking for the one-frame path. Input-side seeking can
+            // return zero frames for valid unindexed/negative-base transports.
+            ["-i", srcPath, "-ss", String(extractionMediaStart), "-frames:v", "1", "-vf", scale]
+          ) : hdrWindowFfmpegArgs({
+            srcPath,
+            mediaStart: extractionMediaStart,
+            fps,
+            fpsArg: fpsToFfmpegArg(job.config.fps),
+            firstTick,
+            firstFrame: spec.firstFrame,
+            frames: spec.frames,
+            scale
+          });
+          const result = await runFfmpegImpl(
+            [...ffmpegArgs, "-pix_fmt", "rgb48le", "-f", "rawvideo", "-y", spec.path],
+            { signal: abortSignal }
           );
+          if (!result.success) {
+            hdrDiagnostics.videoExtractionFailures += 1;
+            log.error("HDR frame extraction failed; aborting render", {
+              videoId,
+              srcPath,
+              firstFrame: spec.firstFrame,
+              stderr: result.stderr.slice(-400)
+            });
+            throw encoderFailureError(`HDR frame extraction failed for video "${videoId}"`, {
+              error: `Aborting render to avoid shipping black HDR layers: ${result.stderr.slice(-400)}`,
+              failureReason: result.failureReason
+            });
+          }
+          return Math.min(Math.floor(statSync2(spec.path).size / frameSize), spec.frames);
         }
-        out.set(videoId, {
-          dir: frameDir,
-          rawPath,
-          fd,
-          width: dims.width,
-          height: dims.height,
-          frameSize,
-          frameCount,
-          scratch: Buffer.allocUnsafe(frameSize),
-          loop: video.loop,
-          mediaStart: extractionMediaStart,
-          videoStreamLeadSeconds: planned.videoStreamLeadSeconds
-        });
-        handedOff = true;
-      } finally {
-        if (!handedOff) closeSync4(fd);
+      });
+      const first = await windows.lease(0);
+      if (!first) {
+        hdrDiagnostics.videoExtractionFailures += 1;
+        throw new Error(
+          `HDR frame extraction produced no frames for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
+        );
       }
+      first.release();
+      if (video.loop) (await windows.lease(totalFrames - 1))?.release();
+      out.set(videoId, {
+        dir: frameDir,
+        windows,
+        width: dims.width,
+        height: dims.height,
+        frameSize,
+        get frameCount() {
+          return windows.totalFrames;
+        },
+        scratch: Buffer.allocUnsafe(frameSize),
+        loop: video.loop,
+        mediaStart: extractionMediaStart,
+        videoStreamLeadSeconds: planned.videoStreamLeadSeconds
+      });
     }
     return { sources: out, estimatedBytes, releaseReservation };
   } catch (error) {
@@ -3085,12 +3192,23 @@ async function extractHdrVideoFrames(args) {
       createdFrameDirs.delete(source.dir);
     }
     for (const frameDir of createdFrameDirs) {
-      cleanupHdrFrameDirectory(frameDir, void 0, log);
+      cleanupHdrFrameDirectory(frameDir, log);
     }
     releaseReservation();
     throw error;
   }
 }
+function hdrWindowFfmpegArgs(a) {
+  const unit = Math.ceil(a.fps);
+  const seekFrame = a.firstFrame < unit ? 0 : (Math.floor(a.firstFrame / unit) - 1) * unit;
+  const trim = a.firstFrame - seekFrame;
+  const filters = [`fps=${a.fpsArg}:start_time=${(a.firstTick / a.fps).toFixed(6)}`, a.scale];
+  if (trim > 0) filters.push(`trim=start_frame=${trim}`);
+  return [
+    ...["-ss", (a.mediaStart + seekFrame / a.fps).toFixed(6), "-i", a.srcPath],
+    ...["-vf", filters.join(","), "-frames:v", String(a.frames)]
+  ];
+}
 function decodeHdrImageBuffers(args) {
   const { log, hdrImageSrcPaths, prep, hdrDiagnostics } = args;
   const out = /* @__PURE__ */ new Map();
@@ -3110,7 +3228,11 @@ function decodeHdrImageBuffers(args) {
           fit,
           fitInfo?.position
         );
-        out.set(imageId, { data: resampled, width: layout.width, height: layout.height });
+        out.set(imageId, {
+          data: resampled,
+          width: layout.width,
+          height: layout.height
+        });
       } else {
         out.set(imageId, {
           data: Buffer.from(decoded.data),
@@ -3222,7 +3344,7 @@ async function captureSceneIntoBuffer(a) {
         hdrPerf
       );
     } else {
-      blitHdrVideoLayer(
+      await blitHdrVideoLayer(
         sceneBuf,
         el,
         time,
@@ -3424,7 +3546,7 @@ function isTargetLossError(error) {
 // src/services/render/stages/captureStreamingStage.ts
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import {
   DrawElementVerificationError,
   captureFrameToBuffer,
@@ -3586,11 +3708,11 @@ function createDrainFrameGuard(args) {
         return buf;
       }
       if (db < verifyMinDb) {
-        const dumpDir = await mkdtemp(join8(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
+        const dumpDir = await mkdtemp(join9(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
         if (dumpDir) {
           await Promise.all([
-            writeFile(join8(dumpDir, `frame-${idx}-de.jpg`), buf),
-            writeFile(join8(dumpDir, `frame-${idx}-truth.jpg`), truth)
+            writeFile(join9(dumpDir, `frame-${idx}-de.jpg`), buf),
+            writeFile(join9(dumpDir, `frame-${idx}-truth.jpg`), truth)
           ]).catch(() => {
           });
         }
@@ -3609,11 +3731,21 @@ function createDrainFrameGuard(args) {
     return buf;
   };
 }
-async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEncoder, reorderBuffer, assertNotAborted, onProgress, log, stats, abortSignal) {
+async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEncoder, reorderBuffer, assertNotAborted, onProgress, log, stats, abortSignal, risk) {
   let prev = null;
   const frameTime = (i) => i * job.config.fps.den / job.config.fps.num;
   const guard = createDrainFrameGuard({ log, stats, frameTime });
-  const guardFrame = (idx, buf) => guard(session, idx, buf);
+  const guardFrame = (item, buf) => item.trusted ? Promise.resolve(buf) : guard(session, item.idx, buf);
+  const captureRisk = async (idx) => {
+    await risk.open();
+    lastProgressAt = Date.now();
+    return raceAgainstStall(
+      risk.capture(idx, frameTime(idx)),
+      stallTimeoutMs - (Date.now() - lastProgressAt),
+      { session, frameIndex: idx, totalFrames, stallTimeoutMs },
+      abortSignal
+    );
+  };
   const stallTimeoutMs = resolveCaptureStallTimeoutMs();
   let lastProgressAt = Date.now();
   const captureWithStallGuard = (idx, promise) => raceAgainstStall(
@@ -3625,7 +3757,7 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   const drainPrev = async () => {
     if (!prev) return;
     assertNotAborted();
-    const buf = await guardFrame(prev.idx, await prev.encodeResult);
+    const buf = await guardFrame(prev, await prev.encodeResult);
     await reorderBuffer.waitForFrame(prev.idx);
     ensureFrameWritten(await currentEncoder.writeFrame(buf), prev.idx, currentEncoder);
     reorderBuffer.advanceTo(prev.idx + 1);
@@ -3645,7 +3777,7 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   const drainBatch = async (batch) => {
     for (const item of batch) {
       assertNotAborted();
-      const buf = await guardFrame(item.idx, await item.encodeResult);
+      const buf = await guardFrame(item, await item.encodeResult);
       await reorderBuffer.waitForFrame(item.idx);
       ensureFrameWritten(await currentEncoder.writeFrame(buf), item.idx, currentEncoder);
       reorderBuffer.advanceTo(item.idx + 1);
@@ -3663,7 +3795,7 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   };
   if (batchN > 1 && !session.onBeforeCapture) {
     const boundarySS = process.env.HF_FAST_CAPTURE_BOUNDARY_SS === "true";
-    const batchable = (f) => !session.staticFrames?.has(f) && !(boundarySS && session.clipBoundaryFrames?.has(f));
+    const batchable = (f) => !session.staticFrames?.has(f) && !(boundarySS && session.clipBoundaryFrames?.has(f)) && !risk?.frames.has(f);
     let prevBatch = [];
     let i = 0;
     while (i < totalFrames) {
@@ -3680,6 +3812,11 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
         );
         await drainBatch(prevBatch);
         prevBatch = results.map((r) => ({ idx: r.frameIndex, encodeResult: r.encodeResult }));
+      } else if (risk?.frames.has(i)) {
+        const buffer = await captureRisk(i);
+        await drainBatch(prevBatch);
+        prevBatch = [{ idx: i, encodeResult: Promise.resolve(buffer), trusted: true }];
+        i++;
       } else {
         const { encodeResult } = await captureWithStallGuard(
           i,
@@ -3695,6 +3832,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   }
   for (let i = 0; i < totalFrames; i++) {
     assertNotAborted();
+    if (risk?.frames.has(i)) {
+      const buffer = await captureRisk(i);
+      await drainPrev();
+      prev = { idx: i, encodeResult: Promise.resolve(buffer), trusted: true };
+      continue;
+    }
     const time = frameTime(i);
     const { encodeResult } = await captureWithStallGuard(
       i,
@@ -3941,6 +4084,24 @@ async function runCaptureStreamingStage(input) {
         prepareCaptureSessionForReuse(session, framesDir, videoInjector);
         probeSession = null;
       }
+      let riskSession = null;
+      const openRiskSession = async () => {
+        const opened = await createCaptureSession(
+          fileServer.url,
+          framesDir,
+          buildCaptureOptions(),
+          createRenderVideoFrameInjector(),
+          {
+            ...captureCfg,
+            useDrawElement: false,
+            staticFrameDedup: false,
+            enableBrowserPool: false
+          }
+        );
+        riskSession = opened;
+        await initializeSession(opened);
+        return opened;
+      };
       try {
         if (!session.isInitialized) {
           await initializeSession(session);
@@ -3955,6 +4116,7 @@ async function runCaptureStreamingStage(input) {
             blankDeterministicAccepts: 0,
             blankRecaptures: 0
           };
+          const riskFrames = session.deRiskFrames;
           await runWorkerEncodePipelineLoop(
             session,
             totalFrames,
@@ -3965,7 +4127,16 @@ async function runCaptureStreamingStage(input) {
             onProgress,
             log,
             deDrainStats,
-            abortSignal
+            abortSignal,
+            riskFrames && riskFrames.size > 0 ? {
+              frames: riskFrames,
+              // Opened on the first risk frame, in a browser of its own: pages sharing a
+              // browser share a compositor, which starves the drawElement page's paint events.
+              open: async () => {
+                riskSession ??= await openRiskSession();
+              },
+              capture: async (frameIndex, time) => (await captureFrameToBuffer(riskSession, frameIndex, time)).buffer
+            } : void 0
           );
         } else {
           const stallTimeoutMs = resolveCaptureStallTimeoutMs();
@@ -4003,6 +4174,7 @@ async function runCaptureStreamingStage(input) {
       } finally {
         lastBrowserConsole = session.browserConsoleBuffer;
         await closeCaptureSession(session);
+        if (riskSession) await closeCaptureSession(riskSession);
       }
     }
     const encodeFrom = job.progress;
@@ -4039,7 +4211,7 @@ async function runCaptureStreamingStage(input) {
 
 // src/services/render/stages/captureSegmentedStage.ts
 function segmentOutputPath(segmentDir, index) {
-  return join9(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
+  return join10(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
 }
 function segmentEncoderOptions(base, segment) {
   return {
@@ -4115,7 +4287,7 @@ async function captureSegment(ctx, segment) {
       path: segmentPath,
       // Recorded so resume can prove the file on disk is the one that
       // finished; absent only in unit tests, whose fake encoder writes none.
-      bytes: existsSync6(segmentPath) ? statSync2(segmentPath).size : 0
+      bytes: existsSync6(segmentPath) ? statSync3(segmentPath).size : 0
     });
     return encodeResult.durationMs;
   } finally {
@@ -4133,7 +4305,7 @@ var DEFAULT_DEPS = {
   // is invisible to a test that swaps the engine module after this file has
   // been evaluated (bun updates live bindings, not copies).
   closeSession: (session) => closeCaptureSession2(session),
-  removeFile: (path) => rmSync5(path, { force: true })
+  removeFile: (path) => rmSync6(path, { force: true })
 };
 function defaultSessionFactory(input) {
   let probeSession = input.probeSession;
@@ -4162,7 +4334,7 @@ function openSegmentedSessionReuse(input, session) {
 async function openSegmentedSession(input) {
   const captureCfg = input.cfg.forceScreenshot === input.plan.forceScreenshot ? input.cfg : { ...input.cfg, forceScreenshot: input.plan.forceScreenshot };
   const videoInjector = input.createRenderVideoFrameInjector();
-  const captureOptions = input.buildCaptureOptions();
+  const captureOptions = { ...input.buildCaptureOptions(), deFrameFallback: false };
   const ownBrowser = shouldDisableBrowserPoolForParallelWorker({
     parallel: (input.workerCount ?? 1) > 1
   });
@@ -4300,7 +4472,7 @@ async function runCaptureSegmentedStage(input) {
   const { log, dedupPerfs, assertNotAborted } = input;
   const deps = { ...DEFAULT_DEPS, ...input.deps };
   const segments = planSegments(input.totalFrames, input.segmentFrames);
-  const segmentDir = input.segmentDir ?? join9(input.workDir, "segments");
+  const segmentDir = input.segmentDir ?? join10(input.workDir, "segments");
   mkdirSync3(segmentDir, { recursive: true });
   const skip = input.completedSegments ?? /* @__PURE__ */ new Set();
   const pending = segments.filter((s) => !skip.has(s.index));
@@ -4371,10 +4543,83 @@ async function runCaptureSegmentedStage(input) {
   };
 }
 
+// src/services/render/renderEtaGuard.ts
+var RENDER_TOO_SLOW = "RENDER_TOO_SLOW";
+var ETA_MARGIN = 1.2;
+var MIN_SAMPLE_MS = 6e4;
+var MIN_SAMPLE_FRAMES = 3;
+var POLL_MS = 5e3;
+var RenderTooSlowError = class extends Error {
+  code = RENDER_TOO_SLOW;
+  // The producer server reads these off the error for the wire envelope.
+  // fallow-ignore-next-line unused-class-member
+  owner = "user";
+  // fallow-ignore-next-line unused-class-member
+  retryable = false;
+  publicMetadata;
+  constructor(stage, input) {
+    const { framesCompleted, totalFrames, msPerFrame, etaMs, maxRenderMs } = input;
+    super(
+      `render too slow: stage ${stage}, ${framesCompleted}/${totalFrames} frames, ${Math.round(msPerFrame)} ms/frame, ETA ${etaMs} ms exceeds maxRenderMs ${maxRenderMs}`
+    );
+    this.name = "RenderTooSlowError";
+    this.publicMetadata = { stage, framesCompleted, totalFrames, msPerFrame, etaMs, maxRenderMs };
+  }
+};
+function checkRenderEta(stage, input) {
+  const { maxRenderMs, elapsedMs, framesCompleted, totalFrames, msPerFrame } = input;
+  if (!maxRenderMs || maxRenderMs <= 0 || !(msPerFrame > 0)) return void 0;
+  const etaMs = Math.round(elapsedMs + (totalFrames - framesCompleted) * msPerFrame);
+  if (etaMs <= maxRenderMs * ETA_MARGIN) return void 0;
+  return new RenderTooSlowError(stage, { ...input, maxRenderMs, etaMs });
+}
+function createRateSampler() {
+  let base;
+  let lastFrames = 0;
+  return {
+    observe(done, at) {
+      if (done === 0 || done < lastFrames) base = void 0;
+      lastFrames = done;
+      if (done === 0) return void 0;
+      base ??= { at, frames: done };
+      const sampleMs = at - base.at;
+      const sampleFrames = done - base.frames;
+      if (sampleMs < MIN_SAMPLE_MS || sampleFrames < MIN_SAMPLE_FRAMES) return void 0;
+      return sampleMs / sampleFrames;
+    }
+  };
+}
+function startRenderEtaGuard(options) {
+  const { maxRenderMs, job, totalFrames, pipelineStartMs, onTooSlow, now = Date.now } = options;
+  if (!maxRenderMs || maxRenderMs <= 0) return () => {
+  };
+  const sampler = createRateSampler();
+  const stop = () => clearInterval(timer);
+  const timer = setInterval(() => {
+    const done = job.framesRendered ?? 0;
+    if (done >= totalFrames) return stop();
+    const at = now();
+    const msPerFrame = sampler.observe(done, at);
+    if (msPerFrame === void 0) return;
+    const error = checkRenderEta("capture", {
+      maxRenderMs,
+      elapsedMs: at - pipelineStartMs,
+      framesCompleted: done,
+      totalFrames,
+      msPerFrame
+    });
+    if (!error) return;
+    stop();
+    onTooSlow(error);
+  }, options.pollMs ?? POLL_MS);
+  timer.unref?.();
+  return stop;
+}
+
 // src/services/render/segmentManifest.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
 import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
 var MANIFEST_FILENAME = "segments.json";
 function computeSegmentPlanHash(input) {
@@ -4400,7 +4645,7 @@ function computeSegmentPlanHash(input) {
   return createHash2("sha256").update(ordered).digest("hex").slice(0, 16);
 }
 function segmentDirFor(projectRendersDir, planHash) {
-  return join10(projectRendersDir, ".hf-segments", planHash);
+  return join11(projectRendersDir, ".hf-segments", planHash);
 }
 function hasNumber(value, key) {
   return key in value && typeof Reflect.get(value, key) === "number";
@@ -4418,7 +4663,7 @@ function isManifest(value) {
   return Reflect.get(value, "version") === 1 && hasString(value, "planHash") && hasNumber(value, "totalFrames") && hasNumber(value, "segmentFrames") && Array.isArray(completed) && completed.every(isEntry);
 }
 function readSegmentManifest(segmentDir) {
-  const path = join10(segmentDir, MANIFEST_FILENAME);
+  const path = join11(segmentDir, MANIFEST_FILENAME);
   if (!existsSync7(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
@@ -4429,9 +4674,9 @@ function readSegmentManifest(segmentDir) {
 }
 function writeSegmentManifest(segmentDir, manifest) {
   mkdirSync4(segmentDir, { recursive: true });
-  const tmp = join10(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  const tmp = join11(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
   writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameWithRetry2(tmp, join10(segmentDir, MANIFEST_FILENAME));
+  renameWithRetry2(tmp, join11(segmentDir, MANIFEST_FILENAME));
 }
 async function probeSegmentFrameCount(path, probe) {
   try {
@@ -4449,7 +4694,7 @@ async function validateCompletedSegments(manifest, expectedHash, probeFrames) {
   if (manifest.planHash !== expectedHash) return ok;
   for (const entry of manifest.completed) {
     if (!existsSync7(entry.path)) continue;
-    const size = statSync3(entry.path).size;
+    const size = statSync4(entry.path).size;
     if (size <= 0 || size !== entry.bytes) continue;
     const frames = await probeFrames(entry.path);
     if (frames !== entry.endFrame - entry.startFrame) continue;
@@ -4543,7 +4788,7 @@ function resolveVideoCaptureBeyondViewport(videoCount) {
 }
 
 // src/services/render/captureCost.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { fpsToNumber as fpsToNumber5 } from "@hyperframes/core";
 import {
   calculateOptimalWorkers,
@@ -4788,7 +5033,7 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join11(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join12(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
@@ -4821,7 +5066,7 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join11(workDir, "capture-calibration-screenshot"),
+          join12(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
@@ -5253,14 +5498,14 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
 
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash5 } from "node:crypto";
 import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join13, dirname as dirname6, resolve as resolve6, basename as basename4, relative as relative2 } from "path";
+import { join as join14, dirname as dirname6, resolve as resolve6, basename as basename4, relative as relative2 } from "path";
 import { parseHTML as parseHTML4 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
@@ -5487,8 +5732,8 @@ import {
 
 // src/services/animatedGifPrep.ts
 import { createHash as createHash4 } from "node:crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync6, statSync as statSync4 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join12, resolve as resolve5 } from "node:path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync7, statSync as statSync5 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join13, resolve as resolve5 } from "node:path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import { parseAnimatedGifMetadata } from "@hyperframes/core";
 import { DEFAULT_VP9_CPU_USED, runFfmpeg as runFfmpeg2, renameWithRetry as renameWithRetry3 } from "@hyperframes/engine";
@@ -5537,7 +5782,7 @@ function resolveGifSourcePath(src, options) {
 }
 function isUsableFile(path) {
   try {
-    const stat = statSync4(path);
+    const stat = statSync5(path);
     return stat.isFile() && stat.size > 0;
   } catch {
     return false;
@@ -5672,10 +5917,10 @@ async function ensurePreparedWebm(input) {
       if (!isUsableFile(input.cachePath)) {
         renameWithRetry3(tmpPath, input.cachePath);
       } else {
-        rmSync6(tmpPath, { force: true });
+        rmSync7(tmpPath, { force: true });
       }
     } catch (error) {
-      rmSync6(tmpPath, { force: true });
+      rmSync7(tmpPath, { force: true });
       throw error;
     }
   }
@@ -5731,7 +5976,7 @@ function replaceImageWithVideo(input) {
   return video;
 }
 async function prepareAnimatedGifInputs(html, options) {
-  const outputDir = options.outputDir ?? join12(options.downloadDir, PREPARED_GIF_SUBDIR);
+  const outputDir = options.outputDir ?? join13(options.downloadDir, PREPARED_GIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_GIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const { document: document2 } = parseHTML3(html);
@@ -5753,8 +5998,8 @@ async function prepareAnimatedGifInputs(html, options) {
     const { loopIterations, padSeconds } = resolvePreparedPlayback(metadata, loop, windowSeconds);
     const hash = computePreparedGifHash(bytes, loopIterations, padSeconds);
     const filename = `${CACHE_SCHEMA}-${hash.slice(0, 24)}.webm`;
-    const cachePath = join12(cacheDir, filename);
-    const outputPath = join12(outputDir, filename);
+    const cachePath = join13(cacheDir, filename);
+    const outputPath = join13(outputDir, filename);
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     await ensurePreparedWebm({
       sourcePath,
@@ -6105,10 +6350,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);
@@ -6168,7 +6409,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     }
   } else {
     filePath = decodedUrlPath(src);
-    if (!filePath.startsWith("/")) filePath = join13(baseDir, filePath);
+    if (!filePath.startsWith("/")) filePath = join14(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
   if (!isHttpUrl(filePath) && !existsSync10(filePath)) {
@@ -6788,7 +7029,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join13(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -6803,7 +7044,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join13(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -6819,7 +7060,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join13(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -6954,7 +7195,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     processed,
-    join13(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -7121,7 +7362,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(
@@ -7235,7 +7475,6 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     renderModeHints,
     hasShaderTransitions,
     usesThreeDTransforms,
-    usesMixBlendMode,
     hasAncestorBackgroundImage
   };
 }
@@ -7621,7 +7860,7 @@ async function runCompileStage(input) {
     abortSignal
   } = input;
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join14(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join15(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
@@ -7629,7 +7868,7 @@ async function runCompileStage(input) {
     variables: input.variables,
     urlByAbsentLocalPath: input.urlByAbsentLocalPath,
     pageMotionBlur: input.pageMotionBlur,
-    animatedGifCacheDir: cfg.extractCacheDir ? join14(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join15(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -7642,13 +7881,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";
@@ -7692,7 +7924,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join14(workDir, "compiled"),
+    compiledDir: join15(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -7737,7 +7969,7 @@ async function runCompileStage(input) {
 }
 
 // src/services/render/stages/probeStage.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
   closeCaptureSession as closeCaptureSession4,
@@ -7929,7 +8161,7 @@ async function runProbeStage(input) {
       });
       fileServer = await createFileServer({
         projectDir,
-        compiledDir: join15(workDir, "compiled"),
+        compiledDir: join16(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM],
         fps: job.config.fps
@@ -7957,7 +8189,7 @@ async function runProbeStage(input) {
           log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join15(workDir, "probe"),
+            join16(workDir, "probe"),
             captureOpts,
             null,
             probeCfg
@@ -8042,7 +8274,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join15(workDir, "probe-screenshot"),
+            join16(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -8078,7 +8310,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join15(workDir, "downloads")
+            join16(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -8269,7 +8501,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join15(workDir, "compiled"),
+      compiledDir: join16(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -8434,7 +8666,7 @@ function validateDistributedDuration(input) {
 
 // src/services/render/stages/extractVideosStage.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import {
   classifyVideoExtractionError,
   createFrameLookupTable,
@@ -8754,14 +8986,14 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join16(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join17(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: job.config.hdrMode === "force-sdr",
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce",
         deferRangeExtraction,
-        contentKeyedDirs: [join16(compiledDir, REMOTE_MEDIA_SUBDIR)],
+        contentKeyedDirs: [join17(compiledDir, REMOTE_MEDIA_SUBDIR)],
         urlByAbsentLocalPath
       },
       abortSignal,
@@ -8828,8 +9060,8 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { join as join18 } from "node:path";
-import { rmSync as rmSync8 } from "node:fs";
+import { join as join19 } from "node:path";
+import { rmSync as rmSync9 } from "node:fs";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -8838,8 +9070,8 @@ import {
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync7 } from "node:fs";
-import { dirname as dirname7, join as join17 } from "node:path";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
+import { dirname as dirname7, join as join18 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -9042,7 +9274,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) rmSync7(path, { force: true });
+    for (const path of plan2.cleanupPaths) rmSync8(path, { force: true });
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -9079,19 +9311,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 = mkdtempSync3(join17(dirname7(input.audioPath), ".true-peak-"));
-    const correctedPath = join17(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync3(join18(dirname7(input.audioPath), ".true-peak-"));
+    const correctedPath = join18(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);
@@ -9108,7 +9342,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,
@@ -9140,7 +9378,7 @@ async function enforceAacTruePeak(input) {
       )}`
     };
   } finally {
-    if (scratchDir) rmSync7(scratchDir, { recursive: true, force: true });
+    if (scratchDir) rmSync8(scratchDir, { recursive: true, force: true });
   }
 }
 function failResult(outputPath, target, source, error) {
@@ -9287,7 +9525,7 @@ function assertAudioNotInterrupted(failures) {
 }
 async function runAudioStage(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join18(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join19(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   try {
     const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
@@ -9307,7 +9545,7 @@ async function runAudioStage(input) {
     }
     return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
   } finally {
-    rmSync8(pcmSourcePath, { force: true });
+    rmSync9(pcmSourcePath, { force: true });
   }
 }
 async function mixAudioForDelivery(input, duration, pcmSourcePath) {
@@ -9325,7 +9563,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join18(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join19(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -9336,7 +9574,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join18(workDir, "audio-work"),
+        join19(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -9405,7 +9643,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 
 // src/services/render/stages/captureStage.ts
 import { existsSync as existsSync12, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -9478,13 +9716,13 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   if (!existsSync12(workDir)) return total;
   for (const attempt of readdirSync3(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join19(workDir, attempt));
+      total += sampleDirectoryBytes(join20(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join19(workDir, attempt);
+    const attemptDir = join20(workDir, attempt);
     for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join19(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join20(attemptDir, name));
     }
   }
   return total;
@@ -9544,7 +9782,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,
@@ -9771,7 +10009,7 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 
 // src/services/render/stages/captureHdrStage.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -9843,7 +10081,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -9968,7 +10206,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join20(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join21(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -10000,7 +10238,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -10014,7 +10252,7 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname8, join as join21 } from "node:path";
+import { dirname as dirname8, join as join22 } from "node:path";
 import { createRequire } from "node:module";
 import { existsSync as existsSync13 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
@@ -10028,9 +10266,9 @@ function resolveWorkerEntry(explicit) {
     return { path: override, isTs };
   }
   const moduleDir = dirname8(fileURLToPath3(import.meta.url));
-  const jsPath = join21(moduleDir, "shaderTransitionWorker.js");
+  const jsPath = join22(moduleDir, "shaderTransitionWorker.js");
   if (existsSync13(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join21(moduleDir, "shaderTransitionWorker.ts");
+  const tsPath = join22(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -10398,7 +10636,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join22(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join23(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -10567,7 +10805,8 @@ async function runCaptureHdrStage(input) {
       width,
       height,
       abortSignal,
-      hdrDiagnostics
+      hdrDiagnostics,
+      maxResidentWindows: Math.max(1, workerCount) + 1
     });
     releaseHdrExtractionReservation = extracted.releaseReservation;
     for (const [id, source] of extracted.sources) hdrVideoFrameSources.set(id, source);
@@ -10585,7 +10824,7 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join23(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join24(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync14(debugDumpDir)) {
         mkdirSync7(debugDumpDir, { recursive: true });
       }
@@ -10745,12 +10984,12 @@ import {
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
   readFileSync as readFileSync7,
-  rmSync as rmSync9,
-  statSync as statSync5,
+  rmSync as rmSync10,
+  statSync as statSync6,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname9, join as join24 } from "node:path";
+import { dirname as dirname9, join as join25 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
@@ -10875,7 +11114,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync15(outputPath) ? statSync5(outputPath).size : 0;
+    const fileSize = existsSync15(outputPath) ? statSync6(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -10884,7 +11123,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync9(input.palettePath, { force: true });
+    rmSync10(input.palettePath, { force: true });
   }
 }
 function startEncodeProgress(job, stage, onProgress) {
@@ -10959,7 +11198,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve12) => wake = resolve12);
       }
       if (signal.aborted) return;
-      const mergedPath = join24(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join25(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -11042,11 +11281,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join24(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync3(join24(framesDir, name), dst);
+      const dst = join25(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync3(join25(framesDir, name), dst);
     });
     if (hasAudio && audioOutputPath && existsSync15(audioOutputPath)) {
-      copyFileSync3(audioOutputPath, join24(outputPath, MIXED_AUDIO_FILENAME2));
+      copyFileSync3(audioOutputPath, join25(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -11066,7 +11305,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join24(dirname9(videoOnlyPath), "gif-palette.png"),
+      palettePath: join25(dirname9(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -11279,9 +11518,9 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join25(current, name);
+      const full = join26(current, name);
       try {
-        const st = statSync6(full);
+        const st = statSync7(full);
         if (st.isDirectory()) {
           stack.push(full);
         } else if (st.isFile()) {
@@ -11428,8 +11667,8 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join25(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync16(framePath) || statSync6(framePath).size <= 8;
+    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync16(framePath) || statSync7(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -11451,7 +11690,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, ran
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join25(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: join26(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -11479,8 +11718,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32" || platform2 === "darwin") return join25(systemTempDir, "hf-render-");
-  return join25(dirname10(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join26(systemTempDir, "hf-render-");
+  return join26(dirname10(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -11512,7 +11751,7 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join25(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync16(framePath)) captured++;
   }
   return captured;
@@ -11538,7 +11777,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join25(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join26(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -11995,7 +12234,10 @@ function resolveDeShortBand(args) {
   return args.bandOpen ? "applied" : "skipped_elements";
 }
 function shouldPreferSingleWorkerDrawElement(args) {
-  return args.workerCount > 1 && typeof args.requestedWorkers !== "number" && args.useDrawElement && !args.deCompileGate && !args.forceScreenshot && outputUsesH264Pipeline(args.outputFormat) && args.minFrames > 0 && args.totalFrames >= args.minFrames && args.singleWorkerStreamingOk && !args.layeredOrEffectRoute && !args.supersampling && !args.probeDeGated && !args.experimentalParallelDeOptIn;
+  return args.workerCount > 1 && args.useDrawElement && !args.deCompileGate && !args.forceScreenshot && outputUsesH264Pipeline(args.outputFormat) && args.minFrames > 0 && args.totalFrames >= args.minFrames && args.singleWorkerStreamingOk && !args.layeredOrEffectRoute && !args.supersampling && !args.probeDeGated && !args.experimentalParallelDeOptIn;
+}
+function probeNeedsScreenshotFrames(session) {
+  return (session?.deRiskFrames?.size ?? 0) > 0;
 }
 function isProbeDeGated(session) {
   return session !== null && session.captureMode !== "drawelement" && !session.deInitDeferred;
@@ -12131,17 +12373,17 @@ function deVerifyFallbackTelemetry(err) {
 }
 function resolveRenderDebugDir() {
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve7(process.env.PRODUCER_RENDERS_DIR, "..") : resolve7(dirname10(fileURLToPath4(import.meta.url)), "../..");
-  return join25(producerRoot, ".debug");
+  return join26(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
   const outputDir = dirname10(outputPath);
   if (!existsSync16(outputDir)) mkdirSync9(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join25(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const workDir = job.config.debug ? join26(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join25(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join26(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -12155,7 +12397,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1, leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync10(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -12186,7 +12428,9 @@ async function executeRenderPipeline(input) {
   const log = execution.logger;
   const eventPublisher = execution.events;
   const onProgress = execution.onProgress;
-  const executionSignal = execution.signal;
+  const tooSlow = new AbortController();
+  let tooSlowError;
+  const executionSignal = job.config.maxRenderMs ? AbortSignal.any([tooSlow.signal, ...execution.signal ? [execution.signal] : []]) : execution.signal;
   let fileServer = null;
   let probeSession = null;
   let lastBrowserConsole = [];
@@ -12199,7 +12443,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join25(workDir, "perf-summary.json");
+  const perfOutputPath = join26(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -12301,15 +12545,15 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join25(projectDir, entryFile);
+    let htmlPath = join26(projectDir, entryFile);
     if (!existsSync16(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync8(htmlPath, "utf-8");
     if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join25(workDir, "standalone-entry.html");
-      const projectIndexPath = join25(projectDir, "index.html");
+      const wrapperPath = join26(workDir, "standalone-entry.html");
+      const projectIndexPath = join26(projectDir, "index.html");
       if (!existsSync16(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
@@ -12472,7 +12716,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join25(workDir, "compiled");
+    const compiledDir = join26(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -12606,7 +12850,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join25(workDir, "compiled"),
+          compiledDir: join26(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -12624,7 +12868,7 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join25(workDir, "captured-frames");
+    const framesDir = join26(workDir, "captured-frames");
     if (!existsSync16(framesDir)) mkdirSync9(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
@@ -12673,6 +12917,7 @@ async function executeRenderPipeline(input) {
       // Probe-resolved duration: drawElement self-verification derives its
       // sample frame indices from this so they land inside the drained range.
       compositionDurationSeconds: job.duration,
+      deFrameFallback: true,
       requiresWebGpu: compositionRequiresWebGpu2(compiled.html),
       // Live route for Chrome memory (spec §5 Phase −1). The aggregate route
       // through CapturePerfSummary only exists on success; a mid-capture
@@ -12728,7 +12973,6 @@ async function executeRenderPipeline(input) {
     const WOULD_RESOLVE_MULTI_WORKER = 2;
     const deInversionArgs = {
       workerCount: WOULD_RESOLVE_MULTI_WORKER,
-      requestedWorkers: job.config.workers,
       useDrawElement: cfg.useDrawElement,
       deCompileGate,
       forceScreenshot: captureForceScreenshot,
@@ -12774,7 +13018,7 @@ async function executeRenderPipeline(input) {
       minFrames: deParallelMinFrames,
       layeredOrEffectRoute: hasHdrContent || compiled.hasShaderTransitions,
       supersampling: deviceScaleFactor !== 1,
-      probeDeGated: isProbeDeGated(probeSession),
+      probeDeGated: isProbeDeGated(probeSession) || probeNeedsScreenshotFrames(probeSession),
       experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true" || process.env.HF_DE_PARALLEL_STREAM === "true",
       routerEnabled: deParallelRouterEnabled,
       // Router pins 3 workers for the streaming path; don't pin when a
@@ -12816,6 +13060,8 @@ async function executeRenderPipeline(input) {
         deInversionEligible = false;
         deParallelRouterEligible = false;
         deShortBand = void 0;
+      } else if (probeNeedsScreenshotFrames(probeSession)) {
+        deParallelRouterEligible = false;
       }
     }
     const deProbeGateReason = isProbeDeGated(probeSession) ? probeSession.deGateReason : void 0;
@@ -12934,7 +13180,7 @@ async function executeRenderPipeline(input) {
     } else if (deInversionEligible && workerCount > 1) {
       deWorkerInversion = "inverted";
       log.info(
-        `[Render] Fast capture: single-worker drawElement streaming preferred over ${workerCount}-worker screenshot capture (${totalFrames} frames >= ${deInversionEffectiveMinFrames}; verified path, measured faster at every worker count). Set HF_DE_SINGLE_MIN_FRAMES=0 or --workers N to override.`
+        `[Render] Fast capture: single-worker drawElement streaming preferred over ${workerCount}-worker screenshot capture (${totalFrames} frames >= ${deInversionEffectiveMinFrames}; verified path, measured faster at every worker count). Set HF_DE_SINGLE_MIN_FRAMES=0 to override.`
       );
       workerCount = 1;
     }
@@ -12978,6 +13224,27 @@ async function executeRenderPipeline(input) {
       deWorkerInversion: deWorkerInversion ?? "none",
       deParallelRouter: deParallelRouter ?? "none"
     });
+    const calibratedTooSlow = checkRenderEta("capture_calibration", {
+      maxRenderMs: job.config.maxRenderMs,
+      elapsedMs: Date.now() - pipelineStart,
+      framesCompleted: 0,
+      totalFrames,
+      msPerFrame: (captureCalibration?.estimate.p95Ms ?? 0) / workerCount
+    });
+    if (calibratedTooSlow) throw calibratedTooSlow;
+    execution.defer(
+      "stop render ETA guard",
+      startRenderEtaGuard({
+        maxRenderMs: job.config.maxRenderMs,
+        job,
+        totalFrames,
+        pipelineStartMs: pipelineStart,
+        onTooSlow: (error) => {
+          tooSlowError = error;
+          tooSlow.abort(error);
+        }
+      })
+    );
     let useStreamingEncode = shouldUseStreamingEncode(
       cfg,
       outputFormat,
@@ -12986,7 +13253,8 @@ async function executeRenderPipeline(input) {
       deParallelStreamForced
     );
     const deParallelStreamVerified = (deParallelStreamForced || process.env.HF_DE_PARALLEL_STREAM === "true") && useStreamingEncode && workerCount > 1;
-    if (shouldClampDefaultDrawElement({
+    const routeDropsScreenshotFrames = cfg.useDrawElement && probeNeedsScreenshotFrames(probeSession) && (!useStreamingEncode || workerCount !== 1);
+    if (routeDropsScreenshotFrames || shouldClampDefaultDrawElement({
       useDrawElement: cfg.useDrawElement,
       fastCaptureExplicitOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true",
       useStreamingEncode,
@@ -13071,7 +13339,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join25(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join26(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -13317,7 +13585,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join25(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join26(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -13332,10 +13600,10 @@ async function executeRenderPipeline(input) {
             });
           }
           if (completedSegments.size === 0) {
-            rmSync10(segmentDir, { recursive: true, force: true });
+            rmSync11(segmentDir, { recursive: true, force: true });
           }
         } else {
-          rmSync10(segmentDir, { recursive: true, force: true });
+          rmSync11(segmentDir, { recursive: true, force: true });
         }
         const segmentManifest = readSegmentManifest(segmentDir) ?? {
           version: 1,
@@ -13416,7 +13684,7 @@ async function executeRenderPipeline(input) {
           );
           updateCaptureObservability({ segmentRetries: segmentedRes.segmentRetries });
           if (job.config.keepSegments !== true) {
-            rmSync10(segmentDir, { recursive: true, force: true });
+            rmSync11(segmentDir, { recursive: true, force: true });
           }
         } else {
           capturePlan = replanAfterFailure(capturePlan, { kind: "streaming_unavailable" });
@@ -13685,7 +13953,7 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement capture failed; retrying with a fresh screenshot session"
           );
-          rmSync10(framesDir, { recursive: true, force: true });
+          rmSync11(framesDir, { recursive: true, force: true });
           mkdirSync9(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
@@ -13872,7 +14140,7 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync16(stagedOutputPath)) {
-        const debugOutput = join25(workDir, `output${videoExt}`);
+        const debugOutput = join26(workDir, `output${videoExt}`);
         copyFileSync4(stagedOutputPath, debugOutput);
       }
     }
@@ -13883,8 +14151,9 @@ async function executeRenderPipeline(input) {
     job.outputPath = outputPath;
     updateJobStatus(job, "complete", "Render complete", 100, onProgress);
     await eventPublisher.flush();
-  } catch (error) {
-    if (error instanceof RenderCancelledError || executionSignal?.aborted) {
+  } catch (caught) {
+    const error = tooSlowError ?? caught;
+    if (!tooSlowError && (error instanceof RenderCancelledError || executionSignal?.aborted)) {
       job.error = error instanceof Error ? error.message : "render_cancelled";
       updateJobStatus(job, "cancelled", "Render cancelled", job.progress, onProgress);
       await eventPublisher.flush();
@@ -14001,10 +14270,10 @@ import {
   existsSync as existsSync21,
   linkSync,
   mkdirSync as mkdirSync13,
-  rmSync as rmSync12,
+  rmSync as rmSync13,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { extname as extname6, isAbsolute as isAbsolute3, join as join33, relative as relative5, sep as sep2 } from "node:path";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join34, relative as relative5, sep as sep2 } from "node:path";
 import {
   fpsToNumber as fpsToNumber10,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -14019,7 +14288,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
@@ -14029,7 +14298,7 @@ import {
 
 // src/services/distributed/chunkFrames.ts
 import { existsSync as existsSync18, readdirSync as readdirSync6 } from "node:fs";
-import { extname as extname4, join as join27 } from "node:path";
+import { extname as extname4, join as join28 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
   createFrameLookupTable as createFrameLookupTable2,
@@ -14039,7 +14308,7 @@ import {
 
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname11, join as join26 } from "node:path";
+import { dirname as dirname11, join as join27 } from "node:path";
 import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
@@ -14055,7 +14324,7 @@ function isPlanAudioArtifactPath(path) {
 }
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join26(planDir, name);
+    const candidate = join27(planDir, name);
     if (existsSync17(candidate)) return candidate;
   }
   return null;
@@ -14315,7 +14584,7 @@ function readProducerVersion() {
   const startDir = dirname11(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join26(current, "package.json");
+    const candidate = join27(current, "package.json");
     if (existsSync17(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
@@ -14369,7 +14638,7 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join27(planDir, "video-frames", v.videoId);
+    const outputDir = join28(planDir, "video-frames", v.videoId);
     if (!existsSync18(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
@@ -14388,7 +14657,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
       if (!frameName) continue;
       const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
       const frameIndex = frameNumber === null ? i : frameNumber - 1;
-      framePaths.set(frameIndex, join27(outputDir, frameName));
+      framePaths.set(frameIndex, join28(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -14478,14 +14747,14 @@ async function extractDeferredVideoFramesForChunk(input) {
   const shown = shownDeferredFrameIndexes(input.planVideos, input.frames, input.fps);
   return Promise.all(
     deferred.map(async (video) => {
-      const outputDir = join27(input.outputRoot, video.videoId);
+      const outputDir = join28(input.outputRoot, video.videoId);
       const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
       if (indexes.length === 0) {
         return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
       }
       const range = video.deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
-      const sourcePath = remoteUrl ?? join27(input.planDir, ...range.sourcePath.split("/"));
+      const sourcePath = remoteUrl ?? join28(input.planDir, ...range.sourcePath.split("/"));
       if (remoteUrl === void 0 && !existsSync18(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
@@ -14534,12 +14803,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join28(workDir, "frame-cost-video-frames"),
+      outputRoot: join29(workDir, "frame-cost-video-frames"),
       cfg: input.cfg
     })
   ];
   const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
-  const compiledDir = join28(planDir, "compiled");
+  const compiledDir = join29(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -14551,7 +14820,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join28(workDir, "frame-cost"),
+      join29(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -14609,6 +14878,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;
@@ -14637,7 +14918,7 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 
 // src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join29, relative as relative3, resolve as resolve8 } from "node:path";
+import { join as join30, relative as relative3, resolve as resolve8 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -14736,7 +15017,7 @@ function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILI
 
 // src/services/render/stages/planHash.ts
 import { createHash as createHash6 } from "node:crypto";
-import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "node:fs";
+import { closeSync as closeSync4, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "node:fs";
 var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
 var FIELD_DELIMITER = Buffer.from([0]);
 function computePlanHash(input) {
@@ -14802,7 +15083,7 @@ function sha256File(path) {
       if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
     } while (bytesRead > 0);
   } finally {
-    closeSync5(fd);
+    closeSync4(fd);
   }
   return hash.digest("hex");
 }
@@ -14855,7 +15136,7 @@ function listPlanFiles(planDir) {
   function walk(dir) {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join29(dir, entry.name);
+      const full = join30(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -14896,15 +15177,15 @@ var PLAN_REMOTE_FILES_RELATIVE_PATH = "meta/remote-files.json";
 function writePlanRemoteFiles(planDir, files) {
   if (files.length === 0) return;
   const sorted = [...files].sort((a, b) => a.path < b.path ? -1 : 1);
-  writeFileSync6(join29(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync6(join30(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join29(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  const path = join30(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
   return existsSync19(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join29(planDir, "plan.json");
-  const encoderJsonPath = join29(planDir, "meta", "encoder.json");
+  const planJsonPath = join30(planDir, "plan.json");
+  const encoderJsonPath = join30(planDir, "meta", "encoder.json");
   if (!existsSync19(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
@@ -14941,18 +15222,18 @@ async function freezePlan(input) {
   if (!existsSync19(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join29(planDir, "meta");
+  const metaDir = join30(planDir, "meta");
   if (!existsSync19(metaDir)) mkdirSync10(metaDir, { recursive: true });
   writeFileSync6(
-    join29(metaDir, "composition.json"),
+    join30(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
     "utf-8"
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync6(join29(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync6(join29(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync6(join30(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync6(join30(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -14976,7 +15257,7 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join29(planDir, "plan.json");
+  const planJsonPath = join30(planDir, "plan.json");
   writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
@@ -15018,16 +15299,16 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync6, existsSync as existsSync20, ftruncateSync, mkdirSync as mkdirSync12, openSync as openSync5, readFileSync as readFileSync11 } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync20, ftruncateSync, mkdirSync as mkdirSync12, openSync as openSync5, readFileSync as readFileSync11 } from "node:fs";
 import { writeFileSync as writeFileSync7, writeSync } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join32 } 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 mkdirSync11, mkdtempSync as mkdtempSync4, rmSync as rmSync11 } from "node:fs";
+import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, rmSync as rmSync12 } from "node:fs";
 import { open } from "node:fs/promises";
 import { renameWithRetry as renameWithRetry5 } from "@hyperframes/engine";
-import { dirname as dirname12, join as join30 } from "node:path";
+import { dirname as dirname12, join as join31 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -15393,16 +15674,16 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
   const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
   mkdirSync11(dirname12(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join30(workDir, "out.mp4"));
+  const out = createWriteStream(join31(workDir, "out.mp4"));
   try {
     out.write(header);
     for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameWithRetry5(join30(workDir, "out.mp4"), outputPath);
+    renameWithRetry5(join31(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
-    rmSync11(workDir, { recursive: true, force: true });
+    rmSync12(workDir, { recursive: true, force: true });
   }
 }
 
@@ -15493,7 +15774,7 @@ async function writeChunkAudioSlices(input) {
   });
   const bytes = readFileSync11(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync12(join31(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync12(join32(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -15501,17 +15782,17 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync7(join31(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync7(join32(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync7(join31(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync7(join31(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  writeFileSync7(join32(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync7(join32(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
-  const layoutPath = join31(planDir, SLICE_LAYOUT);
+  const layoutPath = join32(planDir, SLICE_LAYOUT);
   if (!existsSync20(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
-  const frame = readFileSync11(join31(planDir, SLICE_FRAME));
+  const frame = readFileSync11(join32(planDir, SLICE_FRAME));
   const fd = openSync5(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -15524,12 +15805,12 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync11(join31(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync11(join32(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
   } finally {
-    closeSync6(fd);
+    closeSync5(fd);
   }
   return scratchPath;
 }
@@ -15580,7 +15861,7 @@ async function muxChunkWithAudio(input) {
 // src/services/distributed/planSize.ts
 import { createHash as createHash7 } from "node:crypto";
 import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "node:fs";
-import { extname as extname5, join as join32, relative as relative4 } from "node:path";
+import { extname as extname5, join as join33, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -15692,7 +15973,7 @@ function walkRegularFiles(dir, visit) {
     return;
   }
   for (const entry of entries) {
-    const full = join32(dir, entry.name);
+    const full = join33(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -15904,13 +16185,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join33("meta", "composition.json"),
-  join33("meta", "encoder.json"),
-  join33("meta", "chunks.json")
+  join34("meta", "composition.json"),
+  join34("meta", "encoder.json"),
+  join34("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync12(join33(planDir, relativePath), { force: true });
+    rmSync13(join34(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -15929,7 +16210,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");
@@ -16052,19 +16336,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join33(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join34(input.planDir, "video-frames", stagedRel);
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync21(join33(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync21(join34(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
       result = `video-sources/${shipped.size}${extname6(current)}`;
-      const destination = join33(input.planDir, ...result.split("/"));
-      mkdirSync13(join33(input.planDir, "video-sources"), { recursive: true });
+      const destination = join34(input.planDir, ...result.split("/"));
+      mkdirSync13(join34(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -16113,14 +16397,14 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join33(projectDir, entryFile);
+  const htmlPath = join34(projectDir, entryFile);
   if (!existsSync21(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join33(planDir, ".plan-work");
-  rmSync12(workDir, { recursive: true, force: true });
+  const workDir = join34(planDir, ".plan-work");
+  rmSync13(workDir, { recursive: true, force: true });
   mkdirSync13(workDir, { recursive: true });
-  const compiledDir = join33(workDir, "compiled");
+  const compiledDir = join34(workDir, "compiled");
   mkdirSync13(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -16134,10 +16418,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join33(planDir, "compiled");
+  const finalCompiledDir = join34(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join33(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join34(projectDir, ...rel.split("/"));
   for (const [, file] of remoteFiles) {
     declareContentAddressedUrl(file.url, file.sha256);
     if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
@@ -16323,17 +16607,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   let stageStarted = Date.now();
   const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  const stagedVideoFrames = join33(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join33(planDir, "video-frames");
-  if (existsSync21(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join33(planDir, "video-sources");
-  rmSync12(videoSourcesDir, { recursive: true, force: true });
+  const stagedVideoFrames = join34(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join34(planDir, "video-frames");
+  if (existsSync21(videoFramesDst)) rmSync13(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join34(planDir, "video-sources");
+  rmSync13(videoSourcesDir, { recursive: true, force: true });
   if (existsSync21(stagedVideoFrames)) {
     renameWithRetry6(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync13(videoFramesDst, { recursive: true });
   }
-  if (existsSync21(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync21(finalCompiledDir)) rmSync13(finalCompiledDir, { recursive: true, force: true });
   renameWithRetry6(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -16363,7 +16647,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync13(join33(planDir, "meta"), { recursive: true });
+  mkdirSync13(join34(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -16373,7 +16657,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }))
   );
   writeFileSync8(
-    join33(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join34(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -16452,7 +16736,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join33(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  const planAudioPath = join34(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync21(audioResult.audioOutputPath)) {
     renameWithRetry6(audioResult.audioOutputPath, planAudioPath);
   }
@@ -16501,7 +16785,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync12(workDir, { recursive: true, force: true });
+    rmSync13(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -16876,6 +17160,7 @@ function assertRequestOptionScalars(options) {
   assertOptionalInteger(options, "gifLoop");
   assertOptionalInteger(options, "hlsSegmentSeconds", 1);
   assertOptionalInteger(options, "workers", 1);
+  assertOptionalInteger(options, "maxRenderMs");
   assertOptionalInteger(options, "crf");
   for (const field of ["useGpu", "debug", "outputResolutionAspectAgnostic"]) {
     assertOptionalBoolean(options, field);
@@ -17072,13 +17357,13 @@ import {
 import {
   existsSync as existsSync24,
   mkdirSync as mkdirSync14,
-  statSync as statSync8,
+  statSync as statSync9,
   mkdtempSync as mkdtempSync5,
   writeFileSync as writeFileSync9,
-  rmSync as rmSync13,
+  rmSync as rmSync14,
   createReadStream as createReadStream5
 } from "node:fs";
-import { resolve as resolve10, dirname as dirname14, join as join36 } from "node:path";
+import { resolve as resolve10, dirname as dirname14, join as join37 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -17091,13 +17376,13 @@ import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engi
 import {
   existsSync as existsSync22,
   readFileSync as readFileSync12,
-  statSync as statSync7,
+  statSync as statSync8,
   openSync as openSync6,
-  fstatSync as fstatSync4,
-  closeSync as closeSync7,
+  fstatSync as fstatSync3,
+  closeSync as closeSync6,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve9, join as join34, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
+import { resolve as resolve9, join as join35, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -17131,19 +17416,19 @@ function readEntryHtml(filePath) {
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync7(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync8(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
-    if (!fstatSync4(fd).isFile()) return null;
+    if (!fstatSync3(fd).isFile()) return null;
     return readFileSync12(fd, "utf-8");
   } finally {
-    closeSync7(fd);
+    closeSync6(fd);
   }
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve9(projectDir);
-  if (!existsSync22(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+  if (!existsSync22(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -17165,7 +17450,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join35(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -17211,7 +17496,7 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname13, join as join35 } from "node:path";
+import { dirname as dirname13, join as join36 } from "node:path";
 import { existsSync as existsSync23 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -17287,7 +17572,7 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname13(fileURLToPath6(import.meta.url));
-  const candidates = [join35(here, "healthWorkerThread.js"), join35(here, "healthWorkerThread.ts")];
+  const candidates = [join36(here, "healthWorkerThread.js"), join36(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync23(candidate)) return candidate;
   }
@@ -17308,7 +17593,8 @@ var SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
   "INVALID_VIDEO_METADATA",
   "VIDEO_SOURCE_UNRENDERABLE",
   "VIDEO_EXTRACTION_FAILED",
-  "ENCODER_INTERRUPTED"
+  "ENCODER_INTERRUPTED",
+  "RENDER_TOO_SLOW"
 ]);
 function extractSafeRenderErrorCode(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
@@ -17367,6 +17653,7 @@ function parseRenderOptions(body) {
   const fps = parseServerFps(body.fps);
   const quality = parseServerQuality(body.quality);
   const workers = typeof body.workers === "number" ? body.workers : void 0;
+  const maxRenderMs = typeof body.maxRenderMs === "number" ? body.maxRenderMs : void 0;
   const useGpu = body.gpu === true;
   const debug = body.debug === true;
   const strictness = body.bestEffort === false ? "strict" : "best-effort";
@@ -17382,6 +17669,7 @@ function parseRenderOptions(body) {
     fps,
     quality,
     workers,
+    maxRenderMs,
     crf,
     videoBitrate,
     useGpu,
@@ -17415,6 +17703,7 @@ function buildRenderJobConfig(input, outputPath, log) {
       quality: input.quality,
       format: input.format ?? "mp4",
       workers: input.workers,
+      maxRenderMs: input.maxRenderMs,
       crf: input.crf,
       videoBitrate: input.videoBitrate,
       useGpu: input.useGpu,
@@ -17441,6 +17730,9 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
 function validateRenderOverrides(body) {
   const encoder = parseEncoderOptions(body, parseServerFormat(body.format) ?? "mp4");
   if (!encoder.ok) return encoder.error;
+  if (body.maxRenderMs !== void 0 && (typeof body.maxRenderMs !== "number" || !Number.isInteger(body.maxRenderMs) || body.maxRenderMs < 0)) {
+    return "maxRenderMs must be a non-negative integer number of milliseconds";
+  }
   if (body.variables !== void 0 && !isPlainObject2(body.variables)) {
     return 'variables must be a JSON object keyed by variable id (e.g. {"title":"Hello"})';
   }
@@ -17473,7 +17765,7 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve10(candidate);
-  if (!existsSync24(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  if (!existsSync24(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
@@ -17498,8 +17790,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync5(join36(tempRoot, "producer-project-"));
-  writeFileSync9(join36(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync5(join37(tempRoot, "producer-project-"));
+  writeFileSync9(join37(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -17560,7 +17852,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync13(dir, { recursive: true, force: true });
+    rmSync14(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -17569,7 +17861,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync24(path) ? statSync8(path).size : 0;
+  return existsSync24(path) ? statSync9(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -17869,7 +18161,7 @@ function createRenderHandlers(options = {}) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync8(artifact.path);
+    const stats = statSync9(artifact.path);
     return new Response(createReadStream5(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -17968,12 +18260,12 @@ import {
   mkdtempSync as mkdtempSync7,
   readFileSync as readFileSync13,
   readdirSync as readdirSync9,
-  rmSync as rmSync15,
-  statSync as statSync10,
+  rmSync as rmSync16,
+  statSync as statSync11,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname16, isAbsolute as isAbsolute5, join as join39, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute5, join as join40, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
 import { DISTRIBUTED_FPS as DISTRIBUTED_FPS2, isDistributedFps as isDistributedFps3 } from "@hyperframes/core";
 import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry8 } from "@hyperframes/engine";
 
@@ -17984,12 +18276,12 @@ import {
   linkSync as linkSync2,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync6,
-  rmSync as rmSync14,
-  statSync as statSync9,
+  rmSync as rmSync15,
+  statSync as statSync10,
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
-import { dirname as dirname15, join as join38 } from "node:path";
+import { dirname as dirname15, join as join39 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -18004,7 +18296,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -18014,7 +18306,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join37(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join38(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -18055,11 +18347,11 @@ var LocalPlanV2ArtifactPublisher = class {
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync15(dirname15(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync6(join38(dirname15(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = mkdtempSync6(join39(dirname15(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
-    const sourceSize = statSync9(blob.sourcePath).size;
+    const sourceSize = statSync10(blob.sourcePath).size;
     if (sourceSize !== blob.sizeBytes) {
       throw new PlanV2IntegrityError(
         `published blob size changed for ${digest}: expected ${blob.sizeBytes}, got ${sourceSize}`
@@ -18068,8 +18360,8 @@ var LocalPlanV2ArtifactPublisher = class {
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
     if (existsSync25(destinationPath)) return;
     mkdirSync15(dirname15(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync6(join38(dirname15(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join38(stagingDir, "blob");
+    const stagingDir = mkdtempSync6(join39(dirname15(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join39(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -18079,7 +18371,7 @@ var LocalPlanV2ArtifactPublisher = class {
       }
       renameWithRetry7(temporaryPath, destinationPath);
     } finally {
-      rmSync14(stagingDir, { recursive: true, force: true });
+      rmSync15(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
@@ -18090,13 +18382,13 @@ var LocalPlanV2ArtifactPublisher = class {
         );
       }
     }
-    writeFileSync10(join38(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync10(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameWithRetry7(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
     if (!this.#committed) {
-      rmSync14(this.temporaryDir, { recursive: true, force: true });
+      rmSync15(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -18135,7 +18427,7 @@ function listFiles(root) {
   const rootResolved = resolve11(root);
   function walk(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join39(dir, entry.name);
+      const absolutePath = join40(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -18162,13 +18454,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join39(executionPlanDir, "video-frames");
+  const videoRoot = join40(executionPlanDir, "video-frames");
   if (!existsSync26(videoRoot)) return;
   for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join39(videoRoot, videoEntry.name);
+    const videoDir = join40(videoRoot, videoEntry.name);
     if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join39(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join40(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -18215,7 +18507,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join39(outputDir, String(index)));
+        framePaths2.set(index, join40(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -18223,7 +18515,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join39(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join40(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -18242,7 +18534,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join39(outputDir, frameName));
+      framePaths.set(frameIndex, join40(outputDir, frameName));
     }
     return {
       ...video,
@@ -18263,7 +18555,7 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync26(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
@@ -18288,17 +18580,22 @@ 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) {
-  const videoRoot = join39(executionPlanDir, "video-frames");
+  const videoRoot = join40(executionPlanDir, "video-frames");
   const hasExtractedFrames = existsSync26(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join39(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join40(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync26(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join39(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join40(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -18354,20 +18651,20 @@ function computeManifestHash(manifest) {
 function writeBlob(sourcePath, destinationPath) {
   if (existsSync26(destinationPath)) return;
   mkdirSync16(dirname16(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync7(join39(dirname16(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join39(temporaryDir, "blob");
+  const temporaryDir = mkdtempSync7(join40(dirname16(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join40(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
     renameWithRetry8(temporaryPath, destinationPath);
   } finally {
-    rmSync15(temporaryDir, { recursive: true, force: true });
+    rmSync16(temporaryDir, { recursive: true, force: true });
   }
 }
 function publishBlobFor(absolutePath, digests) {
   return {
     sourcePath: absolutePath,
     sha256: planFileSha256(absolutePath, digests),
-    sizeBytes: statSync10(absolutePath).size
+    sizeBytes: statSync11(absolutePath).size
   };
 }
 async function putBlobs(publisher, blobs) {
@@ -18391,7 +18688,7 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join39(executionPlanDir, "plan.json");
+  const executionPlanPath = join40(executionPlanDir, "plan.json");
   if (!existsSync26(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
@@ -18419,7 +18716,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join39(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join40(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
   const files = listFiles(executionPlanDir);
   const chunkAudio = !isRecord3(encoder) || encoder.chunksCarryAudio !== true ? "none" : files.some((file) => chunkAudioSliceTarget(file.path) !== null) ? "sliced" : "whole";
   for (const file of files) {
@@ -18480,20 +18777,20 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
   mkdirSync16(dirname16(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync7(join39(dirname16(planV2Dir), ".plan-v2-build-"));
+  const tempDir = mkdtempSync7(join40(dirname16(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync11(
-      join39(tempDir, "plan.json"),
+      join40(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
     renameWithRetry8(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
-    rmSync15(tempDir, { recursive: true, force: true });
+    rmSync16(tempDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18533,7 +18830,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync7(join39(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync7(join40(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -18544,7 +18841,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
       // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
       whileAudioMixes: () => putBlobs(
         publisher,
-        listFiles(join39(stagingRoot, "compiled")).map(
+        listFiles(join40(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -18560,7 +18857,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
     }
     throw error;
   } finally {
-    rmSync15(stagingRoot, { recursive: true, force: true });
+    rmSync16(stagingRoot, { recursive: true, force: true });
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
@@ -18576,7 +18873,7 @@ async function planV2(projectDir, config, planV2Dir) {
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join39(planV2Dir, "plan.json"),
+    manifestPath: join40(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -18712,7 +19009,7 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join39(planV2Dir, "plan.json");
+  const manifestPath = join40(planV2Dir, "plan.json");
   if (!existsSync26(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
@@ -18735,7 +19032,7 @@ function verifyBlob(planV2Dir, artifact) {
   if (!existsSync26(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
-  const stats = statSync10(sourcePath);
+  const stats = statSync11(sourcePath);
   if (!stats.isFile() || stats.size !== artifact.sizeBytes) {
     throw new PlanV2IntegrityError(`artifact size mismatch for ${artifact.path}`);
   }
@@ -18758,16 +19055,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync16(dirname16(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync7(join39(dirname16(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = mkdtempSync7(join40(dirname16(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join39(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join40(tempDir, ...artifact.path.split("/"));
       mkdirSync16(dirname16(destinationPath), { recursive: true });
       copyFileSync7(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync11(
-      join39(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join40(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -18777,7 +19074,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     );
     renameWithRetry8(tempDir, destinationDir);
   } catch (error) {
-    rmSync15(tempDir, { recursive: true, force: true });
+    rmSync16(tempDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -18790,7 +19087,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     // Join the artifact's OWN name, not the current constant: a plan written
     // before the container change carries the legacy name, and materializing it
     // under the new one would point at a file that was never written.
-    audioPath: target.role === "assembler" ? audioArtifact ? join39(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join40(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -18809,7 +19106,7 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  const markerPath = join39(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  const markerPath = join40(planDir, PLAN_V2_MATERIALIZATION_MARKER);
   if (!existsSync26(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
@@ -18827,8 +19124,8 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   assertRemoteSources(remoteSources, required);
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
-    const path = join39(planDir, ...artifact.path.split("/"));
-    if (!existsSync26(path) || statSync10(path).size !== artifact.sizeBytes) {
+    const path = join40(planDir, ...artifact.path.split("/"));
+    if (!existsSync26(path) || statSync11(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -18841,9 +19138,9 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
 }
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync9, rmSync as rmSync18 } from "node:fs";
+import { mkdtempSync as mkdtempSync9, rmSync as rmSync19 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
@@ -18853,11 +19150,11 @@ import {
   mkdtempSync as mkdtempSync8,
   readFileSync as readFileSync14,
   readdirSync as readdirSync10,
-  rmSync as rmSync16,
-  statSync as statSync11,
+  rmSync as rmSync17,
+  statSync as statSync12,
   writeFileSync as writeFileSync12
 } from "node:fs";
-import { dirname as dirname17, join as join40 } from "node:path";
+import { dirname as dirname17, join as join41 } from "node:path";
 import {
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
   describeFfmpegFailure as describeFfmpegFailure4,
@@ -18893,7 +19190,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       outputPath,
       durationMs: Date.now() - start,
       framesEncoded: plan2.totalFrames,
-      fileSize: statSync11(outputPath).size
+      fileSize: statSync12(outputPath).size
     };
   }
   const format = plan2.dimensions.format;
@@ -18921,7 +19218,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join40(workDir, `output.${format}`);
+    const finalPath = join41(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync27(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameWithRetry9(finalPath, outputPath);
@@ -18932,7 +19229,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync16(workDir, { recursive: true, force: true });
+      rmSync17(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -18940,7 +19237,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync27(outputPath) ? statSync11(outputPath).size : 0;
+  const fileSize = existsSync27(outputPath) ? statSync12(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -18949,8 +19246,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join40(planDir, "plan.json");
-  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
+  const planJsonPath = join41(planDir, "plan.json");
+  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
   if (!existsSync27(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
@@ -18998,7 +19295,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join40(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join41(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
@@ -19025,7 +19322,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join40(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join41(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -19065,7 +19362,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join40(workDir, "concat-list.txt");
+  const listPath = join41(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync12(listPath, `${body}
 `, "utf-8");
@@ -19103,11 +19400,11 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync14(join40(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync14(join41(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
-  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) return {};
   return JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
 }
@@ -19117,7 +19414,7 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
@@ -19130,11 +19427,11 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync27(outputPath)) rmSync16(outputPath, { recursive: true, force: true });
+  if (existsSync27(outputPath)) rmSync17(outputPath, { recursive: true, force: true });
   mkdirSync17(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
-    if (!statSync11(chunkDir).isDirectory()) {
+    if (!statSync12(chunkDir).isDirectory()) {
       throw new Error(
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
@@ -19144,8 +19441,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join40(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join40(chunkDir, frame), dst);
+      const dst = join41(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join41(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -19155,13 +19452,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     );
   }
   if (audioPath !== null && existsSync27(audioPath)) {
-    const sidecar = join40(outputPath, MIXED_AUDIO_FILENAME4);
+    const sidecar = join41(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync11(join40(outputPath, name)).size;
+      fileSize += statSync12(join41(outputPath, name)).size;
     } catch {
     }
   }
@@ -19175,9 +19472,9 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync15, readdirSync as readdirSync11, rmSync as rmSync17, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync15, readdirSync as readdirSync11, rmSync as rmSync18, writeFileSync as writeFileSync13 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
-import { join as join41 } from "node:path";
+import { join as join42 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -19296,7 +19593,7 @@ function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync15(outputPath));
   const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync15(join41(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync15(join42(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19313,9 +19610,9 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join41(planDir, "plan.json");
-  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
+  const planJsonPath = join42(planDir, "plan.json");
+  const encoderJsonPath = join42(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join42(planDir, "meta", "chunks.json");
   if (!existsSync28(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19341,7 +19638,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const encoder = JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync15(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join42(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync28(videosJsonPath)) {
     try {
@@ -19373,7 +19670,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
-  const compiledDir = join41(planDir, "compiled");
+  const compiledDir = join42(planDir, "compiled");
   if (!existsSync28(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19431,7 +19728,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync18(workDir, { recursive: true });
-    const framesDir = join41(workDir, "captured-frames");
+    const framesDir = join42(workDir, "captured-frames");
     mkdirSync18(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
@@ -19456,7 +19753,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync15(join41(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync15(join42(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)
@@ -19465,15 +19762,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;
@@ -19539,6 +19838,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           session = null;
         }
       }
+      const extractStarted = Date.now();
       const deferredVideoFrames = planVideos ? extractDeferredVideoFramesForChunk({
         planDir,
         planVideos,
@@ -19548,6 +19848,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(
@@ -19581,7 +19884,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       if (isPngSequence) {
         if (!existsSync28(outputChunkPath)) mkdirSync18(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join41(outputChunkPath, "..");
+        const outDir = join42(outputChunkPath, "..");
         if (!existsSync28(outDir)) mkdirSync18(outDir, { recursive: true });
       }
       const encodeInput = {
@@ -19685,7 +19988,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
-          rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          rmSync18(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
           mkdirSync18(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
@@ -19728,8 +20031,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync17(videoOnlyPath, { force: true });
-        rmSync17(audioScratchPath, { force: true });
+        rmSync18(videoOnlyPath, { force: true });
+        rmSync18(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -19765,6 +20068,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.
@@ -19777,8 +20082,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync17(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync18(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync18(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     } catch (err) {
       log.warn("[renderChunk] failed to remove work dir", {
         workDir,
@@ -19807,18 +20112,18 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join42(workRoot, "plan");
+  const workRoot = mkdtempSync9(join43(tmpdir5(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join43(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
   } finally {
-    rmSync18(workRoot, { recursive: true, force: true });
+    rmSync19(workRoot, { recursive: true, force: true });
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join42(workRoot, "plan");
+  const workRoot = mkdtempSync9(join43(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join43(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -19833,7 +20138,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync18(workRoot, { recursive: true, force: true });
+    rmSync19(workRoot, { recursive: true, force: true });
   }
 }