hyperframes 0.4.15-alpha.1 → 0.4.15

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.15-alpha.1" : "0.0.0-dev";
+    VERSION = true ? "0.4.15" : "0.0.0-dev";
   }
 });
 
@@ -9821,7 +9821,7 @@ import { get as httpsGet } from "https";
 import { pipeline } from "stream/promises";
 function downloadFile(url, dest) {
   const tmp = `${dest}.tmp`;
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const follow = (u) => {
       httpsGet(u, (res) => {
         if (res.statusCode === 301 || res.statusCode === 302) {
@@ -9838,7 +9838,7 @@ function downloadFile(url, dest) {
         const file = createWriteStream(tmp);
         pipeline(res, file).then(() => {
           renameSync(tmp, dest);
-          resolve36();
+          resolve37();
         }).catch((err) => {
           try {
             unlinkSync(tmp);
@@ -10556,7 +10556,7 @@ function hasNpx() {
   }
 }
 function runSkillsAdd(repo) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const child = spawn("npx", ["skills", "add", repo, "--all"], {
       stdio: "inherit",
       timeout: 12e4,
@@ -10570,7 +10570,7 @@ function runSkillsAdd(repo) {
       env: { ...process.env, GIT_CLONE_PROTECTION_ACTIVE: "0" }
     });
     child.on("close", (code, signal) => {
-      if (code === 0) resolve36();
+      if (code === 0) resolve37();
       else if (signal === "SIGINT" || code === 130) process.exit(0);
       else reject(new Error(`npx skills add exited with code ${code}`));
     });
@@ -15315,8 +15315,8 @@ var init_custom_element_registry = __esm({
         } : (element) => element.localName === localName;
         registry.set(localName, { Class, check });
         if (waiting.has(localName)) {
-          for (const resolve36 of waiting.get(localName))
-            resolve36(Class);
+          for (const resolve37 of waiting.get(localName))
+            resolve37(Class);
           waiting.delete(localName);
         }
         ownerDocument.querySelectorAll(
@@ -15356,13 +15356,13 @@ var init_custom_element_registry = __esm({
        */
       whenDefined(localName) {
         const { registry, waiting } = this;
-        return new Promise((resolve36) => {
+        return new Promise((resolve37) => {
           if (registry.has(localName))
-            resolve36(registry.get(localName).Class);
+            resolve37(registry.get(localName).Class);
           else {
             if (!waiting.has(localName))
               waiting.set(localName, []);
-            waiting.get(localName).push(resolve36);
+            waiting.get(localName).push(resolve37);
           }
         });
       }
@@ -21068,12 +21068,12 @@ var require_CSSValueExpression = __commonJS({
         return false;
       }
     };
-    CSSOM.CSSValueExpression.prototype._parseJSString = function(token, idx, sep3) {
-      var endIdx = this._findMatchedIdx(token, idx, sep3), text;
+    CSSOM.CSSValueExpression.prototype._parseJSString = function(token, idx, sep4) {
+      var endIdx = this._findMatchedIdx(token, idx, sep4), text;
       if (endIdx === -1) {
         return false;
       } else {
-        text = token.substring(idx, endIdx + sep3.length);
+        text = token.substring(idx, endIdx + sep4.length);
         return {
           idx: endIdx,
           text
@@ -21113,15 +21113,15 @@ var require_CSSValueExpression = __commonJS({
       if (!isLegal) {
         return false;
       } else {
-        var sep3 = "/";
-        return this._parseJSString(token, idx, sep3);
+        var sep4 = "/";
+        return this._parseJSString(token, idx, sep4);
       }
     };
-    CSSOM.CSSValueExpression.prototype._findMatchedIdx = function(token, idx, sep3) {
+    CSSOM.CSSValueExpression.prototype._findMatchedIdx = function(token, idx, sep4) {
       var startIdx = idx, endIdx;
       var NOT_FOUND = -1;
       while (true) {
-        endIdx = token.indexOf(sep3, startIdx + 1);
+        endIdx = token.indexOf(sep4, startIdx + 1);
         if (endIdx === -1) {
           endIdx = NOT_FOUND;
           break;
@@ -24755,7 +24755,7 @@ function resolveConfig(overrides) {
     hdr: (() => {
       const raw = env("PRODUCER_HDR_TRANSFER");
       if (raw === "hlg" || raw === "pq") return { transfer: raw };
-      return void 0;
+      return false;
     })(),
     hdrAutoDetect: envBool("PRODUCER_HDR_AUTO_DETECT", DEFAULT_CONFIG2.hdrAutoDetect),
     audioGain: envNum("PRODUCER_AUDIO_GAIN", DEFAULT_CONFIG2.audioGain),
@@ -25220,7 +25220,8 @@ async function injectVideoFramesBatch(page, updates) {
         let img = video.nextElementSibling;
         const isNewImage = !img || !img.classList.contains("__render_frame__");
         const computedStyle = window.getComputedStyle(video);
-        const computedOpacity = parseFloat(computedStyle.opacity) || 1;
+        const opacityParsed = parseFloat(computedStyle.opacity);
+        const computedOpacity = Number.isNaN(opacityParsed) ? 1 : opacityParsed;
         const sourceIsStatic = !computedStyle.position || computedStyle.position === "static";
         if (isNewImage) {
           img = document.createElement("img");
@@ -25266,7 +25267,6 @@ async function injectVideoFramesBatch(page, updates) {
         img.style.opacity = String(computedOpacity);
         img.style.visibility = "visible";
         video.style.setProperty("visibility", "hidden", "important");
-        video.style.setProperty("opacity", "0", "important");
         video.style.setProperty("pointer-events", "none", "important");
       }
       if (pendingDecodes.length > 0) {
@@ -25293,7 +25293,6 @@ async function syncVideoFrameVisibility(page, activeVideoIds) {
       } else {
         video.style.removeProperty("display");
         video.style.setProperty("visibility", "hidden", "important");
-        video.style.setProperty("opacity", "0", "important");
         video.style.setProperty("pointer-events", "none", "important");
         if (hasImg) {
           img.style.visibility = "hidden";
@@ -25397,7 +25396,7 @@ async function pollPageExpression(page, expression, timeoutMs, intervalMs = 100)
   while (Date.now() < deadline) {
     const ready = Boolean(await page.evaluate(expression));
     if (ready) return true;
-    await new Promise((resolve36) => setTimeout(resolve36, intervalMs));
+    await new Promise((resolve37) => setTimeout(resolve37, intervalMs));
   }
   return Boolean(await page.evaluate(expression));
 }
@@ -25628,9 +25627,15 @@ async function captureFrameToBuffer(session, frameIndex, time) {
   return { buffer, captureTimeMs };
 }
 async function closeCaptureSession(session) {
-  if (session.page) await session.page.close().catch(() => {
-  });
-  if (session.browser) await releaseBrowser(session.browser, session.config);
+  if (!session.pageReleased && session.page) {
+    await session.page.close().catch(() => {
+    });
+    session.pageReleased = true;
+  }
+  if (!session.browserReleased && session.browser) {
+    await releaseBrowser(session.browser, session.config);
+    session.browserReleased = true;
+  }
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
@@ -25680,7 +25685,7 @@ var init_frameCapture = __esm({
 // ../engine/src/utils/gpuEncoder.ts
 import { spawn as spawn2 } from "child_process";
 async function detectGpuEncoder() {
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     const ffmpeg = spawn2("ffmpeg", ["-encoders"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -25689,13 +25694,13 @@ async function detectGpuEncoder() {
       stdout2 += data.toString();
     });
     ffmpeg.on("close", () => {
-      if (stdout2.includes("h264_nvenc")) resolve36("nvenc");
-      else if (stdout2.includes("h264_videotoolbox")) resolve36("videotoolbox");
-      else if (stdout2.includes("h264_vaapi")) resolve36("vaapi");
-      else if (stdout2.includes("h264_qsv")) resolve36("qsv");
-      else resolve36(null);
+      if (stdout2.includes("h264_nvenc")) resolve37("nvenc");
+      else if (stdout2.includes("h264_videotoolbox")) resolve37("videotoolbox");
+      else if (stdout2.includes("h264_vaapi")) resolve37("vaapi");
+      else if (stdout2.includes("h264_qsv")) resolve37("qsv");
+      else resolve37(null);
     });
-    ffmpeg.on("error", () => resolve36(null));
+    ffmpeg.on("error", () => resolve37(null));
   });
 }
 async function getCachedGpuEncoder() {
@@ -25727,6 +25732,51 @@ var init_gpuEncoder = __esm({
   }
 });
 
+// ../engine/src/utils/hdr.ts
+function isHdrColorSpace(cs) {
+  if (!cs) return false;
+  return cs.colorPrimaries.includes("bt2020") || cs.colorSpace.includes("bt2020") || cs.colorTransfer === "smpte2084" || cs.colorTransfer === "arib-std-b67";
+}
+function detectTransfer(cs) {
+  if (cs?.colorTransfer === "smpte2084") return "pq";
+  return "hlg";
+}
+function getHdrEncoderColorParams(transfer, mastering = DEFAULT_HDR10_MASTERING) {
+  const colorTrc = transfer === "pq" ? "smpte2084" : "arib-std-b67";
+  const tagging = `colorprim=bt2020:transfer=${colorTrc}:colormatrix=bt2020nc`;
+  const metadata = `master-display=${mastering.masterDisplay}:max-cll=${mastering.maxCll}`;
+  return {
+    colorPrimaries: "bt2020",
+    colorTrc,
+    colorspace: "bt2020nc",
+    pixelFormat: "yuv420p10le",
+    x265ColorParams: `${tagging}:${metadata}`,
+    mastering
+  };
+}
+function analyzeCompositionHdr(colorSpaces) {
+  let hasPq = false;
+  let hasHdr = false;
+  for (const cs of colorSpaces) {
+    if (!isHdrColorSpace(cs)) continue;
+    hasHdr = true;
+    if (cs?.colorTransfer === "smpte2084") hasPq = true;
+  }
+  if (!hasHdr) return { hasHdr: false, dominantTransfer: null };
+  const dominantTransfer = hasPq ? "pq" : "hlg";
+  return { hasHdr: true, dominantTransfer };
+}
+var DEFAULT_HDR10_MASTERING;
+var init_hdr = __esm({
+  "../engine/src/utils/hdr.ts"() {
+    "use strict";
+    DEFAULT_HDR10_MASTERING = {
+      masterDisplay: "G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)",
+      maxCll: "1000,400"
+    };
+  }
+});
+
 // ../engine/src/utils/runFfmpeg.ts
 import { spawn as spawn3 } from "child_process";
 async function runFfmpeg(args, opts) {
@@ -25734,7 +25784,7 @@ async function runFfmpeg(args, opts) {
   const signal = opts?.signal;
   const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
   const onStderr = opts?.onStderr;
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     const ffmpeg = spawn3("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -25760,7 +25810,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("close", (code) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve36({
+      resolve37({
         success: !signal?.aborted && code === 0,
         exitCode: code,
         stderr,
@@ -25770,7 +25820,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve36({
+      resolve37({
         success: false,
         exitCode: null,
         stderr: err.message,
@@ -25830,6 +25880,12 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     pixelFormat = "yuv420p",
     useGpu = false
   } = options;
+  if (options.hdr && codec === "h264") {
+    console.warn(
+      "[chunkEncoder] HDR is not supported with codec=h264 (libx264 has no HDR support). Stripping HDR metadata and tagging output as SDR/BT.709. Use codec=h265 for HDR output."
+    );
+    options = { ...options, hdr: void 0 };
+  }
   const args = [...inputArgs, "-r", String(fps)];
   const shouldUseGpu = useGpu && gpuEncoder !== null;
   if (codec === "h264" || codec === "h265") {
@@ -25868,7 +25924,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const xParamsFlag = codec === "h264" ? "-x264-params" : "-x265-params";
-      const colorParams = "colorprim=bt709:transfer=bt709:colormatrix=bt709";
+      const colorParams = codec === "h265" && options.hdr ? getHdrEncoderColorParams(options.hdr.transfer).x265ColorParams : "colorprim=bt709:transfer=bt709:colormatrix=bt709";
       if (preset === "ultrafast") {
         args.push(xParamsFlag, `aq-mode=3:${colorParams}`);
       } else {
@@ -25892,16 +25948,30 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     return [...args, "-y", outputPath];
   }
   if (codec === "h264" || codec === "h265") {
-    args.push(
-      "-colorspace:v",
-      "bt709",
-      "-color_primaries:v",
-      "bt709",
-      "-color_trc:v",
-      "bt709",
-      "-color_range",
-      "tv"
-    );
+    if (options.hdr) {
+      const transferTag = options.hdr.transfer === "pq" ? "smpte2084" : "arib-std-b67";
+      args.push(
+        "-colorspace:v",
+        "bt2020nc",
+        "-color_primaries:v",
+        "bt2020",
+        "-color_trc:v",
+        transferTag,
+        "-color_range",
+        "tv"
+      );
+    } else {
+      args.push(
+        "-colorspace:v",
+        "bt709",
+        "-color_primaries:v",
+        "bt709",
+        "-color_trc:v",
+        "bt709",
+        "-color_range",
+        "tv"
+      );
+    }
     if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
@@ -25941,7 +26011,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   const inputPath = join19(framesDir, framePattern);
   const inputArgs = ["-framerate", String(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     const ffmpeg = spawn4("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -25966,7 +26036,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       if (signal) signal.removeEventListener("abort", onAbort);
       const durationMs = Date.now() - startTime;
       if (signal?.aborted) {
-        resolve36({
+        resolve37({
           success: false,
           outputPath,
           durationMs,
@@ -25977,7 +26047,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       if (code !== 0) {
-        resolve36({
+        resolve37({
           success: false,
           outputPath,
           durationMs,
@@ -25988,12 +26058,12 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       const fileSize = existsSync15(outputPath) ? statSync4(outputPath).size : 0;
-      resolve36({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
+      resolve37({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve36({
+      resolve37({
         success: false,
         outputPath,
         durationMs: Date.now() - startTime,
@@ -26051,18 +26121,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     let gpuEncoder = null;
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
-    const chunkResult = await new Promise((resolve36) => {
+    const chunkResult = await new Promise((resolve37) => {
       const ffmpeg = spawn4("ffmpeg", args);
       let stderr = "";
       ffmpeg.stderr.on("data", (d) => {
         stderr += d.toString();
       });
       ffmpeg.on("close", (code) => {
-        if (code === 0) resolve36({ success: true });
-        else resolve36({ success: false, error: `Chunk ${i2} encode failed: ${stderr.slice(-400)}` });
+        if (code === 0) resolve37({ success: true });
+        else resolve37({ success: false, error: `Chunk ${i2} encode failed: ${stderr.slice(-400)}` });
       });
       ffmpeg.on("error", (err) => {
-        resolve36({ success: false, error: `Chunk ${i2} encode error: ${err.message}` });
+        resolve37({ success: false, error: `Chunk ${i2} encode error: ${err.message}` });
       });
     });
     if (!chunkResult.success) {
@@ -26092,18 +26162,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     "-y",
     outputPath
   ];
-  const concatResult = await new Promise((resolve36) => {
+  const concatResult = await new Promise((resolve37) => {
     const ffmpeg = spawn4("ffmpeg", concatArgs);
     let stderr = "";
     ffmpeg.stderr.on("data", (d) => {
       stderr += d.toString();
     });
     ffmpeg.on("close", (code) => {
-      if (code === 0) resolve36({ success: true });
-      else resolve36({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
+      if (code === 0) resolve37({ success: true });
+      else resolve37({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
     });
     ffmpeg.on("error", (err) => {
-      resolve36({ success: false, error: `Chunk concat error: ${err.message}` });
+      resolve37({ success: false, error: `Chunk concat error: ${err.message}` });
     });
   });
   if (!concatResult.success) {
@@ -26185,6 +26255,7 @@ var init_chunkEncoder = __esm({
     "use strict";
     init_config2();
     init_gpuEncoder();
+    init_hdr();
     init_runFfmpeg();
     init_gpuEncoder();
     ENCODER_PRESETS = {
@@ -26195,51 +26266,6 @@ var init_chunkEncoder = __esm({
   }
 });
 
-// ../engine/src/utils/hdr.ts
-function isHdrColorSpace(cs) {
-  if (!cs) return false;
-  return cs.colorPrimaries.includes("bt2020") || cs.colorSpace.includes("bt2020") || cs.colorTransfer === "smpte2084" || cs.colorTransfer === "arib-std-b67";
-}
-function detectTransfer(cs) {
-  if (cs?.colorTransfer === "smpte2084") return "pq";
-  return "hlg";
-}
-function getHdrEncoderColorParams(transfer, mastering = DEFAULT_HDR10_MASTERING) {
-  const colorTrc = transfer === "pq" ? "smpte2084" : "arib-std-b67";
-  const tagging = `colorprim=bt2020:transfer=${colorTrc}:colormatrix=bt2020nc`;
-  const metadata = `master-display=${mastering.masterDisplay}:max-cll=${mastering.maxCll}`;
-  return {
-    colorPrimaries: "bt2020",
-    colorTrc,
-    colorspace: "bt2020nc",
-    pixelFormat: "yuv420p10le",
-    x265ColorParams: `${tagging}:${metadata}`,
-    mastering
-  };
-}
-function analyzeCompositionHdr(colorSpaces) {
-  let hasPq = false;
-  let hasHdr = false;
-  for (const cs of colorSpaces) {
-    if (!isHdrColorSpace(cs)) continue;
-    hasHdr = true;
-    if (cs?.colorTransfer === "smpte2084") hasPq = true;
-  }
-  if (!hasHdr) return { hasHdr: false, dominantTransfer: null };
-  const dominantTransfer = hasPq ? "pq" : "hlg";
-  return { hasHdr: true, dominantTransfer };
-}
-var DEFAULT_HDR10_MASTERING;
-var init_hdr = __esm({
-  "../engine/src/utils/hdr.ts"() {
-    "use strict";
-    DEFAULT_HDR10_MASTERING = {
-      masterDisplay: "G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)",
-      maxCll: "1000,400"
-    };
-  }
-});
-
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync16, mkdirSync as mkdirSync10, statSync as statSync5 } from "fs";
@@ -26247,37 +26273,37 @@ import { dirname as dirname6 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
   const pending = /* @__PURE__ */ new Map();
-  const enqueueAt = (frame, resolve36) => {
+  const enqueueAt = (frame, resolve37) => {
     const list = pending.get(frame);
     if (list === void 0) {
-      pending.set(frame, [resolve36]);
+      pending.set(frame, [resolve37]);
     } else {
-      list.push(resolve36);
+      list.push(resolve37);
     }
   };
   const flushAt = (frame) => {
     const list = pending.get(frame);
     if (list === void 0) return;
     pending.delete(frame);
-    for (const resolve36 of list) resolve36();
+    for (const resolve37 of list) resolve37();
   };
-  const waitForFrame = (frame) => new Promise((resolve36) => {
+  const waitForFrame = (frame) => new Promise((resolve37) => {
     if (frame === cursor) {
-      resolve36();
+      resolve37();
       return;
     }
-    enqueueAt(frame, resolve36);
+    enqueueAt(frame, resolve37);
   });
   const advanceTo = (frame) => {
     cursor = frame;
     flushAt(frame);
   };
-  const waitForAllDone = () => new Promise((resolve36) => {
+  const waitForAllDone = () => new Promise((resolve37) => {
     if (cursor >= endFrame) {
-      resolve36();
+      resolve37();
       return;
     }
-    enqueueAt(endFrame, resolve36);
+    enqueueAt(endFrame, resolve37);
   });
   return { waitForFrame, advanceTo, waitForAllDone };
 }
@@ -26439,7 +26465,7 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
   let stderr = "";
   let exitCode = null;
   let exitPromiseResolve = null;
-  const exitPromise = new Promise((resolve36) => exitPromiseResolve = resolve36);
+  const exitPromise = new Promise((resolve37) => exitPromiseResolve = resolve37);
   ffmpeg.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
@@ -26485,8 +26511,8 @@ Process error: ${err.message}`;
       if (signal) signal.removeEventListener("abort", onAbort);
       const stdin = ffmpeg.stdin;
       if (stdin && !stdin.destroyed) {
-        await new Promise((resolve36) => {
-          stdin.end(() => resolve36());
+        await new Promise((resolve37) => {
+          stdin.end(() => resolve37());
         });
       }
       await exitPromise;
@@ -26528,7 +26554,7 @@ import { spawn as spawn6 } from "child_process";
 import { readFileSync as readFileSync14 } from "fs";
 import { extname as extname4 } from "path";
 function runFfprobe(args) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const proc = spawn6("ffprobe", args);
     let stdout2 = "";
     let stderr = "";
@@ -26542,7 +26568,7 @@ function runFfprobe(args) {
       if (code !== 0) {
         reject(new Error(`[FFmpeg] ffprobe exited with code ${code}: ${stderr}`));
       } else {
-        resolve36(stdout2);
+        resolve37(stdout2);
       }
     });
     proc.on("error", (err) => {
@@ -26956,7 +26982,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   args.push("-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0");
   if (format === "png") args.push("-compression_level", "6");
   args.push("-y", outputPattern);
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const ffmpeg = spawn7("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -26991,7 +27017,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       files.forEach((file, index) => {
         framePaths.set(index, join21(videoOutputDir, file));
       });
-      resolve36({
+      resolve37({
         videoId,
         srcPath: videoPath,
         outputDir: videoOutputDir,
@@ -27013,8 +27039,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     });
   });
 }
-async function convertSdrToHdr(inputPath, outputPath, signal, config) {
+async function convertSdrToHdr(inputPath, outputPath, targetTransfer, signal, config) {
   const timeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
+  const colorTrc = targetTransfer === "pq" ? "smpte2084" : "arib-std-b67";
   const args = [
     "-i",
     inputPath,
@@ -27023,7 +27050,7 @@ async function convertSdrToHdr(inputPath, outputPath, signal, config) {
     "-color_primaries",
     "bt2020",
     "-color_trc",
-    "arib-std-b67",
+    colorTrc,
     "-colorspace",
     "bt2020nc",
     "-c:v",
@@ -27109,8 +27136,9 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       return metadata.colorSpace;
     })
   );
-  const hasAnyHdr = videoColorSpaces.some(isHdrColorSpace);
-  if (hasAnyHdr) {
+  const hdrInfo = analyzeCompositionHdr(videoColorSpaces);
+  if (hdrInfo.hasHdr && hdrInfo.dominantTransfer) {
+    const targetTransfer = hdrInfo.dominantTransfer;
     const convertDir = join21(options.outputDir, "_hdr_normalized");
     mkdirSync12(convertDir, { recursive: true });
     for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
@@ -27121,7 +27149,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         if (!entry) continue;
         const convertedPath = join21(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
-          await convertSdrToHdr(entry.videoPath, convertedPath, signal, config);
+          await convertSdrToHdr(entry.videoPath, convertedPath, targetTransfer, signal, config);
           entry.videoPath = convertedPath;
         } catch (err) {
           errors.push({
@@ -27424,7 +27452,6 @@ async function hideVideoElements(page, videoIds) {
       const el = document.getElementById(id);
       if (el) {
         el.style.setProperty("visibility", "hidden", "important");
-        el.style.setProperty("opacity", "0", "important");
         const img = document.getElementById(`__render_frame_${id}__`);
         if (img) img.style.setProperty("visibility", "hidden", "important");
       }
@@ -27438,7 +27465,6 @@ async function showVideoElements(page, videoIds) {
       const el = document.getElementById(id);
       if (el) {
         el.style.removeProperty("visibility");
-        el.style.removeProperty("opacity");
         const img = document.getElementById(`__render_frame_${id}__`);
         if (img) img.style.removeProperty("visibility");
       }
@@ -27465,8 +27491,10 @@ async function queryVideoElementBounds(page, videoIds) {
       }
       const rect = el.getBoundingClientRect();
       const style = window.getComputedStyle(el);
-      const zIndex = parseInt(style.zIndex) || 0;
-      const opacity = parseFloat(style.opacity) || 1;
+      const zIndexParsed = parseInt(style.zIndex);
+      const zIndex = Number.isNaN(zIndexParsed) ? 0 : zIndexParsed;
+      const opacityParsed = parseFloat(style.opacity);
+      const opacity = Number.isNaN(opacityParsed) ? 1 : opacityParsed;
       const transform = style.transform || "none";
       const visible = style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
       return {
@@ -27504,12 +27532,12 @@ async function queryElementStacking(page, nativeHdrIds) {
       function resolveRadius(value, el) {
         if (value.includes("%")) {
           const pct = parseFloat(value) / 100;
-          const htmlEl = el;
-          const w = htmlEl.offsetWidth || 0;
-          const h3 = htmlEl.offsetHeight || 0;
+          const w = el instanceof HTMLElement ? el.offsetWidth : 0;
+          const h3 = el instanceof HTMLElement ? el.offsetHeight : 0;
           return pct * Math.min(w, h3);
         }
-        return parseFloat(value) || 0;
+        const parsed = parseFloat(value);
+        return Number.isNaN(parsed) ? 0 : parsed;
       }
       const selfCs = window.getComputedStyle(node);
       const selfRadii = [
@@ -27593,8 +27621,7 @@ async function queryElementStacking(page, nativeHdrIds) {
       const style = window.getComputedStyle(el);
       const zIndex = getEffectiveZIndex(el);
       const isHdrEl = hdrSet.has(id);
-      const opacityStartNode = isHdrEl ? el.parentElement : el;
-      const opacity = opacityStartNode ? getEffectiveOpacity(opacityStartNode) : 1;
+      const opacity = getEffectiveOpacity(el);
       const visible = style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
       const htmlEl = el instanceof HTMLElement ? el : null;
       results.push({
@@ -28237,11 +28264,11 @@ function createFileServer(options) {
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     const server = serve({ fetch: app.fetch, port }, (info) => {
       const actualPort = info.port;
       const url = `http://localhost:${actualPort}`;
-      resolve36({
+      resolve37({
         url,
         port: actualPort,
         close: () => server.close()
@@ -30502,8 +30529,20 @@ var init_hyperframeRuntimeLoader = __esm({
 // ../producer/src/services/fileServer.ts
 import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { readFileSync as readFileSync18, existsSync as existsSync25, statSync as statSync7 } from "fs";
-import { join as join27, extname as extname7 } from "path";
+import { readFileSync as readFileSync18, existsSync as existsSync25, realpathSync, statSync as statSync7 } from "fs";
+import { join as join27, extname as extname7, resolve as resolve13, sep as sep3 } from "path";
+function isPathInside(child, parent, options = {}) {
+  const { resolveSymlinks = false, pathModule } = options;
+  const resolveFn = pathModule?.resolve ?? resolve13;
+  const separator = pathModule?.sep ?? sep3;
+  const resolvedChild = resolveFn(child);
+  const resolvedParent = resolveFn(parent);
+  const normalizedChild = resolveSymlinks && existsSync25(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync25(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
+  if (normalizedChild === normalizedParent) return true;
+  const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
+  return normalizedChild.startsWith(parentWithSep);
+}
 function stripEmbeddedRuntimeScripts3(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -30586,12 +30625,20 @@ function createFileServer2(options) {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join27(compiledDir, relativePath) : null;
-    const hasCompiledFile = Boolean(
-      compiledPath && existsSync25(compiledPath) && statSync7(compiledPath).isFile()
-    );
-    const filePath = hasCompiledFile ? compiledPath : join27(projectDir, relativePath);
-    if (!existsSync25(filePath) || !statSync7(filePath).isFile()) {
+    let filePath = null;
+    if (compiledDir) {
+      const candidate = join27(compiledDir, relativePath);
+      if (existsSync25(candidate) && isPathInside(candidate, compiledDir, { resolveSymlinks: true }) && statSync7(candidate).isFile()) {
+        filePath = candidate;
+      }
+    }
+    if (!filePath) {
+      const candidate = join27(projectDir, relativePath);
+      if (existsSync25(candidate) && isPathInside(candidate, projectDir, { resolveSymlinks: true }) && statSync7(candidate).isFile()) {
+        filePath = candidate;
+      }
+    }
+    if (!filePath) {
       if (!/favicon\.ico$/i.test(requestPath)) {
         console.warn(`[FileServer] 404 Not Found: ${requestPath}`);
       }
@@ -30615,10 +30662,10 @@ function createFileServer2(options) {
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     const connections = /* @__PURE__ */ new Set();
     const server = serve2({ fetch: app.fetch, port }, (info) => {
-      resolve36({
+      resolve37({
         url: `http://localhost:${info.port}`,
         port: info.port,
         close: () => {
@@ -30961,10 +31008,10 @@ var init_ffprobe2 = __esm({
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve13, basename, join as join28, relative as relative2, isAbsolute as isAbsolute3 } from "path";
-function isPathInside(childPath, parentPath) {
-  const absChild = resolve13(childPath);
-  const absParent = resolve13(parentPath);
+import { resolve as resolve14, basename, join as join28, relative as relative2, isAbsolute as isAbsolute3 } from "path";
+function isPathInside2(childPath, parentPath) {
+  const absChild = resolve14(childPath);
+  const absParent = resolve14(parentPath);
   if (absChild === absParent) return true;
   const rel = relative2(absParent, absChild);
   return rel !== "" && !rel.startsWith("..") && !isAbsolute3(rel);
@@ -30980,17 +31027,17 @@ function toExternalAssetKey(absPath) {
   return "hf-ext/" + normalised;
 }
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
-  const absoluteProjectDir = resolve13(projectDir);
+  const absoluteProjectDir = resolve14(projectDir);
   const projectName = basename(absoluteProjectDir);
   const resolvedOutputPath = outputPath ?? join28(rendersDir, `${projectName}.mp4`);
-  const absoluteOutputPath = resolve13(resolvedOutputPath);
+  const absoluteOutputPath = resolve14(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
 var DEFAULT_RENDERS_DIR;
 var init_paths = __esm({
   "../producer/src/utils/paths.ts"() {
     "use strict";
-    DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve13(new URL(import.meta.url).pathname, "../../..", "renders");
+    DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve14(new URL(import.meta.url).pathname, "../../..", "renders");
   }
 });
 
@@ -31394,7 +31441,7 @@ var init_deterministicFonts = __esm({
 
 // ../producer/src/services/htmlCompiler.ts
 import { readFileSync as readFileSync20, existsSync as existsSync27, mkdirSync as mkdirSync16 } from "fs";
-import { join as join30, dirname as dirname9, resolve as resolve14 } from "path";
+import { join as join30, dirname as dirname9, resolve as resolve15 } from "path";
 import postcss from "postcss";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -31519,7 +31566,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     const elEnd = elEndRaw ? parseFloat(elEndRaw) : Infinity;
     const absoluteStart = parentOffset + elStart;
     const absoluteEnd = Math.min(parentEnd, isFinite(elEnd) ? parentOffset + elEnd : Infinity);
-    const filePath = resolve14(projectDir, srcPath);
+    const filePath = resolve15(projectDir, srcPath);
     if (visited.has(filePath)) {
       continue;
     }
@@ -31732,7 +31779,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     if (!srcPath) continue;
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
-      const filePath = resolve14(projectDir, srcPath);
+      const filePath = resolve15(projectDir, srcPath);
       if (existsSync27(filePath)) {
         compHtml = readFileSync20(filePath, "utf-8");
       }
@@ -31949,7 +31996,7 @@ ${safeText}
   return wrappedFragment ? document2.body.innerHTML || "" : document2.toString();
 }
 function collectExternalAssets(html, projectDir) {
-  const absProjectDir = resolve14(projectDir);
+  const absProjectDir = resolve15(projectDir);
   const externalAssets = /* @__PURE__ */ new Map();
   const CSS_URL_RE2 = /\burl\(\s*(["']?)([^)"']+)\1\s*\)/g;
   function processPath(rawPath) {
@@ -31957,8 +32004,8 @@ function collectExternalAssets(html, projectDir) {
     if (!trimmed || trimmed.startsWith("/") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("//") || trimmed.startsWith("data:") || trimmed.startsWith("#")) {
       return null;
     }
-    const absPath = resolve14(absProjectDir, trimmed);
-    if (isPathInside(absPath, absProjectDir)) {
+    const absPath = resolve15(absProjectDir, trimmed);
+    if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
     if (!existsSync27(absPath)) return null;
@@ -32038,7 +32085,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir) {
   const images = dedupeElementsById([...mainImages, ...subImages]);
   for (const video of videos) {
     if (isHttpUrl(video.src)) continue;
-    const videoPath = resolve14(projectDir, video.src);
+    const videoPath = resolve15(projectDir, video.src);
     const reencode = `ffmpeg -i "${video.src}" -c:v libx264 -r 30 -g 30 -keyint_min 30 -movflags +faststart -c:a copy output.mp4`;
     Promise.all([analyzeKeyframeIntervals(videoPath), extractVideoMetadata(videoPath)]).then(([analysis, metadata]) => {
       if (analysis.isProblematic) {
@@ -32244,7 +32291,7 @@ import {
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join31, dirname as dirname10, resolve as resolve15 } from "path";
+import { join as join31, dirname as dirname10, resolve as resolve16 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -32325,8 +32372,8 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
     writeFileSync10(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve15(join31(compileDir, relativePath));
-    if (!isPathInside(outPath, compileDir)) {
+    const outPath = resolve16(join31(compileDir, relativePath));
+    if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
@@ -32513,7 +32560,7 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
 }
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
   const moduleDir = dirname10(fileURLToPath3(import.meta.url));
-  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve15(process.env.PRODUCER_RENDERS_DIR, "..") : resolve15(moduleDir, "../..");
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve16(process.env.PRODUCER_RENDERS_DIR, "..") : resolve16(moduleDir, "../..");
   const debugDir = join31(producerRoot, ".debug");
   const workDir = job.config.debug ? join31(debugDir, job.id) : join31(dirname10(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
@@ -32957,6 +33004,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
     const preset = getEncoderPreset(job.config.quality, outputFormat, encoderHdr);
+    if (job.config.crf != null && job.config.videoBitrate) {
+      log2.warn(
+        `[Render] Both crf=${job.config.crf} and videoBitrate=${job.config.videoBitrate} were set. These are mutually exclusive; honoring crf and ignoring videoBitrate. Set only one to silence this warning.`
+      );
+    }
+    const effectiveQuality = job.config.crf ?? preset.quality;
+    const effectiveBitrate = job.config.crf != null ? void 0 : job.config.videoBitrate;
     job.framesRendered = 0;
     if (hasHdrContent) {
       log2.info("[Render] HDR layered composite: z-ordered DOM + native HLG video layers");
@@ -32980,411 +33034,251 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         createVideoFrameInjector(frameLookup),
         cfg
       );
-      await initializeSession(domSession);
-      assertNotAborted();
-      lastBrowserConsole = domSession.browserConsoleBuffer;
-      await initTransparentBackground(domSession.page);
-      const transitionMeta = await domSession.page.evaluate(() => {
-        return window.__hf?.transitions ?? [];
-      });
-      const sceneElements = await domSession.page.evaluate(() => {
-        const scenes = document.querySelectorAll(".scene");
-        const map = {};
-        for (const scene of scenes) {
-          const els = scene.querySelectorAll("[data-start]");
-          map[scene.id] = Array.from(els).map((e2) => e2.id);
-        }
-        return map;
-      });
-      const transitionRanges = transitionMeta.map((t3) => ({
-        ...t3,
-        startFrame: Math.floor(t3.time * job.config.fps),
-        endFrame: Math.ceil((t3.time + t3.duration) * job.config.fps)
-      }));
-      if (transitionRanges.length > 0) {
-        log2.info("[Render] Detected shader transitions for HDR compositing", {
-          count: transitionRanges.length,
-          transitions: transitionRanges.map((t3) => ({
-            shader: t3.shader,
-            from: t3.fromScene,
-            to: t3.toScene,
-            frames: `${t3.startFrame}-${t3.endFrame}`
-          }))
-        });
-      }
-      const hdrEncoder = await spawnStreamingEncoder(
-        videoOnlyPath,
-        {
-          fps: job.config.fps,
-          width,
-          height,
-          codec: preset.codec,
-          preset: preset.preset,
-          quality: preset.quality,
-          pixelFormat: preset.pixelFormat,
-          hdr: preset.hdr,
-          rawInputFormat: "rgb48le"
-        },
-        abortSignal,
-        { ffmpegStreamingTimeout: 36e5 }
-      );
-      assertNotAborted();
-      const hdrExtractionDims = /* @__PURE__ */ new Map();
-      const hdrImageFitInfo = /* @__PURE__ */ new Map();
-      const hdrVideoStartTimes = /* @__PURE__ */ new Map();
-      for (const v of composition.videos) {
-        if (hdrVideoIds.includes(v.id)) {
-          hdrVideoStartTimes.set(v.id, v.start);
-        }
-      }
-      const hdrImageStartTimes = /* @__PURE__ */ new Map();
-      for (const img of composition.images) {
-        if (nativeHdrImageIds.has(img.id)) {
-          hdrImageStartTimes.set(img.id, img.start);
-        }
-      }
-      const uniqueStartTimes = [
-        .../* @__PURE__ */ new Set([...hdrVideoStartTimes.values(), ...hdrImageStartTimes.values()])
-      ].sort((a, b) => a - b);
-      for (const seekTime of uniqueStartTimes) {
-        await domSession.page.evaluate((t3) => {
-          if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
-        }, seekTime);
-        if (domSession.onBeforeCapture) {
-          await domSession.onBeforeCapture(domSession.page, seekTime);
-        }
-        const stacking = await queryElementStacking(domSession.page, nativeHdrIds);
-        for (const el of stacking) {
-          if (el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0 && !hdrExtractionDims.has(el.id)) {
-            hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
-          }
-          if (el.isHdr && nativeHdrImageIds.has(el.id) && !hdrImageFitInfo.has(el.id)) {
-            hdrImageFitInfo.set(el.id, {
-              fit: el.objectFit,
-              position: el.objectPosition
-            });
-          }
-        }
-      }
+      let hdrEncoder = null;
+      let hdrEncoderClosed = false;
+      let domSessionClosed = false;
       const hdrFrameDirs = /* @__PURE__ */ new Map();
-      for (const [videoId, srcPath] of hdrVideoSrcPaths) {
-        const video = composition.videos.find((v) => v.id === videoId);
-        if (!video) continue;
-        const frameDir = join31(framesDir, `hdr_${videoId}`);
-        mkdirSync17(frameDir, { recursive: true });
-        const duration = video.end - video.start;
-        const dims = hdrExtractionDims.get(videoId) ?? { width, height };
-        const ffmpegArgs = [
-          "-ss",
-          String(video.mediaStart),
-          "-i",
-          srcPath,
-          "-t",
-          String(duration),
-          "-r",
-          String(job.config.fps),
-          "-vf",
-          `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`,
-          "-pix_fmt",
-          "rgb48le",
-          "-c:v",
-          "png",
-          "-y",
-          join31(frameDir, "frame_%04d.png")
-        ];
-        const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
-        if (!result.success) {
-          hdrDiagnostics.videoExtractionFailures += 1;
-          log2.error("HDR frame pre-extraction failed; aborting render", {
-            videoId,
-            srcPath,
-            stderr: result.stderr.slice(-400)
+      try {
+        await initializeSession(domSession);
+        assertNotAborted();
+        lastBrowserConsole = domSession.browserConsoleBuffer;
+        await initTransparentBackground(domSession.page);
+        const transitionMeta = await domSession.page.evaluate(() => {
+          return window.__hf?.transitions ?? [];
+        });
+        const sceneElements = await domSession.page.evaluate(() => {
+          const scenes = document.querySelectorAll(".scene");
+          const map = {};
+          for (const scene of scenes) {
+            const els = scene.querySelectorAll("[data-start]");
+            map[scene.id] = Array.from(els).map((e2) => e2.id);
+          }
+          return map;
+        });
+        const transitionRanges = transitionMeta.map((t3) => ({
+          ...t3,
+          startFrame: Math.floor(t3.time * job.config.fps),
+          endFrame: Math.ceil((t3.time + t3.duration) * job.config.fps)
+        }));
+        if (transitionRanges.length > 0) {
+          log2.info("[Render] Detected shader transitions for HDR compositing", {
+            count: transitionRanges.length,
+            transitions: transitionRanges.map((t3) => ({
+              shader: t3.shader,
+              from: t3.fromScene,
+              to: t3.toScene,
+              frames: `${t3.startFrame}-${t3.endFrame}`
+            }))
           });
-          throw new Error(
-            `HDR frame extraction failed for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
-          );
         }
-        hdrFrameDirs.set(videoId, frameDir);
-      }
-      const hdrImageBuffers = /* @__PURE__ */ new Map();
-      for (const [imageId, srcPath] of hdrImageSrcPaths) {
-        try {
-          const decoded = decodePngToRgb48le(readFileSync21(srcPath));
-          const layout2 = hdrExtractionDims.get(imageId);
-          const fitInfo = hdrImageFitInfo.get(imageId);
-          if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
-            const fit = normalizeObjectFit(fitInfo?.fit);
-            const resampled = resampleRgb48leObjectFit(
-              decoded.data,
-              decoded.width,
-              decoded.height,
-              layout2.width,
-              layout2.height,
-              fit,
-              fitInfo?.position
-            );
-            hdrImageBuffers.set(imageId, {
-              data: resampled,
-              width: layout2.width,
-              height: layout2.height
-            });
-          } else {
-            hdrImageBuffers.set(imageId, {
-              data: Buffer.from(decoded.data),
-              width: decoded.width,
-              height: decoded.height
-            });
+        hdrEncoder = await spawnStreamingEncoder(
+          videoOnlyPath,
+          {
+            fps: job.config.fps,
+            width,
+            height,
+            codec: preset.codec,
+            preset: preset.preset,
+            quality: effectiveQuality,
+            bitrate: effectiveBitrate,
+            pixelFormat: preset.pixelFormat,
+            hdr: preset.hdr,
+            rawInputFormat: "rgb48le"
+          },
+          abortSignal,
+          { ffmpegStreamingTimeout: 36e5 }
+        );
+        assertNotAborted();
+        const hdrExtractionDims = /* @__PURE__ */ new Map();
+        const hdrImageFitInfo = /* @__PURE__ */ new Map();
+        const hdrVideoStartTimes = /* @__PURE__ */ new Map();
+        for (const v of composition.videos) {
+          if (hdrVideoIds.includes(v.id)) {
+            hdrVideoStartTimes.set(v.id, v.start);
           }
-        } catch (err) {
-          hdrDiagnostics.imageDecodeFailures += 1;
-          log2.error("HDR image decode failed; aborting render", {
-            imageId,
-            srcPath,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          throw new Error(
-            `HDR image decode failed for image "${imageId}". Aborting render to avoid shipping missing HDR image layers.`
-          );
         }
-      }
-      assertNotAborted();
-      try {
-        let countNonZeroAlpha2 = function(rgba) {
-          let n = 0;
-          for (let p = 3; p < rgba.length; p += 4) {
-            if (rgba[p] !== 0) n++;
+        const hdrImageStartTimes = /* @__PURE__ */ new Map();
+        for (const img of composition.images) {
+          if (nativeHdrImageIds.has(img.id)) {
+            hdrImageStartTimes.set(img.id, img.start);
           }
-          return n;
-        }, countNonZeroRgb482 = function(buf) {
-          let n = 0;
-          for (let p = 0; p < buf.length; p += 6) {
-            if (buf[p] !== 0 || buf[p + 1] !== 0 || buf[p + 2] !== 0) n++;
+        }
+        const uniqueStartTimes = [
+          .../* @__PURE__ */ new Set([...hdrVideoStartTimes.values(), ...hdrImageStartTimes.values()])
+        ].sort((a, b) => a - b);
+        for (const seekTime of uniqueStartTimes) {
+          await domSession.page.evaluate((t3) => {
+            if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
+          }, seekTime);
+          if (domSession.onBeforeCapture) {
+            await domSession.onBeforeCapture(domSession.page, seekTime);
+          }
+          const stacking = await queryElementStacking(domSession.page, nativeHdrIds);
+          for (const el of stacking) {
+            if (el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0 && !hdrExtractionDims.has(el.id)) {
+              hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+            }
+            if (el.isHdr && nativeHdrImageIds.has(el.id) && !hdrImageFitInfo.has(el.id)) {
+              hdrImageFitInfo.set(el.id, {
+                fit: el.objectFit,
+                position: el.objectPosition
+              });
+            }
           }
-          return n;
-        };
-        var countNonZeroAlpha = countNonZeroAlpha2, countNonZeroRgb48 = countNonZeroRgb482;
-        const beforeCaptureHook = domSession.onBeforeCapture;
-        const cleanedUpVideos = /* @__PURE__ */ new Set();
-        const hdrVideoEndTimes = /* @__PURE__ */ new Map();
-        for (const v of composition.videos) {
-          if (hdrFrameDirs.has(v.id)) {
-            hdrVideoEndTimes.set(v.id, v.end);
-          }
-        }
-        const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-        const debugDumpDir = debugDumpEnabled ? join31(framesDir, "debug-composite") : null;
-        if (debugDumpDir && !existsSync28(debugDumpDir)) {
-          mkdirSync17(debugDumpDir, { recursive: true });
-        }
-        async function compositeToBuffer(canvas, time, fullStacking, elementFilter, debugFrameIndex = -1) {
-          const filteredStacking = elementFilter ? fullStacking.filter((e2) => elementFilter.has(e2.id)) : fullStacking;
-          const layers = groupIntoLayers(filteredStacking);
-          const shouldLog = debugDumpEnabled && debugFrameIndex >= 0;
-          if (shouldLog) {
-            log2.info("[diag] compositeToBuffer plan", {
-              frame: debugFrameIndex,
-              time: time.toFixed(3),
-              filterSize: elementFilter?.size,
-              fullStackingCount: fullStacking.length,
-              filteredCount: filteredStacking.length,
-              layerCount: layers.length,
-              layers: layers.map(
-                (l) => l.type === "hdr" ? {
-                  type: "hdr",
-                  id: l.element.id,
-                  z: l.element.zIndex,
-                  visible: l.element.visible,
-                  opacity: l.element.opacity,
-                  bounds: `${Math.round(l.element.x)},${Math.round(l.element.y)} ${Math.round(l.element.width)}x${Math.round(l.element.height)}`
-                } : { type: "dom", ids: l.elementIds }
-              )
+        }
+        for (const [videoId, srcPath] of hdrVideoSrcPaths) {
+          const video = composition.videos.find((v) => v.id === videoId);
+          if (!video) continue;
+          const frameDir = join31(framesDir, `hdr_${videoId}`);
+          mkdirSync17(frameDir, { recursive: true });
+          const duration = video.end - video.start;
+          const dims = hdrExtractionDims.get(videoId) ?? { width, height };
+          const ffmpegArgs = [
+            "-ss",
+            String(video.mediaStart),
+            "-i",
+            srcPath,
+            "-t",
+            String(duration),
+            "-r",
+            String(job.config.fps),
+            "-vf",
+            `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`,
+            "-pix_fmt",
+            "rgb48le",
+            "-c:v",
+            "png",
+            "-y",
+            join31(frameDir, "frame_%04d.png")
+          ];
+          const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
+          if (!result.success) {
+            hdrDiagnostics.videoExtractionFailures += 1;
+            log2.error("HDR frame pre-extraction failed; aborting render", {
+              videoId,
+              srcPath,
+              stderr: result.stderr.slice(-400)
             });
+            throw new Error(
+              `HDR frame extraction failed for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
+            );
           }
-          for (const [layerIdx, layer] of layers.entries()) {
-            if (layer.type === "hdr") {
-              const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
-              const isHdrImage = nativeHdrImageIds.has(layer.element.id);
-              if (isHdrImage) {
-                blitHdrImageLayer(
-                  canvas,
-                  layer.element,
-                  hdrImageBuffers,
-                  width,
-                  height,
-                  log2,
-                  imageTransfers.get(layer.element.id),
-                  effectiveHdr?.transfer
-                );
-              } else {
-                blitHdrVideoLayer(
-                  canvas,
-                  layer.element,
-                  time,
-                  job.config.fps,
-                  hdrFrameDirs,
-                  hdrVideoStartTimes,
-                  width,
-                  height,
-                  log2,
-                  videoTransfers.get(layer.element.id),
-                  effectiveHdr?.transfer
-                );
-              }
-              if (shouldLog) {
-                const after2 = countNonZeroRgb482(canvas);
-                if (isHdrImage) {
-                  const buf = hdrImageBuffers.get(layer.element.id);
-                  log2.info("[diag] hdr layer blit", {
-                    frame: debugFrameIndex,
-                    layerIdx,
-                    id: layer.element.id,
-                    kind: "image",
-                    pixelsAdded: after2 - before2,
-                    totalNonZero: after2,
-                    bufferDecoded: !!buf,
-                    bufferDims: buf ? `${buf.width}x${buf.height}` : null
-                  });
-                } else {
-                  const frameDir = hdrFrameDirs.get(layer.element.id);
-                  const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
-                  const localTime = time - startTime;
-                  const frameNum = Math.floor(localTime * job.config.fps) + 1;
-                  const expectedFrame = frameDir ? join31(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
-                  log2.info("[diag] hdr layer blit", {
-                    frame: debugFrameIndex,
-                    layerIdx,
-                    id: layer.element.id,
-                    kind: "video",
-                    pixelsAdded: after2 - before2,
-                    totalNonZero: after2,
-                    startTime,
-                    localTime: localTime.toFixed(3),
-                    hdrFrameNum: frameNum,
-                    expectedFrame,
-                    expectedFrameExists: expectedFrame ? existsSync28(expectedFrame) : false
-                  });
-                }
-              }
+          hdrFrameDirs.set(videoId, frameDir);
+        }
+        const hdrImageBuffers = /* @__PURE__ */ new Map();
+        for (const [imageId, srcPath] of hdrImageSrcPaths) {
+          try {
+            const decoded = decodePngToRgb48le(readFileSync21(srcPath));
+            const layout2 = hdrExtractionDims.get(imageId);
+            const fitInfo = hdrImageFitInfo.get(imageId);
+            if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
+              const fit = normalizeObjectFit(fitInfo?.fit);
+              const resampled = resampleRgb48leObjectFit(
+                decoded.data,
+                decoded.width,
+                decoded.height,
+                layout2.width,
+                layout2.height,
+                fit,
+                fitInfo?.position
+              );
+              hdrImageBuffers.set(imageId, {
+                data: resampled,
+                width: layout2.width,
+                height: layout2.height
+              });
             } else {
-              const allElementIds = fullStacking.map((e2) => e2.id);
-              const layerIds = new Set(layer.elementIds);
-              const hideIds = allElementIds.filter((id) => !layerIds.has(id));
-              await domSession.page.evaluate((t3) => {
-                if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
-              }, time);
-              if (beforeCaptureHook) {
-                await beforeCaptureHook(domSession.page, time);
-              }
-              await applyDomLayerMask(domSession.page, layer.elementIds, hideIds);
-              const domPng = await captureAlphaPng(domSession.page, width, height);
-              await removeDomLayerMask(domSession.page, hideIds);
-              try {
-                const { data: domRgba } = decodePng(domPng);
-                if (!effectiveHdr) {
-                  throw new Error(
-                    "Invariant violation: effectiveHdr is undefined inside HDR layer branch"
-                  );
-                }
-                const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
-                const alphaPixels = shouldLog ? countNonZeroAlpha2(domRgba) : 0;
-                blitRgba8OverRgb48le(domRgba, canvas, width, height, effectiveHdr.transfer);
-                if (shouldLog && debugDumpDir) {
-                  const after2 = countNonZeroRgb482(canvas);
-                  const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-                  const dumpPath = join31(debugDumpDir, dumpName);
-                  writeFileSync10(dumpPath, domPng);
-                  log2.info("[diag] dom layer blit", {
-                    frame: debugFrameIndex,
-                    layerIdx,
-                    layerIds: layer.elementIds,
-                    hideCount: hideIds.length,
-                    pngBytes: domPng.length,
-                    alphaPixels,
-                    pixelsAdded: after2 - before2,
-                    totalNonZero: after2,
-                    dumpPath
-                  });
-                }
-              } catch (err) {
-                log2.warn("DOM layer decode/blit failed; skipping overlay", {
-                  layerIds: layer.elementIds,
-                  error: err instanceof Error ? err.message : String(err)
-                });
-              }
+              hdrImageBuffers.set(imageId, {
+                data: Buffer.from(decoded.data),
+                width: decoded.width,
+                height: decoded.height
+              });
             }
-          }
-          if (shouldLog && debugDumpDir) {
-            const finalNonZero = countNonZeroRgb482(canvas);
-            log2.info("[diag] compositeToBuffer end", {
-              frame: debugFrameIndex,
-              finalNonZeroPixels: finalNonZero,
-              totalPixels: width * height,
-              coverage: (finalNonZero / (width * height) * 100).toFixed(1) + "%"
+          } catch (err) {
+            hdrDiagnostics.imageDecodeFailures += 1;
+            log2.error("HDR image decode failed; aborting render", {
+              imageId,
+              srcPath,
+              error: err instanceof Error ? err.message : String(err)
             });
+            throw new Error(
+              `HDR image decode failed for image "${imageId}". Aborting render to avoid shipping missing HDR image layers.`
+            );
           }
         }
-        const bufSize = width * height * 6;
-        const hasTransitions = transitionRanges.length > 0;
-        const transBufferA = hasTransitions ? Buffer.alloc(bufSize) : null;
-        const transBufferB = hasTransitions ? Buffer.alloc(bufSize) : null;
-        const transOutput = hasTransitions ? Buffer.alloc(bufSize) : null;
-        const normalCanvas = Buffer.alloc(bufSize);
-        for (let i2 = 0; i2 < totalFrames; i2++) {
-          assertNotAborted();
-          const time = i2 / job.config.fps;
-          await domSession.page.evaluate((t3) => {
-            if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
-          }, time);
-          if (beforeCaptureHook) {
-            await beforeCaptureHook(domSession.page, time);
-          }
-          const stackingInfo = await queryElementStacking(domSession.page, nativeHdrIds);
-          const activeTransition = transitionRanges.find(
-            (t3) => i2 >= t3.startFrame && i2 <= t3.endFrame
-          );
-          if (i2 % 30 === 0) {
-            const hdrEl = stackingInfo.find((e2) => e2.isHdr);
-            log2.debug("[Render] HDR layer composite frame", {
-              frame: i2,
-              time: time.toFixed(2),
-              hdrElement: hdrEl ? { z: hdrEl.zIndex, visible: hdrEl.visible, width: hdrEl.width } : null,
-              stackingCount: stackingInfo.length,
-              activeTransition: activeTransition?.shader
-            });
+        assertNotAborted();
+        try {
+          let countNonZeroAlpha2 = function(rgba) {
+            let n = 0;
+            for (let p = 3; p < rgba.length; p += 4) {
+              if (rgba[p] !== 0) n++;
+            }
+            return n;
+          }, countNonZeroRgb482 = function(buf) {
+            let n = 0;
+            for (let p = 0; p < buf.length; p += 6) {
+              if (buf[p] !== 0 || buf[p + 1] !== 0 || buf[p + 2] !== 0 || buf[p + 3] !== 0 || buf[p + 4] !== 0 || buf[p + 5] !== 0)
+                n++;
+            }
+            return n;
+          };
+          var countNonZeroAlpha = countNonZeroAlpha2, countNonZeroRgb48 = countNonZeroRgb482;
+          const beforeCaptureHook = domSession.onBeforeCapture;
+          const cleanedUpVideos = /* @__PURE__ */ new Set();
+          const hdrVideoEndTimes = /* @__PURE__ */ new Map();
+          for (const v of composition.videos) {
+            if (hdrFrameDirs.has(v.id)) {
+              hdrVideoEndTimes.set(v.id, v.end);
+            }
           }
-          if (activeTransition && transBufferA && transBufferB && transOutput) {
-            const progress = activeTransition.endFrame === activeTransition.startFrame ? 1 : (i2 - activeTransition.startFrame) / (activeTransition.endFrame - activeTransition.startFrame);
-            const sceneAIds = new Set(sceneElements[activeTransition.fromScene] ?? []);
-            const sceneBIds = new Set(sceneElements[activeTransition.toScene] ?? []);
-            transBufferA.fill(0);
-            transBufferB.fill(0);
-            for (const [sceneBuf, sceneIds] of [
-              [transBufferA, sceneAIds],
-              [transBufferB, sceneBIds]
-            ]) {
-              await domSession.page.evaluate((t3) => {
-                if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
-              }, time);
-              if (beforeCaptureHook) {
-                await beforeCaptureHook(domSession.page, time);
-              }
-              for (const el of stackingInfo) {
-                if (!el.isHdr || !sceneIds.has(el.id)) continue;
-                if (nativeHdrImageIds.has(el.id)) {
+          const debugDumpEnabled = process.env.KEEP_TEMP === "1";
+          const debugDumpDir = debugDumpEnabled ? join31(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync28(debugDumpDir)) {
+            mkdirSync17(debugDumpDir, { recursive: true });
+          }
+          async function compositeToBuffer(canvas, time, fullStacking, elementFilter, debugFrameIndex = -1) {
+            const filteredStacking = elementFilter ? fullStacking.filter((e2) => elementFilter.has(e2.id)) : fullStacking;
+            const layers = groupIntoLayers(filteredStacking);
+            const shouldLog = debugDumpEnabled && debugFrameIndex >= 0;
+            if (shouldLog) {
+              log2.info("[diag] compositeToBuffer plan", {
+                frame: debugFrameIndex,
+                time: time.toFixed(3),
+                filterSize: elementFilter?.size,
+                fullStackingCount: fullStacking.length,
+                filteredCount: filteredStacking.length,
+                layerCount: layers.length,
+                layers: layers.map(
+                  (l) => l.type === "hdr" ? {
+                    type: "hdr",
+                    id: l.element.id,
+                    z: l.element.zIndex,
+                    visible: l.element.visible,
+                    opacity: l.element.opacity,
+                    bounds: `${Math.round(l.element.x)},${Math.round(l.element.y)} ${Math.round(l.element.width)}x${Math.round(l.element.height)}`
+                  } : { type: "dom", ids: l.elementIds }
+                )
+              });
+            }
+            for (const [layerIdx, layer] of layers.entries()) {
+              if (layer.type === "hdr") {
+                const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
+                const isHdrImage = nativeHdrImageIds.has(layer.element.id);
+                if (isHdrImage) {
                   blitHdrImageLayer(
-                    sceneBuf,
-                    el,
+                    canvas,
+                    layer.element,
                     hdrImageBuffers,
                     width,
                     height,
                     log2,
-                    imageTransfers.get(el.id),
+                    imageTransfers.get(layer.element.id),
                     effectiveHdr?.transfer
                   );
                 } else {
                   blitHdrVideoLayer(
-                    sceneBuf,
-                    el,
+                    canvas,
+                    layer.element,
                     time,
                     job.config.fps,
                     hdrFrameDirs,
@@ -33392,100 +33286,294 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                     width,
                     height,
                     log2,
-                    videoTransfers.get(el.id),
+                    videoTransfers.get(layer.element.id),
                     effectiveHdr?.transfer
                   );
                 }
+                if (shouldLog) {
+                  const after2 = countNonZeroRgb482(canvas);
+                  if (isHdrImage) {
+                    const buf = hdrImageBuffers.get(layer.element.id);
+                    log2.info("[diag] hdr layer blit", {
+                      frame: debugFrameIndex,
+                      layerIdx,
+                      id: layer.element.id,
+                      kind: "image",
+                      pixelsAdded: after2 - before2,
+                      totalNonZero: after2,
+                      bufferDecoded: !!buf,
+                      bufferDims: buf ? `${buf.width}x${buf.height}` : null
+                    });
+                  } else {
+                    const frameDir = hdrFrameDirs.get(layer.element.id);
+                    const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
+                    const localTime = time - startTime;
+                    const frameNum = Math.floor(localTime * job.config.fps) + 1;
+                    const expectedFrame = frameDir ? join31(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
+                    log2.info("[diag] hdr layer blit", {
+                      frame: debugFrameIndex,
+                      layerIdx,
+                      id: layer.element.id,
+                      kind: "video",
+                      pixelsAdded: after2 - before2,
+                      totalNonZero: after2,
+                      startTime,
+                      localTime: localTime.toFixed(3),
+                      hdrFrameNum: frameNum,
+                      expectedFrame,
+                      expectedFrameExists: expectedFrame ? existsSync28(expectedFrame) : false
+                    });
+                  }
+                }
+              } else {
+                const allElementIds = fullStacking.map((e2) => e2.id);
+                const layerIds = new Set(layer.elementIds);
+                const hideIds = allElementIds.filter((id) => !layerIds.has(id));
+                await domSession.page.evaluate((t3) => {
+                  if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
+                }, time);
+                if (beforeCaptureHook) {
+                  await beforeCaptureHook(domSession.page, time);
+                }
+                await applyDomLayerMask(domSession.page, layer.elementIds, hideIds);
+                const domPng = await captureAlphaPng(domSession.page, width, height);
+                await removeDomLayerMask(domSession.page, hideIds);
+                try {
+                  const { data: domRgba } = decodePng(domPng);
+                  if (!effectiveHdr) {
+                    throw new Error(
+                      "Invariant violation: effectiveHdr is undefined inside HDR layer branch"
+                    );
+                  }
+                  const before2 = shouldLog ? countNonZeroRgb482(canvas) : 0;
+                  const alphaPixels = shouldLog ? countNonZeroAlpha2(domRgba) : 0;
+                  blitRgba8OverRgb48le(domRgba, canvas, width, height, effectiveHdr.transfer);
+                  if (shouldLog && debugDumpDir) {
+                    const after2 = countNonZeroRgb482(canvas);
+                    const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
+                    const dumpPath = join31(debugDumpDir, dumpName);
+                    writeFileSync10(dumpPath, domPng);
+                    log2.info("[diag] dom layer blit", {
+                      frame: debugFrameIndex,
+                      layerIdx,
+                      layerIds: layer.elementIds,
+                      hideCount: hideIds.length,
+                      pngBytes: domPng.length,
+                      alphaPixels,
+                      pixelsAdded: after2 - before2,
+                      totalNonZero: after2,
+                      dumpPath
+                    });
+                  }
+                } catch (err) {
+                  log2.warn("DOM layer decode/blit failed; skipping overlay", {
+                    layerIds: layer.elementIds,
+                    error: err instanceof Error ? err.message : String(err)
+                  });
+                }
               }
-              const showIds = Array.from(sceneIds);
-              const hideIds = stackingInfo.map((e2) => e2.id).filter((id) => !sceneIds.has(id) || nativeHdrIds.has(id));
-              await applyDomLayerMask(domSession.page, showIds, hideIds);
-              const domPng = await captureAlphaPng(domSession.page, width, height);
-              await removeDomLayerMask(domSession.page, hideIds);
-              try {
-                const { data: domRgba } = decodePng(domPng);
-                if (!effectiveHdr) {
-                  throw new Error(
-                    "Invariant violation: effectiveHdr is undefined inside hasHdrVideo branch"
+            }
+            if (shouldLog && debugDumpDir) {
+              const finalNonZero = countNonZeroRgb482(canvas);
+              log2.info("[diag] compositeToBuffer end", {
+                frame: debugFrameIndex,
+                finalNonZeroPixels: finalNonZero,
+                totalPixels: width * height,
+                coverage: (finalNonZero / (width * height) * 100).toFixed(1) + "%"
+              });
+            }
+          }
+          const bufSize = width * height * 6;
+          const hasTransitions = transitionRanges.length > 0;
+          const transBufferA = hasTransitions ? Buffer.alloc(bufSize) : null;
+          const transBufferB = hasTransitions ? Buffer.alloc(bufSize) : null;
+          const transOutput = hasTransitions ? Buffer.alloc(bufSize) : null;
+          const normalCanvas = Buffer.alloc(bufSize);
+          for (let i2 = 0; i2 < totalFrames; i2++) {
+            assertNotAborted();
+            const time = i2 / job.config.fps;
+            await domSession.page.evaluate((t3) => {
+              if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
+            }, time);
+            if (beforeCaptureHook) {
+              await beforeCaptureHook(domSession.page, time);
+            }
+            const stackingInfo = await queryElementStacking(domSession.page, nativeHdrIds);
+            const activeTransition = transitionRanges.find(
+              (t3) => i2 >= t3.startFrame && i2 <= t3.endFrame
+            );
+            if (i2 % 30 === 0) {
+              const hdrEl = stackingInfo.find((e2) => e2.isHdr);
+              log2.debug("[Render] HDR layer composite frame", {
+                frame: i2,
+                time: time.toFixed(2),
+                hdrElement: hdrEl ? { z: hdrEl.zIndex, visible: hdrEl.visible, width: hdrEl.width } : null,
+                stackingCount: stackingInfo.length,
+                activeTransition: activeTransition?.shader
+              });
+            }
+            if (activeTransition && transBufferA && transBufferB && transOutput) {
+              const progress = activeTransition.endFrame === activeTransition.startFrame ? 1 : (i2 - activeTransition.startFrame) / (activeTransition.endFrame - activeTransition.startFrame);
+              const sceneAIds = new Set(sceneElements[activeTransition.fromScene] ?? []);
+              const sceneBIds = new Set(sceneElements[activeTransition.toScene] ?? []);
+              transBufferA.fill(0);
+              transBufferB.fill(0);
+              for (const [sceneBuf, sceneIds] of [
+                [transBufferA, sceneAIds],
+                [transBufferB, sceneBIds]
+              ]) {
+                assertNotAborted();
+                await domSession.page.evaluate((t3) => {
+                  if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
+                }, time);
+                if (beforeCaptureHook) {
+                  await beforeCaptureHook(domSession.page, time);
+                }
+                for (const el of stackingInfo) {
+                  if (!el.isHdr || !sceneIds.has(el.id)) continue;
+                  if (nativeHdrImageIds.has(el.id)) {
+                    blitHdrImageLayer(
+                      sceneBuf,
+                      el,
+                      hdrImageBuffers,
+                      width,
+                      height,
+                      log2,
+                      imageTransfers.get(el.id),
+                      effectiveHdr?.transfer
+                    );
+                  } else {
+                    blitHdrVideoLayer(
+                      sceneBuf,
+                      el,
+                      time,
+                      job.config.fps,
+                      hdrFrameDirs,
+                      hdrVideoStartTimes,
+                      width,
+                      height,
+                      log2,
+                      videoTransfers.get(el.id),
+                      effectiveHdr?.transfer
+                    );
+                  }
+                }
+                const showIds = Array.from(sceneIds);
+                const hideIds = stackingInfo.map((e2) => e2.id).filter((id) => !sceneIds.has(id) || nativeHdrIds.has(id));
+                await applyDomLayerMask(domSession.page, showIds, hideIds);
+                const domPng = await captureAlphaPng(domSession.page, width, height);
+                await removeDomLayerMask(domSession.page, hideIds);
+                try {
+                  const { data: domRgba } = decodePng(domPng);
+                  if (!effectiveHdr) {
+                    throw new Error(
+                      "Invariant violation: effectiveHdr is undefined inside hasHdrVideo branch"
+                    );
+                  }
+                  blitRgba8OverRgb48le(
+                    domRgba,
+                    sceneBuf,
+                    width,
+                    height,
+                    effectiveHdr.transfer
                   );
+                } catch (err) {
+                  log2.warn("DOM layer decode/blit failed; skipping overlay for transition scene", {
+                    frameIndex: i2,
+                    sceneIds: Array.from(sceneIds),
+                    error: err instanceof Error ? err.message : String(err)
+                  });
                 }
-                blitRgba8OverRgb48le(
-                  domRgba,
-                  sceneBuf,
-                  width,
-                  height,
-                  effectiveHdr.transfer
+              }
+              const transitionFn = TRANSITIONS[activeTransition.shader] ?? crossfade;
+              transitionFn(transBufferA, transBufferB, transOutput, width, height, progress);
+              hdrEncoder.writeFrame(transOutput);
+            } else {
+              normalCanvas.fill(0);
+              await compositeToBuffer(normalCanvas, time, stackingInfo, void 0, i2);
+              if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
+                const previewPath = join31(
+                  debugDumpDir,
+                  `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
                 );
-              } catch (err) {
-                log2.warn("DOM layer decode/blit failed; skipping overlay for transition scene", {
-                  frameIndex: i2,
-                  sceneIds: Array.from(sceneIds),
-                  error: err instanceof Error ? err.message : String(err)
-                });
+                writeFileSync10(previewPath, normalCanvas);
               }
+              hdrEncoder.writeFrame(normalCanvas);
             }
-            const transitionFn = TRANSITIONS[activeTransition.shader] ?? crossfade;
-            transitionFn(transBufferA, transBufferB, transOutput, width, height, progress);
-            hdrEncoder.writeFrame(transOutput);
-          } else {
-            normalCanvas.fill(0);
-            await compositeToBuffer(normalCanvas, time, stackingInfo, void 0, i2);
-            if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-              const previewPath = join31(
-                debugDumpDir,
-                `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
-              );
-              writeFileSync10(previewPath, normalCanvas);
-            }
-            hdrEncoder.writeFrame(normalCanvas);
-          }
-          if (process.env.KEEP_TEMP !== "1") {
-            for (const [videoId, endTime] of hdrVideoEndTimes) {
-              if (time > endTime && !cleanedUpVideos.has(videoId)) {
-                const stillNeeded = activeTransition && (sceneElements[activeTransition.fromScene]?.includes(videoId) || sceneElements[activeTransition.toScene]?.includes(videoId));
-                if (!stillNeeded) {
-                  const frameDir = hdrFrameDirs.get(videoId);
-                  if (frameDir) {
-                    try {
-                      rmSync6(frameDir, { recursive: true, force: true });
-                    } catch (err) {
-                      log2.warn("Failed to clean up HDR frame directory", {
-                        videoId,
-                        frameDir,
-                        error: err instanceof Error ? err.message : String(err)
-                      });
+            if (process.env.KEEP_TEMP !== "1") {
+              for (const [videoId, endTime] of hdrVideoEndTimes) {
+                if (time > endTime && !cleanedUpVideos.has(videoId)) {
+                  const stillNeeded = activeTransition && (sceneElements[activeTransition.fromScene]?.includes(videoId) || sceneElements[activeTransition.toScene]?.includes(videoId));
+                  if (!stillNeeded) {
+                    const frameDir = hdrFrameDirs.get(videoId);
+                    if (frameDir) {
+                      try {
+                        rmSync6(frameDir, { recursive: true, force: true });
+                      } catch (err) {
+                        log2.warn("Failed to clean up HDR frame directory", {
+                          videoId,
+                          frameDir,
+                          error: err instanceof Error ? err.message : String(err)
+                        });
+                      }
+                      frameDirMaxIndexCache.delete(frameDir);
+                      hdrFrameDirs.delete(videoId);
                     }
+                    cleanedUpVideos.add(videoId);
                   }
-                  cleanedUpVideos.add(videoId);
                 }
               }
             }
+            job.framesRendered = i2 + 1;
+            if ((i2 + 1) % 10 === 0 || i2 + 1 === totalFrames) {
+              const frameProgress = (i2 + 1) / totalFrames;
+              updateJobStatus(
+                job,
+                "rendering",
+                `HDR composite frame ${i2 + 1}/${job.totalFrames}`,
+                Math.round(25 + frameProgress * 55),
+                onProgress
+              );
+            }
           }
-          job.framesRendered = i2 + 1;
-          if ((i2 + 1) % 10 === 0 || i2 + 1 === totalFrames) {
-            const frameProgress = (i2 + 1) / totalFrames;
-            updateJobStatus(
-              job,
-              "rendering",
-              `HDR composite frame ${i2 + 1}/${job.totalFrames}`,
-              Math.round(25 + frameProgress * 55),
-              onProgress
-            );
-          }
+        } finally {
+          lastBrowserConsole = domSession.browserConsoleBuffer;
+          await closeCaptureSession(domSession);
+          domSessionClosed = true;
         }
+        const hdrEncodeResult = await hdrEncoder.close();
+        hdrEncoderClosed = true;
+        assertNotAborted();
+        if (!hdrEncodeResult.success) {
+          throw new Error(`HDR encode failed: ${hdrEncodeResult.error}`);
+        }
+        perfStages.captureMs = Date.now() - stage4Start;
+        perfStages.encodeMs = hdrEncodeResult.durationMs;
       } finally {
-        lastBrowserConsole = domSession.browserConsoleBuffer;
-        await closeCaptureSession(domSession);
-      }
-      const hdrEncodeResult = await hdrEncoder.close();
-      assertNotAborted();
-      if (!hdrEncodeResult.success) {
-        throw new Error(`HDR encode failed: ${hdrEncodeResult.error}`);
+        if (hdrEncoder && !hdrEncoderClosed) {
+          try {
+            await hdrEncoder.close();
+          } catch (err) {
+            log2.warn("hdrEncoder defensive close failed", {
+              err: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+        if (!domSessionClosed) {
+          await closeCaptureSession(domSession).catch((err) => {
+            log2.warn("closeCaptureSession defensive close failed", {
+              err: err instanceof Error ? err.message : String(err)
+            });
+          });
+        }
+        for (const frameDir of hdrFrameDirs.values()) {
+          frameDirMaxIndexCache.delete(frameDir);
+        }
+        hdrFrameDirs.clear();
       }
-      perfStages.captureMs = Date.now() - stage4Start;
-      perfStages.encodeMs = hdrEncodeResult.durationMs;
     } else {
       let streamingEncoder = null;
+      let streamingEncoderClosed = false;
       if (enableStreamingEncode) {
         streamingEncoder = await spawnStreamingEncoder(
           videoOnlyPath,
@@ -33495,7 +33583,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             height,
             codec: preset.codec,
             preset: preset.preset,
-            quality: preset.quality,
+            quality: effectiveQuality,
+            bitrate: effectiveBitrate,
             pixelFormat: preset.pixelFormat,
             useGpu: job.config.useGpu,
             imageFormat: captureOptions.format || "jpeg",
@@ -33505,201 +33594,215 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         );
         assertNotAborted();
       }
-      if (enableStreamingEncode && streamingEncoder) {
-        const reorderBuffer = createFrameReorderBuffer(0, totalFrames);
-        const currentEncoder = streamingEncoder;
-        if (workerCount > 1) {
-          const tasks = distributeFrames(job.totalFrames, workerCount, workDir);
-          const onFrameBuffer = async (frameIndex, buffer) => {
-            await reorderBuffer.waitForFrame(frameIndex);
-            currentEncoder.writeFrame(buffer);
-            reorderBuffer.advanceTo(frameIndex + 1);
-          };
-          await executeParallelCapture(
-            fileServer.url,
-            workDir,
-            tasks,
-            { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
-            () => createVideoFrameInjector(frameLookup),
-            abortSignal,
-            (progress) => {
-              job.framesRendered = progress.capturedFrames;
-              const frameProgress = progress.capturedFrames / progress.totalFrames;
-              const progressPct = 25 + frameProgress * 55;
-              if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
+      try {
+        if (enableStreamingEncode && streamingEncoder) {
+          const reorderBuffer = createFrameReorderBuffer(0, totalFrames);
+          const currentEncoder = streamingEncoder;
+          if (workerCount > 1) {
+            const tasks = distributeFrames(job.totalFrames, workerCount, workDir);
+            const onFrameBuffer = async (frameIndex, buffer) => {
+              await reorderBuffer.waitForFrame(frameIndex);
+              currentEncoder.writeFrame(buffer);
+              reorderBuffer.advanceTo(frameIndex + 1);
+            };
+            await executeParallelCapture(
+              fileServer.url,
+              workDir,
+              tasks,
+              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              () => createVideoFrameInjector(frameLookup),
+              abortSignal,
+              (progress) => {
+                job.framesRendered = progress.capturedFrames;
+                const frameProgress = progress.capturedFrames / progress.totalFrames;
+                const progressPct = 25 + frameProgress * 55;
+                if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
+                  updateJobStatus(
+                    job,
+                    "rendering",
+                    `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
+                    Math.round(progressPct),
+                    onProgress
+                  );
+                }
+              },
+              onFrameBuffer,
+              cfg
+            );
+            if (probeSession) {
+              lastBrowserConsole = probeSession.browserConsoleBuffer;
+              await closeCaptureSession(probeSession);
+              probeSession = null;
+            }
+          } else {
+            const videoInjector = createVideoFrameInjector(frameLookup);
+            const session = probeSession ?? await createCaptureSession(
+              fileServer.url,
+              framesDir,
+              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              videoInjector,
+              cfg
+            );
+            if (probeSession) {
+              prepareCaptureSessionForReuse(session, framesDir, videoInjector);
+              probeSession = null;
+            }
+            try {
+              if (!session.isInitialized) {
+                await initializeSession(session);
+              }
+              assertNotAborted();
+              lastBrowserConsole = session.browserConsoleBuffer;
+              for (let i2 = 0; i2 < totalFrames; i2++) {
+                assertNotAborted();
+                const time = i2 / job.config.fps;
+                const { buffer } = await captureFrameToBuffer(session, i2, time);
+                await reorderBuffer.waitForFrame(i2);
+                currentEncoder.writeFrame(buffer);
+                reorderBuffer.advanceTo(i2 + 1);
+                job.framesRendered = i2 + 1;
+                const frameProgress = (i2 + 1) / totalFrames;
+                const progress = 25 + frameProgress * 55;
                 updateJobStatus(
                   job,
                   "rendering",
-                  `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-                  Math.round(progressPct),
+                  `Streaming frame ${i2 + 1}/${job.totalFrames}`,
+                  Math.round(progress),
                   onProgress
                 );
               }
-            },
-            onFrameBuffer,
-            cfg
-          );
-          if (probeSession) {
-            lastBrowserConsole = probeSession.browserConsoleBuffer;
-            await closeCaptureSession(probeSession);
-            probeSession = null;
+            } finally {
+              lastBrowserConsole = session.browserConsoleBuffer;
+              await closeCaptureSession(session);
+            }
           }
-        } else {
-          const videoInjector = createVideoFrameInjector(frameLookup);
-          const session = probeSession ?? await createCaptureSession(
-            fileServer.url,
-            framesDir,
-            { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
-            videoInjector,
-            cfg
-          );
-          if (probeSession) {
-            prepareCaptureSessionForReuse(session, framesDir, videoInjector);
-            probeSession = null;
+          const encodeResult = await currentEncoder.close();
+          streamingEncoderClosed = true;
+          assertNotAborted();
+          if (!encodeResult.success) {
+            throw new Error(`Streaming encode failed: ${encodeResult.error}`);
           }
-          try {
-            if (!session.isInitialized) {
-              await initializeSession(session);
+          perfStages.captureMs = Date.now() - stage4Start;
+          perfStages.encodeMs = encodeResult.durationMs;
+        } else {
+          if (workerCount > 1) {
+            const tasks = distributeFrames(job.totalFrames, workerCount, workDir);
+            await executeParallelCapture(
+              fileServer.url,
+              workDir,
+              tasks,
+              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              () => createVideoFrameInjector(frameLookup),
+              abortSignal,
+              (progress) => {
+                job.framesRendered = progress.capturedFrames;
+                const frameProgress = progress.capturedFrames / progress.totalFrames;
+                const progressPct = 25 + frameProgress * 45;
+                if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
+                  updateJobStatus(
+                    job,
+                    "rendering",
+                    `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
+                    Math.round(progressPct),
+                    onProgress
+                  );
+                }
+              },
+              void 0,
+              cfg
+            );
+            await mergeWorkerFrames(workDir, tasks, framesDir);
+            if (probeSession) {
+              lastBrowserConsole = probeSession.browserConsoleBuffer;
+              await closeCaptureSession(probeSession);
+              probeSession = null;
             }
-            assertNotAborted();
-            lastBrowserConsole = session.browserConsoleBuffer;
-            for (let i2 = 0; i2 < totalFrames; i2++) {
-              assertNotAborted();
-              const time = i2 / job.config.fps;
-              const { buffer } = await captureFrameToBuffer(session, i2, time);
-              await reorderBuffer.waitForFrame(i2);
-              currentEncoder.writeFrame(buffer);
-              reorderBuffer.advanceTo(i2 + 1);
-              job.framesRendered = i2 + 1;
-              const frameProgress = (i2 + 1) / totalFrames;
-              const progress = 25 + frameProgress * 55;
-              updateJobStatus(
-                job,
-                "rendering",
-                `Streaming frame ${i2 + 1}/${job.totalFrames}`,
-                Math.round(progress),
-                onProgress
-              );
+          } else {
+            const videoInjector = createVideoFrameInjector(frameLookup);
+            const session = probeSession ?? await createCaptureSession(
+              fileServer.url,
+              framesDir,
+              { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
+              videoInjector,
+              cfg
+            );
+            if (probeSession) {
+              prepareCaptureSessionForReuse(session, framesDir, videoInjector);
+              probeSession = null;
             }
-          } finally {
-            lastBrowserConsole = session.browserConsoleBuffer;
-            await closeCaptureSession(session);
-          }
-        }
-        const encodeResult = await currentEncoder.close();
-        assertNotAborted();
-        if (!encodeResult.success) {
-          throw new Error(`Streaming encode failed: ${encodeResult.error}`);
-        }
-        perfStages.captureMs = Date.now() - stage4Start;
-        perfStages.encodeMs = encodeResult.durationMs;
-      } else {
-        if (workerCount > 1) {
-          const tasks = distributeFrames(job.totalFrames, workerCount, workDir);
-          await executeParallelCapture(
-            fileServer.url,
-            workDir,
-            tasks,
-            { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
-            () => createVideoFrameInjector(frameLookup),
-            abortSignal,
-            (progress) => {
-              job.framesRendered = progress.capturedFrames;
-              const frameProgress = progress.capturedFrames / progress.totalFrames;
-              const progressPct = 25 + frameProgress * 45;
-              if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
+            try {
+              if (!session.isInitialized) {
+                await initializeSession(session);
+              }
+              assertNotAborted();
+              lastBrowserConsole = session.browserConsoleBuffer;
+              for (let i2 = 0; i2 < job.totalFrames; i2++) {
+                assertNotAborted();
+                const time = i2 / job.config.fps;
+                await captureFrame(session, i2, time);
+                job.framesRendered = i2 + 1;
+                const frameProgress = (i2 + 1) / job.totalFrames;
+                const progress = 25 + frameProgress * 45;
                 updateJobStatus(
                   job,
                   "rendering",
-                  `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-                  Math.round(progressPct),
+                  `Capturing frame ${i2 + 1}/${job.totalFrames}`,
+                  Math.round(progress),
                   onProgress
                 );
               }
-            },
-            void 0,
-            cfg
-          );
-          await mergeWorkerFrames(workDir, tasks, framesDir);
-          if (probeSession) {
-            lastBrowserConsole = probeSession.browserConsoleBuffer;
-            await closeCaptureSession(probeSession);
-            probeSession = null;
+            } finally {
+              lastBrowserConsole = session.browserConsoleBuffer;
+              await closeCaptureSession(session);
+            }
           }
-        } else {
-          const videoInjector = createVideoFrameInjector(frameLookup);
-          const session = probeSession ?? await createCaptureSession(
-            fileServer.url,
+          perfStages.captureMs = Date.now() - stage4Start;
+          const stage5Start = Date.now();
+          updateJobStatus(job, "encoding", "Encoding video", 75, onProgress);
+          const frameExt = needsAlpha ? "png" : "jpg";
+          const framePattern = `frame_%06d.${frameExt}`;
+          const encoderOpts = {
+            fps: job.config.fps,
+            width,
+            height,
+            codec: preset.codec,
+            preset: preset.preset,
+            quality: effectiveQuality,
+            bitrate: effectiveBitrate,
+            pixelFormat: preset.pixelFormat,
+            useGpu: job.config.useGpu,
+            hdr: preset.hdr
+          };
+          const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
+            framesDir,
+            framePattern,
+            videoOnlyPath,
+            encoderOpts,
+            chunkedEncodeSize,
+            abortSignal
+          ) : await encodeFramesFromDir(
             framesDir,
-            { ...captureOptions, skipReadinessVideoIds: Array.from(nativeHdrVideoIds) },
-            videoInjector,
-            cfg
+            framePattern,
+            videoOnlyPath,
+            encoderOpts,
+            abortSignal
           );
-          if (probeSession) {
-            prepareCaptureSessionForReuse(session, framesDir, videoInjector);
-            probeSession = null;
+          assertNotAborted();
+          if (!encodeResult.success) {
+            throw new Error(`Encoding failed: ${encodeResult.error}`);
           }
+          perfStages.encodeMs = Date.now() - stage5Start;
+        }
+      } finally {
+        if (streamingEncoder && !streamingEncoderClosed) {
           try {
-            if (!session.isInitialized) {
-              await initializeSession(session);
-            }
-            assertNotAborted();
-            lastBrowserConsole = session.browserConsoleBuffer;
-            for (let i2 = 0; i2 < job.totalFrames; i2++) {
-              assertNotAborted();
-              const time = i2 / job.config.fps;
-              await captureFrame(session, i2, time);
-              job.framesRendered = i2 + 1;
-              const frameProgress = (i2 + 1) / job.totalFrames;
-              const progress = 25 + frameProgress * 45;
-              updateJobStatus(
-                job,
-                "rendering",
-                `Capturing frame ${i2 + 1}/${job.totalFrames}`,
-                Math.round(progress),
-                onProgress
-              );
-            }
-          } finally {
-            lastBrowserConsole = session.browserConsoleBuffer;
-            await closeCaptureSession(session);
+            await streamingEncoder.close();
+          } catch (err) {
+            log2.warn("streamingEncoder defensive close failed", {
+              err: err instanceof Error ? err.message : String(err)
+            });
           }
         }
-        perfStages.captureMs = Date.now() - stage4Start;
-        const stage5Start = Date.now();
-        updateJobStatus(job, "encoding", "Encoding video", 75, onProgress);
-        const frameExt = needsAlpha ? "png" : "jpg";
-        const framePattern = `frame_%06d.${frameExt}`;
-        const encoderOpts = {
-          fps: job.config.fps,
-          width,
-          height,
-          codec: preset.codec,
-          preset: preset.preset,
-          quality: preset.quality,
-          pixelFormat: preset.pixelFormat,
-          useGpu: job.config.useGpu,
-          hdr: preset.hdr
-        };
-        const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
-          framesDir,
-          framePattern,
-          videoOnlyPath,
-          encoderOpts,
-          chunkedEncodeSize,
-          abortSignal
-        ) : await encodeFramesFromDir(
-          framesDir,
-          framePattern,
-          videoOnlyPath,
-          encoderOpts,
-          abortSignal
-        );
-        assertNotAborted();
-        if (!encodeResult.success) {
-          throw new Error(`Encoding failed: ${encodeResult.error}`);
-        }
-        perfStages.encodeMs = Date.now() - stage5Start;
       }
     }
     if (probeSession !== null) {
@@ -33909,7 +34012,7 @@ var init_config3 = __esm({
 
 // ../producer/src/services/hyperframeLint.ts
 import { existsSync as existsSync29, readFileSync as readFileSync22, statSync as statSync8 } from "fs";
-import { resolve as resolve16, join as join32 } from "path";
+import { resolve as resolve17, join as join32 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -33936,7 +34039,7 @@ function pickEntryFile(files, preferredEntryFile) {
   return null;
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
-  const absProjectDir = resolve16(projectDir);
+  const absProjectDir = resolve17(projectDir);
   if (!existsSync29(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
@@ -33944,7 +34047,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     (value) => typeof value === "string" && value.trim().length > 0
   );
   for (const entryFile of entryCandidates) {
-    const absoluteEntryPath = resolve16(absProjectDir, entryFile);
+    const absoluteEntryPath = resolve17(absProjectDir, entryFile);
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
@@ -34019,10 +34122,10 @@ var init_semaphore = __esm({
           this.active++;
           return () => this.release();
         }
-        return new Promise((resolve36) => {
+        return new Promise((resolve37) => {
           this.queue.push(() => {
             this.active++;
-            resolve36(() => this.release());
+            resolve37(() => this.release());
           });
         });
       }
@@ -34053,7 +34156,7 @@ import {
   rmSync as rmSync7,
   createReadStream
 } from "fs";
-import { resolve as resolve17, dirname as dirname11, join as join33 } from "path";
+import { resolve as resolve18, dirname as dirname11, join as join33 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -34075,12 +34178,12 @@ async function prepareRenderBody(body) {
   const options = parseRenderOptions(body);
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
-    const absProjectDir = resolve17(projectDir);
+    const absProjectDir = resolve18(projectDir);
     if (!existsSync30(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync30(resolve17(absProjectDir, entry))) {
+    if (!existsSync30(resolve18(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -34121,7 +34224,7 @@ function resolveOutputPath(projectDir, outputCandidate, rendersDir, log2) {
   try {
     return resolveRenderPaths(projectDir, outputCandidate, rendersDir).absoluteOutputPath;
   } catch (error) {
-    const fallbackPath = resolve17(rendersDir, `producer-fallback-${Date.now()}.mp4`);
+    const fallbackPath = resolve18(rendersDir, `producer-fallback-${Date.now()}.mp4`);
     log2.warn("Failed to resolve output path, using fallback", {
       fallback: fallbackPath,
       error: error instanceof Error ? error.message : String(error)
@@ -34509,7 +34612,7 @@ var init_server = __esm({
     init_paths();
     init_logger();
     init_semaphore();
-    entryScript = process.argv[1] ? resolve17(process.argv[1]) : "";
+    entryScript = process.argv[1] ? resolve18(process.argv[1]) : "";
     isPublicServerEntry = entryScript.endsWith("/public-server.js") || entryScript.endsWith("/src/server.ts");
     if (isPublicServerEntry) {
       const { values } = parseArgs2({
@@ -34582,18 +34685,18 @@ __export(studioServer_exports, {
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
 import { existsSync as existsSync31, readFileSync as readFileSync23, writeFileSync as writeFileSync12, statSync as statSync10 } from "fs";
-import { resolve as resolve18, join as join34, basename as basename2 } from "path";
+import { resolve as resolve19, join as join34, basename as basename2 } from "path";
 function resolveDistDir() {
-  const builtPath = resolve18(__dirname, "studio");
-  if (existsSync31(resolve18(builtPath, "index.html"))) return builtPath;
-  const devPath = resolve18(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync31(resolve18(devPath, "index.html"))) return devPath;
+  const builtPath = resolve19(__dirname, "studio");
+  if (existsSync31(resolve19(builtPath, "index.html"))) return builtPath;
+  const devPath = resolve19(__dirname, "..", "..", "..", "studio", "dist");
+  if (existsSync31(resolve19(devPath, "index.html"))) return devPath;
   return builtPath;
 }
 function resolveRuntimePath() {
-  const builtPath = resolve18(__dirname, "hyperframe-runtime.js");
+  const builtPath = resolve19(__dirname, "hyperframe-runtime.js");
   if (existsSync31(builtPath)) return builtPath;
-  const devPath = resolve18(
+  const devPath = resolve19(
     __dirname,
     "..",
     "..",
@@ -34814,7 +34917,7 @@ function createStudioServer(options) {
     return api.fetch(forwardReq);
   });
   app.get("/assets/*", (c2) => {
-    const filePath = resolve18(studioDir, c2.req.path.slice(1));
+    const filePath = resolve19(studioDir, c2.req.path.slice(1));
     if (!existsSync31(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync23(filePath);
     return new Response(content, {
@@ -34822,7 +34925,7 @@ function createStudioServer(options) {
     });
   });
   app.get("/icons/*", (c2) => {
-    const filePath = resolve18(studioDir, c2.req.path.slice(1));
+    const filePath = resolve19(studioDir, c2.req.path.slice(1));
     if (!existsSync31(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync23(filePath);
     return new Response(content, {
@@ -34830,7 +34933,7 @@ function createStudioServer(options) {
     });
   });
   app.get("*", (c2) => {
-    const indexPath = resolve18(studioDir, "index.html");
+    const indexPath = resolve19(studioDir, "index.html");
     if (!existsSync31(indexPath)) {
       return c2.text("Studio not found. Rebuild with: pnpm run build", 500);
     }
@@ -34859,12 +34962,12 @@ __export(preview_exports, {
 });
 import { spawn as spawn8 } from "child_process";
 import { existsSync as existsSync32, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync19 } from "fs";
-import { resolve as resolve19, dirname as dirname12, basename as basename3, join as join35 } from "path";
+import { resolve as resolve20, dirname as dirname12, basename as basename3, join as join35 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire } from "module";
 async function runDevMode(dir, projectName) {
   const thisFile = fileURLToPath4(import.meta.url);
-  const repoRoot = resolve19(dirname12(thisFile), "..", "..", "..", "..");
+  const repoRoot = resolve20(dirname12(thisFile), "..", "..", "..", "..");
   const projectsDir = join35(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename3(dir);
   const symlinkPath = join35(projectsDir, pName);
@@ -34876,7 +34979,7 @@ async function runDevMode(dir, projectName) {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
           const target = readlinkSync(symlinkPath);
-          if (resolve19(target) !== resolve19(dir)) {
+          if (resolve20(target) !== resolve20(dir)) {
             unlinkSync5(symlinkPath);
           }
         }
@@ -34930,8 +35033,8 @@ async function runDevMode(dir, projectName) {
       }
     });
   }
-  return new Promise((resolve36) => {
-    child.on("close", () => resolve36());
+  return new Promise((resolve37) => {
+    child.on("close", () => resolve37());
   });
 }
 function hasLocalStudio(dir) {
@@ -34953,7 +35056,7 @@ async function runLocalStudioMode(dir, projectName) {
   let createdSymlink = false;
   if (dir !== symlinkPath) {
     if (existsSync32(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
-      if (resolve19(readlinkSync(symlinkPath)) !== resolve19(dir)) {
+      if (resolve20(readlinkSync(symlinkPath)) !== resolve20(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
@@ -35001,8 +35104,8 @@ async function runLocalStudioMode(dir, projectName) {
       }
     });
   }
-  return new Promise((resolve36) => {
-    child.on("close", () => resolve36());
+  return new Promise((resolve37) => {
+    child.on("close", () => resolve37());
   });
 }
 async function runEmbeddedMode(dir, startPort, projectName, forceNew = false) {
@@ -35133,7 +35236,7 @@ var init_preview2 = __esm({
           return;
         }
         const rawArg = args.dir;
-        const dir = resolve19(rawArg ?? ".");
+        const dir = resolve20(rawArg ?? ".");
         const isImplicitCwd = !rawArg || rawArg === "." || rawArg === "./";
         const projectName = isImplicitCwd ? basename3(process.env.PWD ?? dir) : basename3(dir);
         const indexPath = join35(dir, "index.html");
@@ -35174,7 +35277,7 @@ import {
   readFileSync as readFileSync24,
   readdirSync as readdirSync12
 } from "fs";
-import { resolve as resolve20, basename as basename4, join as join36, dirname as dirname13 } from "path";
+import { resolve as resolve21, basename as basename4, join as join36, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { execFileSync as execFileSync4, spawn as spawn9 } from "child_process";
 function probeVideo(filePath) {
@@ -35244,8 +35347,8 @@ function transcodeToMp4(inputPath, outputPath) {
 }
 function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname13(fileURLToPath5(import.meta.url));
-  const devPath = resolve20(base, ...devSegments);
-  const builtPath = resolve20(base, ...builtSegments);
+  const devPath = resolve21(base, ...devSegments);
+  const builtPath = resolve21(base, ...builtSegments);
   return existsSync33(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
@@ -35330,7 +35433,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
       }
       if (shouldTranscode) {
         const mp4Name = localVideoName.replace(/\.[^.]+$/, ".mp4");
-        const mp4Path = resolve20(destDir, mp4Name);
+        const mp4Path = resolve21(destDir, mp4Name);
         const spin = be();
         spin.start("Transcoding to H.264 MP4...");
         const ok = await transcodeToMp4(videoPath, mp4Path);
@@ -35339,10 +35442,10 @@ async function handleVideoFile(videoPath, destDir, interactive) {
           localVideoName = mp4Name;
         } else {
           spin.stop(c.warn("Transcode failed \u2014 copying original file"));
-          copyFileSync3(videoPath, resolve20(destDir, localVideoName));
+          copyFileSync3(videoPath, resolve21(destDir, localVideoName));
         }
       } else {
-        copyFileSync3(videoPath, resolve20(destDir, localVideoName));
+        copyFileSync3(videoPath, resolve21(destDir, localVideoName));
       }
     } else {
       if (interactive) {
@@ -35352,10 +35455,10 @@ async function handleVideoFile(videoPath, destDir, interactive) {
         console.log(c.warn("ffmpeg not installed \u2014 cannot transcode. Copying original."));
         console.log(c.dim("Install: ") + c.accent("brew install ffmpeg"));
       }
-      copyFileSync3(videoPath, resolve20(destDir, localVideoName));
+      copyFileSync3(videoPath, resolve21(destDir, localVideoName));
     }
   } else {
-    copyFileSync3(videoPath, resolve20(destDir, localVideoName));
+    copyFileSync3(videoPath, resolve21(destDir, localVideoName));
   }
   return { meta, localVideoName };
 }
@@ -35369,7 +35472,7 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
   }
   patchVideoSrc(destDir, localVideoName, durationSeconds);
   writeFileSync13(
-    resolve20(destDir, "meta.json"),
+    resolve21(destDir, "meta.json"),
     JSON.stringify(
       {
         id: name,
@@ -35381,7 +35484,7 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync33(resolve20(destDir, "hyperframes.json"))) {
+  if (!existsSync33(resolve21(destDir, "hyperframes.json"))) {
     const { writeProjectConfig: writeProjectConfig2, DEFAULT_PROJECT_CONFIG: DEFAULT_PROJECT_CONFIG2 } = await Promise.resolve().then(() => (init_projectConfig(), projectConfig_exports));
     writeProjectConfig2(destDir, DEFAULT_PROJECT_CONFIG2);
   }
@@ -35389,7 +35492,7 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
   if (existsSync33(sharedDir)) {
     for (const entry of readdirSync12(sharedDir, { withFileTypes: true })) {
       const src = join36(sharedDir, entry.name);
-      const dest = resolve20(destDir, entry.name);
+      const dest = resolve21(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
       }
@@ -35501,7 +35604,7 @@ var init_init = __esm({
         if (!interactive) {
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
-          const destDir2 = resolve20(name2);
+          const destDir2 = resolve21(name2);
           if (existsSync33(destDir2) && readdirSync12(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
@@ -35515,7 +35618,7 @@ var init_init = __esm({
             process.exit(1);
           }
           if (videoFlag) {
-            const videoPath = resolve20(videoFlag);
+            const videoPath = resolve21(videoFlag);
             if (!existsSync33(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
@@ -35529,13 +35632,13 @@ var init_init = __esm({
             );
           }
           if (audioFlag) {
-            const audioPath = resolve20(audioFlag);
+            const audioPath = resolve21(audioFlag);
             if (!existsSync33(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
             sourceFilePath2 = audioPath;
-            copyFileSync3(audioPath, resolve20(destDir2, basename4(audioPath)));
+            copyFileSync3(audioPath, resolve21(destDir2, basename4(audioPath)));
             console.log(`Audio: ${basename4(audioPath)}`);
           }
           if (sourceFilePath2 && !skipTranscribe) {
@@ -35575,7 +35678,7 @@ var init_init = __esm({
             process.exit(1);
           }
           trackInitTemplate(templateId2);
-          const transcriptFile2 = resolve20(destDir2, "transcript.json");
+          const transcriptFile2 = resolve21(destDir2, "transcript.json");
           if (existsSync33(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
@@ -35627,7 +35730,7 @@ var init_init = __esm({
           }
           name = nameResult;
         }
-        const destDir = resolve20(name);
+        const destDir = resolve21(name);
         if (existsSync33(destDir) && readdirSync12(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
@@ -35642,7 +35745,7 @@ var init_init = __esm({
         let sourceFilePath;
         let videoDuration;
         if (videoFlag) {
-          const videoPath = resolve20(videoFlag);
+          const videoPath = resolve21(videoFlag);
           if (!existsSync33(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
@@ -35654,7 +35757,7 @@ var init_init = __esm({
           localVideoName = result.localVideoName;
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
-          const audioPath = resolve20(audioFlag);
+          const audioPath = resolve21(audioFlag);
           if (!existsSync33(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
@@ -35662,7 +35765,7 @@ var init_init = __esm({
           }
           mkdirSync20(destDir, { recursive: true });
           sourceFilePath = audioPath;
-          copyFileSync3(audioPath, resolve20(destDir, basename4(audioPath)));
+          copyFileSync3(audioPath, resolve21(destDir, basename4(audioPath)));
           R2.info(`Audio copied to ${c.accent(basename4(audioPath))}`);
         }
         if (sourceFilePath) {
@@ -35747,7 +35850,7 @@ ${c.dim("Use --example blank for offline use.")}`
           process.exit(1);
         }
         trackInitTemplate(templateId);
-        const transcriptFile = resolve20(destDir, "transcript.json");
+        const transcriptFile = resolve21(destDir, "transcript.json");
         if (existsSync33(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
@@ -35835,7 +35938,7 @@ __export(add_exports, {
   runAdd: () => runAdd
 });
 import { existsSync as existsSync34 } from "fs";
-import { resolve as resolve21, relative as relative3 } from "path";
+import { resolve as resolve22, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
     const blocksDir = paths.blocks.replace(/\/+$/, "");
@@ -35858,10 +35961,10 @@ function buildSnippet(item, relativeTarget) {
   return "";
 }
 async function runAdd(opts) {
-  const projectDir = resolve21(opts.projectDir);
+  const projectDir = resolve22(opts.projectDir);
   let config = loadProjectConfig(projectDir);
   const hasConfig = existsSync34(projectConfigPath(projectDir));
-  if (!hasConfig && existsSync34(resolve21(projectDir, "index.html"))) {
+  if (!hasConfig && existsSync34(resolve22(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -35957,7 +36060,7 @@ var init_add = __esm({
         }
       },
       async run({ args }) {
-        const projectDir = resolve21(args.dir ?? process.cwd());
+        const projectDir = resolve22(args.dir ?? process.cwd());
         const json = args.json === true;
         const skipClipboard = args["no-clipboard"] === true;
         const hasConfigBefore = existsSync34(projectConfigPath(projectDir));
@@ -36005,7 +36108,7 @@ __export(catalog_exports, {
   default: () => catalog_default,
   examples: () => examples4
 });
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 var examples4, catalog_default;
 var init_catalog = __esm({
   "src/commands/catalog.ts"() {
@@ -36049,7 +36152,7 @@ var init_catalog = __esm({
       async run({ args }) {
         const json = args.json === true;
         const interactive = args["human-friendly"] === true;
-        const dir = resolve22(process.cwd());
+        const dir = resolve23(process.cwd());
         const config = loadProjectConfig(dir) ?? DEFAULT_PROJECT_CONFIG;
         let typeFilter;
         if (args.type === "block") typeFilter = "hyperframes:block";
@@ -36174,11 +36277,11 @@ var init_format = __esm({
 
 // src/utils/project.ts
 import { existsSync as existsSync35, statSync as statSync11 } from "fs";
-import { resolve as resolve23, basename as basename5 } from "path";
+import { resolve as resolve24, basename as basename5 } from "path";
 function resolveProject(dirArg) {
-  const dir = resolve23(dirArg ?? ".");
+  const dir = resolve24(dirArg ?? ".");
   const name = basename5(dir);
-  const indexPath = resolve23(dir, "index.html");
+  const indexPath = resolve24(dir, "index.html");
   if (!existsSync35(dir) || !statSync11(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
@@ -36207,7 +36310,7 @@ __export(play_exports, {
   examples: () => examples5
 });
 import { existsSync as existsSync36, readFileSync as readFileSync25 } from "fs";
-import { resolve as resolve24, dirname as dirname14 } from "path";
+import { resolve as resolve25, dirname as dirname14 } from "path";
 function commandDir() {
   return dirname14(new URL(import.meta.url).pathname);
 }
@@ -36215,10 +36318,10 @@ function resolveRuntimePath2() {
   const d = commandDir();
   const candidates = [
     // Bundled with CLI dist
-    resolve24(d, "hyperframe-runtime.js"),
-    resolve24(d, "..", "hyperframe-runtime.js"),
+    resolve25(d, "hyperframe-runtime.js"),
+    resolve25(d, "..", "hyperframe-runtime.js"),
     // Monorepo dev: commands/ → src/ → cli/ → packages/ then into core/dist/
-    resolve24(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
+    resolve25(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
     if (existsSync36(p)) return p;
@@ -36229,10 +36332,10 @@ function resolvePlayerPath() {
   const d = commandDir();
   const candidates = [
     // Monorepo dev: commands/ → src/ → cli/ → packages/ then into player/dist/
-    resolve24(d, "..", "..", "..", "player", "dist", "hyperframes-player.global.js"),
+    resolve25(d, "..", "..", "..", "player", "dist", "hyperframes-player.global.js"),
     // Bundled with CLI dist
-    resolve24(d, "hyperframes-player.global.js"),
-    resolve24(d, "..", "hyperframes-player.global.js")
+    resolve25(d, "hyperframes-player.global.js"),
+    resolve25(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
     if (existsSync36(p)) return p;
@@ -36335,7 +36438,7 @@ var init_play = __esm({
         });
         app.get("/composition/*", async (ctx) => {
           const reqPath = ctx.req.path.replace("/composition/", "");
-          const filePath = resolve24(project.dir, reqPath);
+          const filePath = resolve25(project.dir, reqPath);
           if (!filePath.startsWith(project.dir)) return ctx.text("Forbidden", 403);
           if (!existsSync36(filePath)) return ctx.text("Not found", 404);
           const content = readFileSync25(filePath, "utf-8");
@@ -36496,7 +36599,7 @@ __export(publish_exports, {
   default: () => publish_default,
   examples: () => examples6
 });
-import { basename as basename7, resolve as resolve25 } from "path";
+import { basename as basename7, resolve as resolve26 } from "path";
 import { existsSync as existsSync37 } from "fs";
 import { join as join38 } from "path";
 var examples6, publish_default;
@@ -36530,7 +36633,7 @@ var init_publish = __esm({
       },
       async run({ args }) {
         const rawArg = args.dir;
-        const dir = resolve25(rawArg ?? ".");
+        const dir = resolve26(rawArg ?? ".");
         const isImplicitCwd = !rawArg || rawArg === "." || rawArg === "./";
         const projectName = isImplicitCwd ? basename7(process.env["PWD"] ?? dir) : basename7(dir);
         const indexPath = join38(dir, "index.html");
@@ -36707,7 +36810,7 @@ __export(render_exports, {
 });
 import { mkdirSync as mkdirSync21, readFileSync as readFileSync27, statSync as statSync13, writeFileSync as writeFileSync14, rmSync as rmSync8 } from "fs";
 import { cpus as cpus3, freemem as freemem3, tmpdir as tmpdir3 } from "os";
-import { resolve as resolve26, dirname as dirname15, join as join39, basename as basename8 } from "path";
+import { resolve as resolve27, dirname as dirname15, join as join39, basename as basename8 } from "path";
 import { execFileSync as execFileSync5, spawn as spawn10 } from "child_process";
 function defaultWorkerCount() {
   return Math.max(1, Math.min(Math.floor(CPU_CORE_COUNT * 3 / 4), 8));
@@ -36716,8 +36819,8 @@ function dockerImageTag(version) {
   return `${DOCKER_IMAGE_PREFIX}:${version}`;
 }
 function resolveDockerfilePath() {
-  const builtPath = resolve26(__dirname, "docker", "Dockerfile.render");
-  const devPath = resolve26(__dirname, "..", "src", "docker", "Dockerfile.render");
+  const builtPath = resolve27(__dirname, "docker", "Dockerfile.render");
+  const devPath = resolve27(__dirname, "..", "src", "docker", "Dockerfile.render");
   for (const p of [builtPath, devPath]) {
     try {
       statSync13(p);
@@ -36794,8 +36897,8 @@ async function renderDocker(projectDir, outputPath, options) {
   const outputFilename = basename8(outputPath);
   const dockerArgs = buildDockerRunArgs({
     imageTag,
-    projectDir: resolve26(projectDir),
-    outputDir: resolve26(outputDir),
+    projectDir: resolve27(projectDir),
+    outputDir: resolve27(outputDir),
     outputFilename,
     options: {
       fps: options.fps,
@@ -37070,12 +37173,12 @@ var init_render2 = __esm({
           }
           process.env.PRODUCER_MAX_CONCURRENT_RENDERS = String(parsed);
         }
-        const rendersDir = resolve26("renders");
+        const rendersDir = resolve27("renders");
         const ext = FORMAT_EXT[format] ?? ".mp4";
         const now = /* @__PURE__ */ new Date();
         const datePart = now.toISOString().slice(0, 10);
         const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
-        const outputPath = args.output ? resolve26(args.output) : join39(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        const outputPath = args.output ? resolve27(args.output) : join39(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
         mkdirSync21(dirname15(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
@@ -37517,7 +37620,7 @@ __export(compositions_exports, {
   examples: () => examples10
 });
 import { existsSync as existsSync38, readFileSync as readFileSync29 } from "fs";
-import { resolve as resolve27, dirname as dirname16 } from "path";
+import { resolve as resolve28, dirname as dirname16 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
   const doc = parser.parseFromString(html, "text/html");
@@ -37529,7 +37632,7 @@ function parseCompositions(html, baseDir) {
     const height = parseInt(div.getAttribute("data-height") ?? "1080", 10);
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
-      const subPath = resolve27(baseDir, compositionSrc);
+      const subPath = resolve28(baseDir, compositionSrc);
       if (existsSync38(subPath)) {
         const subHtml = readFileSync29(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
@@ -37664,7 +37767,7 @@ __export(benchmark_exports, {
   examples: () => examples11
 });
 import { existsSync as existsSync39, statSync as statSync15 } from "fs";
-import { resolve as resolve28, join as join41 } from "path";
+import { resolve as resolve29, join as join41 } from "path";
 var examples11, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -37706,7 +37809,7 @@ var init_benchmark = __esm({
           process.exit(1);
         }
         const jsonOutput = args.json ?? false;
-        const benchDir = resolve28("renders", ".benchmark");
+        const benchDir = resolve29("renders", ".benchmark");
         let producer = null;
         try {
           producer = await loadProducer();
@@ -37970,7 +38073,7 @@ __export(transcribe_exports2, {
   examples: () => examples13
 });
 import { existsSync as existsSync40, writeFileSync as writeFileSync15 } from "fs";
-import { resolve as resolve29, join as join42, extname as extname8 } from "path";
+import { resolve as resolve30, join as join42, extname as extname8 } from "path";
 async function importTranscript(inputPath, dir, json) {
   const { loadTranscript: loadTranscript2, patchCaptionHtml: patchCaptionHtml2 } = await Promise.resolve().then(() => (init_normalize(), normalize_exports));
   const { words, format } = loadTranscript2(inputPath);
@@ -38094,12 +38197,12 @@ var init_transcribe2 = __esm({
         }
       },
       async run({ args }) {
-        const inputPath = resolve29(args.input);
+        const inputPath = resolve30(args.input);
         if (!existsSync40(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
-        const dir = resolve29(args.dir ?? ".");
+        const dir = resolve30(args.dir ?? ".");
         const ext = extname8(inputPath).toLowerCase();
         const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
         if (isImport) {
@@ -38389,7 +38492,7 @@ __export(tts_exports, {
   examples: () => examples14
 });
 import { existsSync as existsSync43, readFileSync as readFileSync30 } from "fs";
-import { resolve as resolve30, extname as extname9 } from "path";
+import { resolve as resolve31, extname as extname9 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v) => ({ ...v, defaultLang: inferLangFromVoiceId(v.id) }));
   if (json) {
@@ -38497,7 +38600,7 @@ var init_tts = __esm({
           process.exit(1);
         }
         let text;
-        const maybeFile = resolve30(args.input);
+        const maybeFile = resolve31(args.input);
         if (existsSync43(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync30(maybeFile, "utf-8").trim();
           if (!text) {
@@ -38511,7 +38614,7 @@ var init_tts = __esm({
           console.error(c.error("No text provided."));
           process.exit(1);
         }
-        const output = resolve30(args.output ?? "speech.wav");
+        const output = resolve31(args.output ?? "speech.wav");
         const voice = args.voice ?? DEFAULT_VOICE;
         const speed = args.speed ? parseFloat(args.speed) : 1;
         if (isNaN(speed) || speed <= 0 || speed > 3) {
@@ -38592,13 +38695,13 @@ __export(docs_exports, {
   examples: () => examples15
 });
 import { readFileSync as readFileSync31, existsSync as existsSync44 } from "fs";
-import { resolve as resolve31, dirname as dirname18, join as join45 } from "path";
+import { resolve as resolve32, dirname as dirname18, join as join45 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath6(import.meta.url);
   const dir = dirname18(thisFile);
-  const devPath = resolve31(dir, "..", "docs");
-  const builtPath = resolve31(dir, "docs");
+  const devPath = resolve32(dir, "..", "docs");
+  const builtPath = resolve32(dir, "docs");
   return existsSync44(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
@@ -39128,7 +39231,7 @@ __export(validate_exports, {
   default: () => validate_default
 });
 import { existsSync as existsSync45, readFileSync as readFileSync32 } from "fs";
-import { resolve as resolve32, join as join46, dirname as dirname19 } from "path";
+import { resolve as resolve33, join as join46, dirname as dirname19 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -39174,7 +39277,7 @@ async function validateInBrowser(projectDir, opts) {
   const { bundleToSingleHtml: bundleToSingleHtml2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   let html = await bundleToSingleHtml2(projectDir);
-  const runtimePath = resolve32(
+  const runtimePath = resolve33(
     __dirname2,
     "..",
     "..",
@@ -39395,7 +39498,7 @@ __export(snapshot_exports, {
 import { spawn as spawn11 } from "child_process";
 import { existsSync as existsSync46, mkdtempSync as mkdtempSync2, readFileSync as readFileSync33, mkdirSync as mkdirSync24, rmSync as rmSync9 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { resolve as resolve33, join as join47, dirname as dirname20, relative as relative5, isAbsolute as isAbsolute4 } from "path";
+import { resolve as resolve34, join as join47, dirname as dirname20, relative as relative5, isAbsolute as isAbsolute4 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds) {
   const tmp = mkdtempSync2(join47(tmpdir4(), "hf-snapshot-frame-"));
@@ -39451,7 +39554,7 @@ async function captureSnapshots(projectDir, opts) {
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const numFrames = opts.frames ?? 5;
   let html = await bundleToSingleHtml2(projectDir);
-  const runtimePath = resolve33(
+  const runtimePath = resolve34(
     __dirname3,
     "..",
     "..",
@@ -39476,7 +39579,7 @@ async function captureSnapshots(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = resolve33(projectDir, decodeURIComponent(url).replace(/^\//, ""));
+    const filePath = resolve34(projectDir, decodeURIComponent(url).replace(/^\//, ""));
     const rel = relative5(projectDir, filePath);
     if (rel.startsWith("..") || isAbsolute4(rel)) {
       res.writeHead(403);
@@ -39617,7 +39720,7 @@ async function captureSnapshots(projectDir, opts) {
             try {
               const url = new URL(v.src);
               const decodedPath = decodeURIComponent(url.pathname).replace(/^\//, "");
-              const candidate = resolve33(projectDir, decodedPath);
+              const candidate = resolve34(projectDir, decodedPath);
               const rel = relative5(projectDir, candidate);
               if (!rel.startsWith("..") && !isAbsolute4(rel) && existsSync46(candidate)) {
                 filePath = candidate;
@@ -40109,7 +40212,7 @@ async function extractHtml(page, opts = {}) {
     (_match, pre, urls, post) => {
       const fixed = urls.replace(/&amp;/g, "&").replace(
         /(^|,\s*)(\/[^\s,]+)/g,
-        (_m, sep3, path2) => sep3 + pageOrigin + path2
+        (_m, sep4, path2) => sep4 + pageOrigin + path2
       );
       return pre + fixed + post;
     }
@@ -41206,7 +41309,7 @@ var require_p_retry = __commonJS({
       return error;
     };
     var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
-    var pRetry2 = (input, options) => new Promise((resolve36, reject) => {
+    var pRetry2 = (input, options) => new Promise((resolve37, reject) => {
       options = {
         onFailedAttempt: () => {
         },
@@ -41216,7 +41319,7 @@ var require_p_retry = __commonJS({
       const operation = retry.operation(options);
       operation.attempt(async (attemptNumber) => {
         try {
-          resolve36(await input(attemptNumber));
+          resolve37(await input(attemptNumber));
         } catch (error) {
           if (!(error instanceof Error)) {
             reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
@@ -41752,8 +41855,8 @@ var require_retry3 = __commonJS({
       }
       const delay = getNextRetryDelay(config);
       err.config.retryConfig.currentRetryAttempt += 1;
-      const backoff = config.retryBackoff ? config.retryBackoff(err, delay) : new Promise((resolve36) => {
-        setTimeout(resolve36, delay);
+      const backoff = config.retryBackoff ? config.retryBackoff(err, delay) : new Promise((resolve37) => {
+        setTimeout(resolve37, delay);
       });
       if (config.onRetryAttempt) {
         await config.onRetryAttempt(err);
@@ -42661,8 +42764,8 @@ var require_helpers = __commonJS({
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
       const req2 = (href.startsWith("https:") ? https2 : http4).request(url, opts);
-      const promise = new Promise((resolve36, reject) => {
-        req2.once("response", resolve36).once("error", reject).end();
+      const promise = new Promise((resolve37, reject) => {
+        req2.once("response", resolve37).once("error", reject).end();
       });
       req2.then = promise.then.bind(promise);
       return req2;
@@ -42839,7 +42942,7 @@ var require_parse_proxy_response = __commonJS({
     var debug_1 = __importDefault(require_src2());
     var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
-      return new Promise((resolve36, reject) => {
+      return new Promise((resolve37, reject) => {
         let buffersLength = 0;
         const buffers = [];
         function read() {
@@ -42905,7 +43008,7 @@ var require_parse_proxy_response = __commonJS({
           }
           debug("got proxy server response: %o %o", firstLine, headers);
           cleanup();
-          resolve36({
+          resolve37({
             connect: {
               statusCode,
               statusText,
@@ -43149,7 +43252,7 @@ var require_ponyfill_es2018 = __commonJS({
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value) {
-        return newPromise((resolve36) => resolve36(value));
+        return newPromise((resolve37) => resolve37(value));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -43319,8 +43422,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released reader");
       }
       function defaultReaderClosedPromiseInitialize(reader) {
-        reader._closedPromise = newPromise((resolve36, reject) => {
-          reader._closedPromise_resolve = resolve36;
+        reader._closedPromise = newPromise((resolve37, reject) => {
+          reader._closedPromise_resolve = resolve37;
           reader._closedPromise_reject = reject;
         });
       }
@@ -43494,8 +43597,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve36, reject) => {
-            resolvePromise = resolve36;
+          const promise = newPromise((resolve37, reject) => {
+            resolvePromise = resolve37;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -43600,8 +43703,8 @@ var require_ponyfill_es2018 = __commonJS({
           const reader = this._reader;
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve36, reject) => {
-            resolvePromise = resolve36;
+          const promise = newPromise((resolve37, reject) => {
+            resolvePromise = resolve37;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -44620,8 +44723,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve36, reject) => {
-            resolvePromise = resolve36;
+          const promise = newPromise((resolve37, reject) => {
+            resolvePromise = resolve37;
             rejectPromise = reject;
           });
           const readIntoRequest = {
@@ -44933,10 +45036,10 @@ var require_ponyfill_es2018 = __commonJS({
           wasAlreadyErroring = true;
           reason = void 0;
         }
-        const promise = newPromise((resolve36, reject) => {
+        const promise = newPromise((resolve37, reject) => {
           stream._pendingAbortRequest = {
             _promise: void 0,
-            _resolve: resolve36,
+            _resolve: resolve37,
             _reject: reject,
             _reason: reason,
             _wasAlreadyErroring: wasAlreadyErroring
@@ -44953,9 +45056,9 @@ var require_ponyfill_es2018 = __commonJS({
         if (state === "closed" || state === "errored") {
           return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
         }
-        const promise = newPromise((resolve36, reject) => {
+        const promise = newPromise((resolve37, reject) => {
           const closeRequest = {
-            _resolve: resolve36,
+            _resolve: resolve37,
             _reject: reject
           };
           stream._closeRequest = closeRequest;
@@ -44968,9 +45071,9 @@ var require_ponyfill_es2018 = __commonJS({
         return promise;
       }
       function WritableStreamAddWriteRequest(stream) {
-        const promise = newPromise((resolve36, reject) => {
+        const promise = newPromise((resolve37, reject) => {
           const writeRequest = {
-            _resolve: resolve36,
+            _resolve: resolve37,
             _reject: reject
           };
           stream._writeRequests.push(writeRequest);
@@ -45586,8 +45689,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released writer");
       }
       function defaultWriterClosedPromiseInitialize(writer) {
-        writer._closedPromise = newPromise((resolve36, reject) => {
-          writer._closedPromise_resolve = resolve36;
+        writer._closedPromise = newPromise((resolve37, reject) => {
+          writer._closedPromise_resolve = resolve37;
           writer._closedPromise_reject = reject;
           writer._closedPromiseState = "pending";
         });
@@ -45623,8 +45726,8 @@ var require_ponyfill_es2018 = __commonJS({
         writer._closedPromiseState = "resolved";
       }
       function defaultWriterReadyPromiseInitialize(writer) {
-        writer._readyPromise = newPromise((resolve36, reject) => {
-          writer._readyPromise_resolve = resolve36;
+        writer._readyPromise = newPromise((resolve37, reject) => {
+          writer._readyPromise_resolve = resolve37;
           writer._readyPromise_reject = reject;
         });
         writer._readyPromiseState = "pending";
@@ -45711,7 +45814,7 @@ var require_ponyfill_es2018 = __commonJS({
         source._disturbed = true;
         let shuttingDown = false;
         let currentWrite = promiseResolvedWith(void 0);
-        return newPromise((resolve36, reject) => {
+        return newPromise((resolve37, reject) => {
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
@@ -45856,7 +45959,7 @@ var require_ponyfill_es2018 = __commonJS({
             if (isError) {
               reject(error);
             } else {
-              resolve36(void 0);
+              resolve37(void 0);
             }
             return null;
           }
@@ -46137,8 +46240,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve36) => {
-          resolveCancelPromise = resolve36;
+        const cancelPromise = newPromise((resolve37) => {
+          resolveCancelPromise = resolve37;
         });
         function pullAlgorithm() {
           if (reading) {
@@ -46229,8 +46332,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve36) => {
-          resolveCancelPromise = resolve36;
+        const cancelPromise = newPromise((resolve37) => {
+          resolveCancelPromise = resolve37;
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
@@ -47010,8 +47113,8 @@ var require_ponyfill_es2018 = __commonJS({
           const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
           const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
           let startPromise_resolve;
-          const startPromise = newPromise((resolve36) => {
-            startPromise_resolve = resolve36;
+          const startPromise = newPromise((resolve37) => {
+            startPromise_resolve = resolve37;
           });
           InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
           SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -47104,8 +47207,8 @@ var require_ponyfill_es2018 = __commonJS({
         if (stream._backpressureChangePromise !== void 0) {
           stream._backpressureChangePromise_resolve();
         }
-        stream._backpressureChangePromise = newPromise((resolve36) => {
-          stream._backpressureChangePromise_resolve = resolve36;
+        stream._backpressureChangePromise = newPromise((resolve37) => {
+          stream._backpressureChangePromise_resolve = resolve37;
         });
         stream._backpressure = backpressure;
       }
@@ -47273,8 +47376,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve36, reject) => {
-          controller._finishPromise_resolve = resolve36;
+        controller._finishPromise = newPromise((resolve37, reject) => {
+          controller._finishPromise_resolve = resolve37;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -47300,8 +47403,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve36, reject) => {
-          controller._finishPromise_resolve = resolve36;
+        controller._finishPromise = newPromise((resolve37, reject) => {
+          controller._finishPromise_resolve = resolve37;
           controller._finishPromise_reject = reject;
         });
         const flushPromise = controller._flushAlgorithm();
@@ -47331,8 +47434,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const writable = stream._writable;
-        controller._finishPromise = newPromise((resolve36, reject) => {
-          controller._finishPromise_resolve = resolve36;
+        controller._finishPromise = newPromise((resolve37, reject) => {
+          controller._finishPromise_resolve = resolve37;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -49301,7 +49404,7 @@ import zlib from "zlib";
 import Stream2, { PassThrough as PassThrough2, pipeline as pump } from "stream";
 import { Buffer as Buffer3 } from "buffer";
 async function fetch3(url, options_) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const request = new Request2(url, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol)) {
@@ -49310,7 +49413,7 @@ async function fetch3(url, options_) {
     if (parsedURL.protocol === "data:") {
       const data = dist_default(request.url);
       const response2 = new Response2(data, { headers: { "Content-Type": data.typeFull } });
-      resolve36(response2);
+      resolve37(response2);
       return;
     }
     const send = (parsedURL.protocol === "https:" ? https : http3).request;
@@ -49432,7 +49535,7 @@ async function fetch3(url, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve36(fetch3(new Request2(locationURL, requestOptions)));
+            resolve37(fetch3(new Request2(locationURL, requestOptions)));
             finalize();
             return;
           }
@@ -49465,7 +49568,7 @@ async function fetch3(url, options_) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
         response = new Response2(body, responseOptions);
-        resolve36(response);
+        resolve37(response);
         return;
       }
       const zlibOptions = {
@@ -49479,7 +49582,7 @@ async function fetch3(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve36(response);
+        resolve37(response);
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
@@ -49503,12 +49606,12 @@ async function fetch3(url, options_) {
             });
           }
           response = new Response2(body, responseOptions);
-          resolve36(response);
+          resolve37(response);
         });
         raw.once("end", () => {
           if (!response) {
             response = new Response2(body, responseOptions);
-            resolve36(response);
+            resolve37(response);
           }
         });
         return;
@@ -49520,11 +49623,11 @@ async function fetch3(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve36(response);
+        resolve37(response);
         return;
       }
       response = new Response2(body, responseOptions);
-      resolve36(response);
+      resolve37(response);
     });
     writeToStream(request_, request).catch(reject);
   });
@@ -55606,7 +55709,7 @@ var require_jwtaccess = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve36, reject) => {
+        return new Promise((resolve37, reject) => {
           if (!inputStream) {
             reject(new Error("Must pass in a stream containing the service account auth settings."));
           }
@@ -55615,7 +55718,7 @@ var require_jwtaccess = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve36();
+              resolve37();
             } catch (err) {
               reject(err);
             }
@@ -55854,7 +55957,7 @@ var require_jwtclient = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve36, reject) => {
+        return new Promise((resolve37, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the service account auth settings.");
           }
@@ -55863,7 +55966,7 @@ var require_jwtclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve36();
+              resolve37();
             } catch (e2) {
               reject(e2);
             }
@@ -55996,7 +56099,7 @@ var require_refreshclient = __commonJS({
         }
       }
       async fromStreamAsync(inputStream) {
-        return new Promise((resolve36, reject) => {
+        return new Promise((resolve37, reject) => {
           if (!inputStream) {
             return reject(new Error("Must pass in a stream containing the user refresh token."));
           }
@@ -56005,7 +56108,7 @@ var require_refreshclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              return resolve36();
+              return resolve37();
             } catch (err) {
               return reject(err);
             }
@@ -57838,7 +57941,7 @@ var require_pluggable_auth_handler = __commonJS({
        * @return A promise that resolves with the executable response.
        */
       retrieveResponseFromExecutable(envMap) {
-        return new Promise((resolve36, reject) => {
+        return new Promise((resolve37, reject) => {
           const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {
             env: { ...process.env, ...Object.fromEntries(envMap) }
           });
@@ -57860,7 +57963,7 @@ var require_pluggable_auth_handler = __commonJS({
               try {
                 const responseJson = JSON.parse(output);
                 const response = new executable_response_1.ExecutableResponse(responseJson);
-                return resolve36(response);
+                return resolve37(response);
               } catch (error) {
                 if (error instanceof executable_response_1.ExecutableResponseError) {
                   return reject(error);
@@ -58763,7 +58866,7 @@ var require_googleauth = __commonJS({
         }
       }
       fromStreamAsync(inputStream, options) {
-        return new Promise((resolve36, reject) => {
+        return new Promise((resolve37, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the Google auth settings.");
           }
@@ -58773,7 +58876,7 @@ var require_googleauth = __commonJS({
               try {
                 const data = JSON.parse(chunks.join(""));
                 const r2 = this._cacheClientFromJSON(data, options);
-                return resolve36(r2);
+                return resolve37(r2);
               } catch (err) {
                 if (!this.keyFilename)
                   throw err;
@@ -58783,7 +58886,7 @@ var require_googleauth = __commonJS({
                 });
                 this.cachedCredential = client;
                 this.setGapicJWTValues(client);
-                return resolve36(client);
+                return resolve37(client);
               }
             } catch (err) {
               return reject(err);
@@ -58819,17 +58922,17 @@ var require_googleauth = __commonJS({
        * Run the Google Cloud SDK command that prints the default project ID
        */
       async getDefaultServiceProjectId() {
-        return new Promise((resolve36) => {
+        return new Promise((resolve37) => {
           (0, child_process_1.exec)("gcloud config config-helper --format json", (err, stdout2) => {
             if (!err && stdout2) {
               try {
                 const projectId = JSON.parse(stdout2).configuration.properties.core.project;
-                resolve36(projectId);
+                resolve37(projectId);
                 return;
               } catch (e2) {
               }
             }
-            resolve36(null);
+            resolve37(null);
           });
         });
       }
@@ -66601,14 +66704,14 @@ function __asyncValues(o) {
   }, i2);
   function verb(n) {
     i2[n] = o[n] && function(v) {
-      return new Promise(function(resolve36, reject) {
-        v = o[n](v), settle(resolve36, reject, v.done, v.value);
+      return new Promise(function(resolve37, reject) {
+        v = o[n](v), settle(resolve37, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve36, reject, d, v) {
+  function settle(resolve37, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve36({ value: v2, done: d });
+      resolve37({ value: v2, done: d });
     }, reject);
   }
 }
@@ -77111,8 +77214,8 @@ var init_node4 = __esm({
         const url = `${websocketBaseUrl}/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.BidiGenerateMusic?key=${apiKey}`;
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve36) => {
-          onopenResolve = resolve36;
+        const onopenPromise = new Promise((resolve37) => {
+          onopenResolve = resolve37;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -77318,8 +77421,8 @@ var init_node4 = __esm({
         }
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve36) => {
-          onopenResolve = resolve36;
+        const onopenPromise = new Promise((resolve37) => {
+          onopenResolve = resolve37;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -79628,7 +79731,7 @@ var init_node4 = __esm({
         return void 0;
       }
     };
-    sleep$1 = (ms) => new Promise((resolve36) => setTimeout(resolve36, ms));
+    sleep$1 = (ms) => new Promise((resolve37) => setTimeout(resolve37, ms));
     FallbackEncoder = ({ headers, body }) => {
       return {
         bodyHeaders: {
@@ -80137,8 +80240,8 @@ ${underline2}`);
     };
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse = defaultParseResponse) {
-        super((resolve36) => {
-          resolve36(null);
+        super((resolve37) => {
+          resolve37(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse;
@@ -81699,12 +81802,12 @@ var init_agentPromptGenerator = __esm({
 
 // src/capture/scaffolding.ts
 import { existsSync as existsSync47, writeFileSync as writeFileSync20, readFileSync as readFileSync36 } from "fs";
-import { join as join52, resolve as resolve34 } from "path";
+import { join as join52, resolve as resolve35 } from "path";
 function loadEnvFile(startDir) {
   try {
-    let dir = resolve34(startDir);
+    let dir = resolve35(startDir);
     for (let i2 = 0; i2 < 5; i2++) {
-      const envPath = resolve34(dir, ".env");
+      const envPath = resolve35(dir, ".env");
       try {
         const envContent = readFileSync36(envPath, "utf-8");
         for (const line of envContent.split("\n")) {
@@ -81718,7 +81821,7 @@ function loadEnvFile(startDir) {
         }
         break;
       } catch {
-        dir = resolve34(dir, "..");
+        dir = resolve35(dir, "..");
       }
     }
   } catch {
@@ -82485,7 +82588,7 @@ __export(capture_exports2, {
   default: () => capture_default,
   examples: () => examples20
 });
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 var examples20, capture_default;
 var init_capture2 = __esm({
   "src/commands/capture.ts"() {
@@ -82544,7 +82647,7 @@ var init_capture2 = __esm({
           const hostname = new URL(url).hostname.replace(/^www\./, "");
           outputName = `captures/${hostname.replace(/\./g, "-")}`;
         }
-        const outputDir = resolve35(outputName);
+        const outputDir = resolve36(outputName);
         const isJson = args.json;
         if (!isJson) {
           const { c: c2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
@@ -82691,13 +82794,13 @@ var init_telemetry2 = __esm({
 });
 
 // src/utils/installerDetection.ts
-import { realpathSync } from "fs";
+import { realpathSync as realpathSync2 } from "fs";
 import { posix as posix2 } from "path";
 function resolveEntry() {
   const entry = process.argv[1];
   if (!entry) return null;
   try {
-    return realpathSync(entry);
+    return realpathSync2(entry);
   } catch {
     return entry;
   }