@hyperframes/producer 0.8.198 → 0.8.200

package/dist/public-server.js

@@ -4,13 +4,13 @@
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync10,
-  statSync as statSync8,
+  statSync as statSync9,
   mkdtempSync as mkdtempSync4,
   writeFileSync as writeFileSync6,
-  rmSync as rmSync11,
+  rmSync as rmSync12,
   createReadStream as createReadStream3
 } from "node:fs";
-import { resolve as resolve9, dirname as dirname12, join as join29 } from "node:path";
+import { resolve as resolve9, dirname as dirname12, join as join30 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -26,8 +26,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
@@ -76,7 +76,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";
@@ -1910,8 +1910,8 @@ function replanAfterFailure(plan, 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,
@@ -2114,6 +2114,7 @@ function aggregateDrawElement(perfs, de) {
     blankDeterministicAccepts: drain?.blankDeterministicAccepts ?? 0,
     blankRecaptures: drain?.blankRecaptures ?? 0,
     boundaryFrames: perfs.reduce((sum, p) => sum + (p.deBoundaryFrames ?? 0), 0),
+    riskFrames: perfs.reduce((sum, p) => sum + (p.deRiskFrames ?? 0), 0),
     ncprFallbacks: perfs.reduce((sum, p) => sum + (p.deNcprFallbacks ?? 0), 0),
     frameTimeouts: perfs.reduce((sum, p) => sum + (p.deFrameTimeouts ?? 0), 0)
   };
@@ -2295,7 +2296,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,
@@ -2348,10 +2349,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)
     });
   }
@@ -2361,7 +2362,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) {
@@ -2377,13 +2378,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;
@@ -2612,7 +2632,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           hdrPerf
         );
       } else {
-        blitHdrVideoLayer(
+        await blitHdrVideoLayer(
           canvas,
           layer.element,
           time,
@@ -2656,7 +2676,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
           });
         }
@@ -2752,18 +2772,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,
@@ -2777,7 +2787,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 open = (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 = open(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";
@@ -2822,10 +2915,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
+        });
       }
     }
   }
@@ -2844,23 +2943,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;
@@ -2924,24 +3021,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]
   );
@@ -2975,14 +3070,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);
@@ -3003,16 +3113,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);
@@ -3024,79 +3131,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) {
@@ -3105,12 +3212,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();
@@ -3130,7 +3248,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),
@@ -3242,7 +3364,7 @@ async function captureSceneIntoBuffer(a) {
         hdrPerf
       );
     } else {
-      blitHdrVideoLayer(
+      await blitHdrVideoLayer(
         sceneBuf,
         el,
         time,
@@ -3444,7 +3566,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,
@@ -3606,11 +3728,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(() => {
           });
         }
@@ -3629,11 +3751,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(
@@ -3645,7 +3777,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);
@@ -3665,7 +3797,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);
@@ -3683,7 +3815,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) {
@@ -3700,6 +3832,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,
@@ -3715,6 +3852,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,
@@ -3961,6 +4104,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);
@@ -3975,6 +4136,7 @@ async function runCaptureStreamingStage(input) {
             blankDeterministicAccepts: 0,
             blankRecaptures: 0
           };
+          const riskFrames = session.deRiskFrames;
           await runWorkerEncodePipelineLoop(
             session,
             totalFrames,
@@ -3985,7 +4147,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();
@@ -4023,6 +4194,7 @@ async function runCaptureStreamingStage(input) {
       } finally {
         lastBrowserConsole = session.browserConsoleBuffer;
         await closeCaptureSession(session);
+        if (riskSession) await closeCaptureSession(riskSession);
       }
     }
     const encodeFrom = job.progress;
@@ -4059,7 +4231,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 {
@@ -4135,7 +4307,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 {
@@ -4153,7 +4325,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;
@@ -4182,7 +4354,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
   });
@@ -4320,7 +4492,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));
@@ -4391,10 +4563,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) {
@@ -4420,7 +4665,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";
@@ -4438,7 +4683,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"));
@@ -4449,9 +4694,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 {
@@ -4469,7 +4714,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;
@@ -4563,7 +4808,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,
@@ -4808,7 +5053,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) {
@@ -4841,7 +5086,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) {
@@ -5273,14 +5518,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,
@@ -5507,8 +5752,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";
@@ -5557,7 +5802,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;
@@ -5692,10 +5937,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;
     }
   }
@@ -5751,7 +5996,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);
@@ -5773,8 +6018,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,
@@ -6125,10 +6370,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);
@@ -6188,7 +6429,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)) {
@@ -6808,7 +7049,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)"
   );
@@ -6823,7 +7064,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)"
   );
@@ -6839,7 +7080,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
@@ -6974,7 +7215,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}")`)
@@ -7141,7 +7382,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(
@@ -7255,7 +7495,6 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     renderModeHints,
     hasShaderTransitions,
     usesThreeDTransforms,
-    usesMixBlendMode,
     hasAncestorBackgroundImage
   };
 }
@@ -7641,7 +7880,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,
@@ -7649,7 +7888,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();
@@ -7662,13 +7901,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";
@@ -7712,7 +7944,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join14(workDir, "compiled"),
+    compiledDir: join15(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -7757,7 +7989,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,
@@ -7949,7 +8181,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
@@ -7977,7 +8209,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
@@ -8062,7 +8294,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join15(workDir, "probe-screenshot"),
+            join16(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -8098,7 +8330,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join15(workDir, "downloads")
+            join16(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -8289,7 +8521,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join15(workDir, "compiled"),
+      compiledDir: join16(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -8423,7 +8655,7 @@ function validateRenderDuration(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,
@@ -8738,14 +8970,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,
@@ -8812,8 +9044,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,
@@ -8822,8 +9054,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,
@@ -9026,7 +9258,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       error: `audioPadTrim: failed to materialize ${plan.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    for (const path of plan.cleanupPaths) rmSync7(path, { force: true });
+    for (const path of plan.cleanupPaths) rmSync8(path, { force: true });
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -9063,19 +9295,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);
@@ -9092,7 +9326,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,
@@ -9124,7 +9362,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) {
@@ -9271,7 +9509,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);
@@ -9291,7 +9529,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) {
@@ -9309,7 +9547,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;
@@ -9320,7 +9558,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join18(workDir, "audio-work"),
+        join19(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -9389,7 +9627,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,
@@ -9462,13 +9700,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;
@@ -9528,7 +9766,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,
@@ -9755,7 +9993,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,
@@ -9827,7 +10065,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
@@ -9952,7 +10190,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
         );
       }
@@ -9984,7 +10222,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,
@@ -9998,7 +10236,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";
@@ -10012,9 +10250,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) {
@@ -10382,7 +10620,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
             );
           }
@@ -10551,7 +10789,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);
@@ -10569,7 +10808,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 });
       }
@@ -10729,12 +10968,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,
@@ -10859,7 +11098,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,
@@ -10868,7 +11107,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) {
@@ -10943,7 +11182,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve10) => wake = resolve10);
       }
       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)) {
@@ -11026,11 +11265,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}`
       );
@@ -11050,7 +11289,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
@@ -11263,9 +11502,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()) {
@@ -11412,8 +11651,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) {
@@ -11435,7 +11674,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);
@@ -11463,8 +11702,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) {
@@ -11496,7 +11735,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;
@@ -11522,7 +11761,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,
@@ -11979,7 +12218,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;
@@ -12115,17 +12357,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,
@@ -12139,7 +12381,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({
@@ -12170,7 +12412,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 = [];
@@ -12183,7 +12427,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,
@@ -12285,15 +12529,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.`
@@ -12456,7 +12700,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",
@@ -12590,7 +12834,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
@@ -12608,7 +12852,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"
@@ -12657,6 +12901,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
@@ -12712,7 +12957,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,
@@ -12758,7 +13002,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
@@ -12800,6 +13044,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;
@@ -12918,7 +13164,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;
     }
@@ -12962,6 +13208,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,
@@ -12970,7 +13237,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,
@@ -13055,7 +13323,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);
@@ -13301,7 +13569,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);
@@ -13316,10 +13584,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,
@@ -13400,7 +13668,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" });
@@ -13669,7 +13937,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;
@@ -13856,7 +14124,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);
       }
     }
@@ -13867,8 +14135,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();
@@ -13962,13 +14231,13 @@ async function executeRenderPipeline(input) {
 import {
   existsSync as existsSync17,
   readFileSync as readFileSync9,
-  statSync as statSync7,
+  statSync as statSync8,
   openSync as openSync4,
-  fstatSync as fstatSync4,
-  closeSync as closeSync5,
+  fstatSync as fstatSync3,
+  closeSync as closeSync4,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve8, join as join26, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
+import { resolve as resolve8, join as join27, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -14002,19 +14271,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 readFileSync9(fd, "utf-8");
   } finally {
-    closeSync5(fd);
+    closeSync4(fd);
   }
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve8(projectDir);
-  if (!existsSync17(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+  if (!existsSync17(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -14036,7 +14305,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join26(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join27(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -14082,7 +14351,7 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname11, join as join27 } from "node:path";
+import { dirname as dirname11, join as join28 } from "node:path";
 import { existsSync as existsSync18 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -14158,7 +14427,7 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname11(fileURLToPath5(import.meta.url));
-  const candidates = [join27(here, "healthWorkerThread.js"), join27(here, "healthWorkerThread.ts")];
+  const candidates = [join28(here, "healthWorkerThread.js"), join28(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync18(candidate)) return candidate;
   }
@@ -14194,7 +14463,7 @@ import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
 
 // src/services/distributed/plan.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframes/engine";
-import { extname as extname4, isAbsolute as isAbsolute4, join as join28, relative as relative4, sep as sep3 } from "node:path";
+import { extname as extname4, isAbsolute as isAbsolute4, join as join29, relative as relative4, sep as sep3 } from "node:path";
 import {
   fpsToNumber as fpsToNumber10,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -14298,9 +14567,9 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join28("meta", "composition.json"),
-  join28("meta", "encoder.json"),
-  join28("meta", "chunks.json")
+  join29("meta", "composition.json"),
+  join29("meta", "encoder.json"),
+  join29("meta", "chunks.json")
 ];
 
 // src/services/distributed/renderConfigValidation.ts
@@ -14441,6 +14710,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);
@@ -14533,7 +14803,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;
@@ -14592,6 +14863,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";
@@ -14607,6 +14879,7 @@ function parseRenderOptions(body) {
     fps,
     quality,
     workers,
+    maxRenderMs,
     crf,
     videoBitrate,
     useGpu,
@@ -14640,6 +14913,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,
@@ -14666,6 +14940,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"})';
   }
@@ -14698,7 +14975,7 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve9(candidate);
-  if (!existsSync19(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  if (!existsSync19(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
@@ -14723,8 +15000,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join29(tempRoot, "producer-project-"));
-  writeFileSync6(join29(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync4(join30(tempRoot, "producer-project-"));
+  writeFileSync6(join30(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -14785,7 +15062,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync11(dir, { recursive: true, force: true });
+    rmSync12(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -14794,7 +15071,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync19(path) ? statSync8(path).size : 0;
+  return existsSync19(path) ? statSync9(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -15094,7 +15371,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(createReadStream3(artifact.path), {
       headers: {
         "content-type": "video/mp4",