hyperframes 0.4.5 → 0.4.7

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.5" : "0.0.0-dev";
+    VERSION = true ? "0.4.7" : "0.0.0-dev";
   }
 });
 
@@ -5571,12 +5571,14 @@ function getModelUrl(model) {
 }
 function whichBinary(name) {
   try {
-    const result = execFileSync("which", [name], {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const output = execFileSync(cmd, [name], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5e3
-    }).trim();
-    return result || void 0;
+    });
+    const first = output.split(/\r?\n/).map((s2) => s2.trim()).find(Boolean);
+    return first || void 0;
   } catch {
     return void 0;
   }
@@ -6544,19 +6546,22 @@ import http from "http";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { resolve as resolve6 } from "path";
-function isPortAvailableOnHost(port, host) {
-  return new Promise((resolve35) => {
-    const server = net.createServer();
-    server.unref();
-    server.on("error", (err) => {
-      resolve35(err.code !== "EADDRINUSE");
-    });
-    server.listen({ port, host }, () => {
-      server.close(() => {
-        resolve35(true);
-      });
+async function isPortAvailableOnHost(port, host) {
+  const probe = net.createServer();
+  probe.unref();
+  const bindError = await new Promise((settle) => {
+    const handleError = (err) => settle(err);
+    probe.once("error", handleError);
+    probe.listen({ port, host }, () => {
+      probe.removeListener("error", handleError);
+      settle(null);
     });
   });
+  if (bindError !== null) {
+    return bindError.code !== "EADDRINUSE";
+  }
+  await new Promise((done) => probe.close(() => done()));
+  return true;
 }
 async function testPortOnAllHosts(port, probe = isPortAvailableOnHost) {
   for (const host of PORT_PROBE_HOSTS) {
@@ -20272,12 +20277,14 @@ function setBrowserPath(path2) {
 }
 function whichBinary2(name) {
   try {
-    const result = execSync(`which ${name}`, {
+    const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
+    const output = execSync(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5e3
-    }).trim();
-    return result || void 0;
+    });
+    const first = output.split(/\r?\n/).map((s2) => s2.trim()).find(Boolean);
+    return first || void 0;
   } catch {
     return void 0;
   }
@@ -20410,6 +20417,12 @@ function resolveConfig(overrides) {
       "FFMPEG_STREAMING_TIMEOUT_MS",
       DEFAULT_CONFIG2.ffmpegStreamingTimeout
     ),
+    hdr: (() => {
+      const raw = env("PRODUCER_HDR_TRANSFER");
+      if (raw === "hlg" || raw === "pq") return { transfer: raw };
+      return void 0;
+    })(),
+    hdrAutoDetect: envBool("PRODUCER_HDR_AUTO_DETECT", DEFAULT_CONFIG2.hdrAutoDetect),
     audioGain: envNum("PRODUCER_AUDIO_GAIN", DEFAULT_CONFIG2.audioGain),
     frameDataUriCacheLimit: Math.max(
       32,
@@ -20457,6 +20470,8 @@ var init_config2 = __esm({
       ffmpegEncodeTimeout: 6e5,
       ffmpegProcessTimeout: 3e5,
       ffmpegStreamingTimeout: 6e5,
+      hdr: false,
+      hdrAutoDetect: true,
       audioGain: 1.35,
       frameDataUriCacheLimit: 256,
       playerReadyTimeout: 45e3,
@@ -20623,7 +20638,8 @@ function buildChromeArgs(options, config) {
     "--font-render-hinting=none",
     "--force-color-profile=srgb",
     `--window-size=${options.width},${options.height}`,
-    // Remotion perf flags — prevent Chrome from throttling background tabs/timers
+    // Prevent Chrome from throttling background tabs/timers — critical when the
+    // page is offscreen during headless capture
     "--disable-background-timer-throttling",
     "--disable-backgrounding-occluded-windows",
     "--disable-renderer-backgrounding",
@@ -20763,6 +20779,44 @@ async function pageScreenshotCapture(page, options) {
   });
   return Buffer.from(result.data, "base64");
 }
+async function captureScreenshotWithAlpha(page, width, height) {
+  const client = await getCdpSession(page);
+  await client.send("Emulation.setDefaultBackgroundColorOverride", {
+    color: { r: 0, g: 0, b: 0, a: 0 }
+  });
+  try {
+    const result = await client.send("Page.captureScreenshot", {
+      format: "png",
+      fromSurface: true,
+      captureBeyondViewport: false,
+      optimizeForSpeed: false,
+      // `true` uses a zero-alpha-aware fast path that crushes real alpha values — observed empirically, CDP docs don't spell it out
+      clip: { x: 0, y: 0, width, height, scale: 1 }
+    });
+    return Buffer.from(result.data, "base64");
+  } finally {
+    await client.send("Emulation.setDefaultBackgroundColorOverride", {}).catch(() => {
+    });
+  }
+}
+async function initTransparentBackground(page) {
+  const client = await getCdpSession(page);
+  await client.send("Emulation.setDefaultBackgroundColorOverride", {
+    color: { r: 0, g: 0, b: 0, a: 0 }
+  });
+}
+async function captureAlphaPng(page, width, height) {
+  const client = await getCdpSession(page);
+  const result = await client.send("Page.captureScreenshot", {
+    format: "png",
+    fromSurface: true,
+    captureBeyondViewport: false,
+    optimizeForSpeed: false,
+    // must be false to preserve alpha
+    clip: { x: 0, y: 0, width, height, scale: 1 }
+  });
+  return Buffer.from(result.data, "base64");
+}
 async function injectVideoFramesBatch(page, updates) {
   if (updates.length === 0) return;
   await page.evaluate(
@@ -20784,16 +20838,7 @@ async function injectVideoFramesBatch(page, updates) {
           video.parentNode?.insertBefore(img, video.nextSibling);
         }
         if (!img) continue;
-        if (!sourceIsStatic) {
-          img.style.position = computedStyle.position;
-          img.style.width = computedStyle.width;
-          img.style.height = computedStyle.height;
-          img.style.top = computedStyle.top;
-          img.style.left = computedStyle.left;
-          img.style.right = computedStyle.right;
-          img.style.bottom = computedStyle.bottom;
-          img.style.inset = computedStyle.inset;
-        } else {
+        {
           const videoRect = video.getBoundingClientRect();
           const offsetLeft = Number.isFinite(video.offsetLeft) ? video.offsetLeft : 0;
           const offsetTop = Number.isFinite(video.offsetTop) ? video.offsetTop : 0;
@@ -20844,14 +20889,22 @@ async function syncVideoFrameVisibility(page, activeVideoIds) {
     const active = new Set(ids);
     const videos = Array.from(document.querySelectorAll("video[data-start]"));
     for (const video of videos) {
-      if (active.has(video.id)) continue;
-      video.style.removeProperty("display");
-      video.style.setProperty("visibility", "hidden", "important");
-      video.style.setProperty("opacity", "0", "important");
-      video.style.setProperty("pointer-events", "none", "important");
       const img = video.nextElementSibling;
-      if (img && img.classList.contains("__render_frame__")) {
-        img.style.visibility = "hidden";
+      const hasImg = img && img.classList.contains("__render_frame__");
+      if (active.has(video.id)) {
+        video.style.setProperty("visibility", "hidden", "important");
+        video.style.setProperty("pointer-events", "none", "important");
+        if (hasImg) {
+          img.style.visibility = "visible";
+        }
+      } 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";
+        }
       }
     }
   }, activeVideoIds);
@@ -20938,6 +20991,15 @@ function isFontResourceError(type, text, locationUrl) {
     `${locationUrl} ${text}`
   );
 }
+async function pollPageExpression(page, expression, timeoutMs, intervalMs = 100) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const ready = Boolean(await page.evaluate(expression));
+    if (ready) return true;
+    await new Promise((resolve35) => setTimeout(resolve35, intervalMs));
+  }
+  return Boolean(await page.evaluate(expression));
+}
 async function initializeSession(session) {
   const { page, serverUrl } = session;
   page.on("console", (msg) => {
@@ -20967,14 +21029,26 @@ async function initializeSession(session) {
   if (session.captureMode === "screenshot") {
     await page.goto(url, { waitUntil: "domcontentloaded", timeout: 6e4 });
     const pageReadyTimeout2 = session.config?.playerReadyTimeout ?? DEFAULT_CONFIG2.playerReadyTimeout;
-    await page.waitForFunction(
+    const pageReady2 = await pollPageExpression(
+      page,
       `!!(window.__hf && typeof window.__hf.seek === "function" && window.__hf.duration > 0)`,
-      { timeout: pageReadyTimeout2 }
+      pageReadyTimeout2
     );
-    await page.waitForFunction(
+    if (!pageReady2) {
+      throw new Error(
+        `[FrameCapture] window.__hf not ready after ${pageReadyTimeout2}ms. Page must expose window.__hf = { duration, seek }.`
+      );
+    }
+    const videosReady = await pollPageExpression(
+      page,
       `document.querySelectorAll("video").length === 0 || Array.from(document.querySelectorAll("video")).every(v => v.readyState >= 1)`,
-      { timeout: pageReadyTimeout2 }
+      pageReadyTimeout2
     );
+    if (!videosReady) {
+      throw new Error(
+        `[FrameCapture] video metadata not ready after ${pageReadyTimeout2}ms. Video elements must load metadata before capture starts.`
+      );
+    }
     await page.evaluate(`document.fonts?.ready`);
     session.isInitialized = true;
     return;
@@ -21314,7 +21388,7 @@ var init_runFfmpeg = __esm({
 import { spawn as spawn4 } from "child_process";
 import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync9, readdirSync as readdirSync7, statSync as statSync4, writeFileSync as writeFileSync8 } from "fs";
 import { join as join19, dirname as dirname5 } from "path";
-function getEncoderPreset(quality, format = "mp4") {
+function getEncoderPreset(quality, format = "mp4", hdr) {
   const base = ENCODER_PRESETS[quality];
   if (format === "webm") {
     return {
@@ -21332,6 +21406,15 @@ function getEncoderPreset(quality, format = "mp4") {
       pixelFormat: "yuva444p10le"
     };
   }
+  if (hdr) {
+    return {
+      preset: base.preset === "ultrafast" ? "fast" : base.preset,
+      quality: base.quality,
+      codec: "h265",
+      pixelFormat: "yuv420p10le",
+      hdr
+    };
+  }
   return { ...base, pixelFormat: "yuv420p" };
 }
 function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
@@ -21389,6 +21472,9 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
         args.push(xParamsFlag, `aq-mode=3:aq-strength=0.8:deblock=1,1:${colorParams}`);
       }
     }
+    if (codec === "h265") {
+      args.push("-tag:v", "hvc1");
+    }
   } else if (codec === "vp9") {
     args.push("-c:v", "libvpx-vp9", "-b:v", bitrate || "0", "-crf", String(quality));
     args.push("-deadline", preset === "ultrafast" ? "realtime" : "good");
@@ -21706,35 +21792,91 @@ 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";
 import { dirname as dirname6 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
-  let nextFrame = startFrame;
-  let waiters = [];
-  const resolveWaiters = () => {
-    for (const waiter of waiters.slice()) {
-      if (waiter.frame === nextFrame) {
-        waiter.resolve();
-        waiters = waiters.filter((w) => w !== waiter);
-      }
+  let cursor = startFrame;
+  const pending = /* @__PURE__ */ new Map();
+  const enqueueAt = (frame, resolve35) => {
+    const list = pending.get(frame);
+    if (list === void 0) {
+      pending.set(frame, [resolve35]);
+    } else {
+      list.push(resolve35);
     }
   };
-  return {
-    waitForFrame: (frame) => new Promise((resolve35) => {
-      waiters.push({ frame, resolve: resolve35 });
-      resolveWaiters();
-    }),
-    advanceTo: (frame) => {
-      nextFrame = frame;
-      resolveWaiters();
-    },
-    waitForAllDone: () => new Promise((resolve35) => {
-      waiters.push({ frame: endFrame, resolve: resolve35 });
-      resolveWaiters();
-    })
+  const flushAt = (frame) => {
+    const list = pending.get(frame);
+    if (list === void 0) return;
+    pending.delete(frame);
+    for (const resolve35 of list) resolve35();
+  };
+  const waitForFrame = (frame) => new Promise((resolve35) => {
+    if (frame === cursor) {
+      resolve35();
+      return;
+    }
+    enqueueAt(frame, resolve35);
+  });
+  const advanceTo = (frame) => {
+    cursor = frame;
+    flushAt(frame);
   };
+  const waitForAllDone = () => new Promise((resolve35) => {
+    if (cursor >= endFrame) {
+      resolve35();
+      return;
+    }
+    enqueueAt(endFrame, resolve35);
+  });
+  return { waitForFrame, advanceTo, waitForAllDone };
 }
 function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
   const {
@@ -21747,19 +21889,36 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     useGpu = false,
     imageFormat = "jpeg"
   } = options;
-  const inputCodec = imageFormat === "png" ? "png" : "mjpeg";
-  const args = [
-    "-f",
-    "image2pipe",
-    "-vcodec",
-    inputCodec,
-    "-framerate",
-    String(fps),
-    "-i",
-    "-",
-    "-r",
-    String(fps)
-  ];
+  const args = [];
+  if (options.rawInputFormat) {
+    const hdrTransfer = options.hdr?.transfer;
+    const inputColorTrc = hdrTransfer === "pq" ? "smpte2084" : hdrTransfer === "hlg" ? "arib-std-b67" : void 0;
+    args.push(
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      options.rawInputFormat,
+      "-s",
+      `${options.width}x${options.height}`,
+      "-framerate",
+      String(fps)
+    );
+    if (inputColorTrc) {
+      args.push(
+        "-color_primaries",
+        "bt2020",
+        "-color_trc",
+        inputColorTrc,
+        "-colorspace",
+        "bt2020nc"
+      );
+    }
+    args.push("-i", "-");
+  } else {
+    const inputCodec = imageFormat === "png" ? "png" : "mjpeg";
+    args.push("-f", "image2pipe", "-vcodec", inputCodec, "-framerate", String(fps), "-i", "-");
+  }
+  args.push("-r", String(fps));
   const shouldUseGpu = useGpu && gpuEncoder !== null;
   if (codec === "h264" || codec === "h265") {
     if (shouldUseGpu) {
@@ -21797,12 +21956,15 @@ function buildStreamingArgs(options, 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 = options.rawInputFormat && options.hdr ? getHdrEncoderColorParams(options.hdr.transfer).x265ColorParams : "colorprim=bt709:transfer=bt709:colormatrix=bt709";
       if (preset === "ultrafast") {
         args.push(xParamsFlag, `aq-mode=3:${colorParams}`);
       } else {
         args.push(xParamsFlag, `aq-mode=3:aq-strength=0.8:deblock=1,1:${colorParams}`);
       }
+      if (codec === "h265") {
+        args.push("-tag:v", "hvc1");
+      }
     }
   } else if (codec === "vp9") {
     args.push("-c:v", "libvpx-vp9", "-b:v", bitrate || "0", "-crf", String(quality));
@@ -21818,17 +21980,31 @@ function buildStreamingArgs(options, 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 (gpuEncoder === "vaapi") {
+    if (options.rawInputFormat && options.hdr) {
+      args.push(
+        "-colorspace:v",
+        "bt2020nc",
+        "-color_primaries:v",
+        "bt2020",
+        "-color_trc:v",
+        options.hdr.transfer === "pq" ? "smpte2084" : "arib-std-b67",
+        "-color_range",
+        "tv"
+      );
+    } else {
+      args.push(
+        "-colorspace:v",
+        "bt709",
+        "-color_primaries:v",
+        "bt709",
+        "-color_trc:v",
+        "bt709",
+        "-color_range",
+        "tv"
+      );
+    }
+    if (options.rawInputFormat) {
+    } else if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
         args[vfIdx + 1] = `scale=in_range=pc:out_range=tv,${args[vfIdx + 1]}`;
@@ -21898,14 +22074,16 @@ Process error: ${err.message}`;
       if (exitStatus !== "running" || !ffmpeg.stdin || ffmpeg.stdin.destroyed) {
         return false;
       }
-      return ffmpeg.stdin.write(buffer);
+      const copy = Buffer.from(buffer);
+      return ffmpeg.stdin.write(copy);
     },
     close: async () => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      if (ffmpeg.stdin && !ffmpeg.stdin.destroyed) {
+      const stdin = ffmpeg.stdin;
+      if (stdin && !stdin.destroyed) {
         await new Promise((resolve35) => {
-          ffmpeg.stdin.end(() => resolve35());
+          stdin.end(() => resolve35());
         });
       }
       await exitPromise;
@@ -21937,6 +22115,7 @@ var init_streamingEncoder = __esm({
   "../engine/src/services/streamingEncoder.ts"() {
     "use strict";
     init_gpuEncoder();
+    init_hdr();
     init_config2();
   }
 });
@@ -22009,6 +22188,10 @@ async function extractVideoMetadata(filePath) {
     const avgFps = parseFrameRate(videoStream.avg_frame_rate);
     const fps = avgFps || rFps;
     const isVFR = rFps > 0 && avgFps > 0 && Math.abs(rFps - avgFps) / Math.max(rFps, avgFps) > 0.1;
+    const colorTransfer = videoStream.color_transfer || "";
+    const colorPrimaries = videoStream.color_primaries || "";
+    const colorSpaceVal = videoStream.color_space || "";
+    const hasColorInfo = !!(colorTransfer || colorPrimaries || colorSpaceVal);
     return {
       durationSeconds: output.format.duration ? parseFloat(output.format.duration) : 0,
       width: videoStream.width || 0,
@@ -22016,7 +22199,8 @@ async function extractVideoMetadata(filePath) {
       fps,
       videoCodec: videoStream.codec_name || "unknown",
       hasAudio: output.streams.some((s2) => s2.codec_type === "audio"),
-      isVFR
+      isVFR,
+      colorSpace: hasColorInfo ? { colorTransfer, colorPrimaries, colorSpace: colorSpaceVal } : null
     };
   })();
   videoMetadataCache.set(filePath, probePromise);
@@ -22241,18 +22425,20 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const metadata = await extractVideoMetadata(videoPath);
   const framePattern = `frame_%05d.${format}`;
   const outputPattern = join21(videoOutputDir, framePattern);
-  const args = [
-    "-ss",
-    String(startTime),
-    "-i",
-    videoPath,
-    "-t",
-    String(duration),
-    "-vf",
-    `fps=${fps}`,
-    "-q:v",
-    format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0"
-  ];
+  const isHdr = isHdrColorSpace(metadata.colorSpace);
+  const isMacOS = process.platform === "darwin";
+  const args = [];
+  if (isHdr && isMacOS) {
+    args.push("-hwaccel", "videotoolbox");
+  }
+  args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
+  const vfFilters = [];
+  if (isHdr && isMacOS) {
+    vfFilters.push("format=nv12");
+  }
+  vfFilters.push(`fps=${fps}`);
+  args.push("-vf", vfFilters.join(","));
+  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((resolve35, reject) => {
@@ -22312,30 +22498,100 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     });
   });
 }
+async function convertSdrToHdr(inputPath, outputPath, signal, config) {
+  const timeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
+  const args = [
+    "-i",
+    inputPath,
+    "-vf",
+    "colorspace=all=bt2020:iall=bt709:range=tv",
+    "-color_primaries",
+    "bt2020",
+    "-color_trc",
+    "arib-std-b67",
+    "-colorspace",
+    "bt2020nc",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "16",
+    "-c:a",
+    "copy",
+    "-y",
+    outputPath
+  ];
+  const result = await runFfmpeg(args, { signal, timeout });
+  if (!result.success) {
+    throw new Error(
+      `SDR\u2192HDR conversion failed (exit ${result.exitCode}): ${result.stderr.slice(-300)}`
+    );
+  }
+}
 async function extractAllVideoFrames(videos, baseDir, options, signal, config, compiledDir) {
   const startTime = Date.now();
   const extracted = [];
   const errors = [];
   let totalFramesExtracted = 0;
+  const resolvedVideos = [];
+  for (const video of videos) {
+    if (signal?.aborted) break;
+    try {
+      let videoPath = video.src;
+      if (!videoPath.startsWith("/") && !isHttpUrl(videoPath)) {
+        const fromCompiled = compiledDir ? join21(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync18(fromCompiled) ? fromCompiled : join21(baseDir, videoPath);
+      }
+      if (isHttpUrl(videoPath)) {
+        const downloadDir = join21(options.outputDir, "_downloads");
+        mkdirSync12(downloadDir, { recursive: true });
+        videoPath = await downloadToTemp(videoPath, downloadDir);
+      }
+      if (!existsSync18(videoPath)) {
+        errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
+        continue;
+      }
+      resolvedVideos.push({ video, videoPath });
+    } catch (err) {
+      errors.push({ videoId: video.id, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  const videoColorSpaces = await Promise.all(
+    resolvedVideos.map(async ({ videoPath }) => {
+      const metadata = await extractVideoMetadata(videoPath);
+      return metadata.colorSpace;
+    })
+  );
+  const hasAnyHdr = videoColorSpaces.some(isHdrColorSpace);
+  if (hasAnyHdr) {
+    const convertDir = join21(options.outputDir, "_hdr_normalized");
+    mkdirSync12(convertDir, { recursive: true });
+    for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
+      if (signal?.aborted) break;
+      const cs = videoColorSpaces[i2] ?? null;
+      if (!isHdrColorSpace(cs)) {
+        const entry = resolvedVideos[i2];
+        if (!entry) continue;
+        const convertedPath = join21(convertDir, `${entry.video.id}_hdr.mp4`);
+        try {
+          await convertSdrToHdr(entry.videoPath, convertedPath, signal, config);
+          entry.videoPath = convertedPath;
+        } catch (err) {
+          errors.push({
+            videoId: entry.video.id,
+            error: `SDR\u2192HDR conversion failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      }
+    }
+  }
   const results = await Promise.all(
-    videos.map(async (video) => {
+    resolvedVideos.map(async ({ video, videoPath }) => {
       if (signal?.aborted) {
         throw new Error("Video frame extraction cancelled");
       }
       try {
-        let videoPath = video.src;
-        if (!videoPath.startsWith("/") && !isHttpUrl(videoPath)) {
-          const fromCompiled = compiledDir ? join21(compiledDir, videoPath) : null;
-          videoPath = fromCompiled && existsSync18(fromCompiled) ? fromCompiled : join21(baseDir, videoPath);
-        }
-        if (isHttpUrl(videoPath)) {
-          const downloadDir = join21(options.outputDir, "_downloads");
-          mkdirSync12(downloadDir, { recursive: true });
-          videoPath = await downloadToTemp(videoPath, downloadDir);
-        }
-        if (!existsSync18(videoPath)) {
-          return { error: { videoId: video.id, error: `Video file not found: ${videoPath}` } };
-        }
         let videoDuration = video.end - video.start;
         if (!Number.isFinite(videoDuration) || videoDuration <= 0) {
           const metadata = await extractVideoMetadata(videoPath);
@@ -22402,7 +22658,9 @@ var init_videoFrameExtractor = __esm({
     "use strict";
     init_esm10();
     init_ffprobe();
+    init_hdr();
     init_urlDownloader();
+    init_runFfmpeg();
     init_config2();
     FrameLookupTable = class {
       videos = /* @__PURE__ */ new Map();
@@ -22580,6 +22838,112 @@ function createVideoFrameInjector(frameLookup, config) {
     }
   };
 }
+async function hideVideoElements(page, videoIds) {
+  if (videoIds.length === 0) return;
+  await page.evaluate((ids) => {
+    for (const id of ids) {
+      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");
+      }
+    }
+  }, videoIds);
+}
+async function showVideoElements(page, videoIds) {
+  if (videoIds.length === 0) return;
+  await page.evaluate((ids) => {
+    for (const id of ids) {
+      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");
+      }
+    }
+  }, videoIds);
+}
+async function queryVideoElementBounds(page, videoIds) {
+  if (videoIds.length === 0) return [];
+  return page.evaluate((ids) => {
+    return ids.map((id) => {
+      const el = document.getElementById(id);
+      if (!el) {
+        return {
+          videoId: id,
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0,
+          opacity: 0,
+          transform: "none",
+          zIndex: 0,
+          visible: false
+        };
+      }
+      const rect = el.getBoundingClientRect();
+      const style = window.getComputedStyle(el);
+      const zIndex = parseInt(style.zIndex) || 0;
+      const opacity = parseFloat(style.opacity) || 1;
+      const transform = style.transform || "none";
+      const visible = style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
+      return {
+        videoId: id,
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        opacity,
+        transform,
+        zIndex,
+        visible
+      };
+    });
+  }, videoIds);
+}
+async function queryElementStacking(page, nativeHdrVideoIds) {
+  const hdrIds = Array.from(nativeHdrVideoIds);
+  return page.evaluate((hdrIdList) => {
+    const hdrSet = new Set(hdrIdList);
+    const elements = document.querySelectorAll("[data-start]");
+    const results = [];
+    function getEffectiveZIndex(node) {
+      let current = node;
+      while (current) {
+        const cs = window.getComputedStyle(current);
+        const pos = cs.position;
+        const z3 = parseInt(cs.zIndex);
+        if (!Number.isNaN(z3) && pos !== "static") return z3;
+        current = current.parentElement;
+      }
+      return 0;
+    }
+    for (const el of elements) {
+      const id = el.id;
+      if (!id) continue;
+      const rect = el.getBoundingClientRect();
+      const style = window.getComputedStyle(el);
+      const zIndex = getEffectiveZIndex(el);
+      const opacity = parseFloat(style.opacity) || 1;
+      const visible = style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
+      results.push({
+        id,
+        zIndex,
+        x: Math.round(rect.x),
+        y: Math.round(rect.y),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        opacity,
+        visible,
+        isHdr: hdrSet.has(id)
+      });
+    }
+    return results;
+  }, hdrIds);
+}
 var init_videoFrameInjector = __esm({
   "../engine/src/services/videoFrameInjector.ts"() {
     "use strict";
@@ -23234,6 +23598,515 @@ var init_fileServer = __esm({
   }
 });
 
+// ../engine/src/utils/alphaBlit.ts
+import { inflateSync } from "zlib";
+function paeth(a, b, c2) {
+  const p = a + b - c2;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc2 = Math.abs(p - c2);
+  if (pa <= pb && pa <= pc2) return a;
+  if (pb <= pc2) return b;
+  return c2;
+}
+function decodePngRaw(buf, caller) {
+  if (buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71 || buf[4] !== 13 || buf[5] !== 10 || buf[6] !== 26 || buf[7] !== 10) {
+    throw new Error(`${caller}: not a PNG file`);
+  }
+  let pos = 8;
+  let width = 0;
+  let height = 0;
+  let bitDepth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  let sawIhdr = false;
+  const idatChunks = [];
+  while (pos + 12 <= buf.length) {
+    const chunkLen = buf.readUInt32BE(pos);
+    const chunkType = buf.toString("ascii", pos + 4, pos + 8);
+    const chunkData = buf.subarray(pos + 8, pos + 8 + chunkLen);
+    if (chunkType === "IHDR") {
+      width = chunkData.readUInt32BE(0);
+      height = chunkData.readUInt32BE(4);
+      bitDepth = chunkData[8] ?? 0;
+      colorType = chunkData[9] ?? 0;
+      interlace = chunkData[12] ?? 0;
+      sawIhdr = true;
+    } else if (chunkType === "IDAT") {
+      idatChunks.push(Buffer.from(chunkData));
+    } else if (chunkType === "IEND") {
+      break;
+    }
+    pos += 12 + chunkLen;
+  }
+  if (!sawIhdr) {
+    throw new Error(`${caller}: PNG missing IHDR chunk`);
+  }
+  if (colorType !== 2 && colorType !== 6) {
+    throw new Error(`${caller}: unsupported color type ${colorType} (expected 2=RGB or 6=RGBA)`);
+  }
+  if (interlace !== 0) {
+    throw new Error(
+      `${caller}: Adam7-interlaced PNGs are not supported (interlace method ${interlace})`
+    );
+  }
+  const channels = colorType === 6 ? 4 : 3;
+  const bpp = channels * (bitDepth / 8);
+  const stride = width * bpp;
+  const compressed = Buffer.concat(idatChunks);
+  const decompressed = inflateSync(compressed);
+  const rawPixels = Buffer.allocUnsafe(height * stride);
+  const prevRow = new Uint8Array(stride);
+  const currRow = new Uint8Array(stride);
+  let srcPos = 0;
+  for (let y2 = 0; y2 < height; y2++) {
+    const filterType = decompressed[srcPos++] ?? 0;
+    const rawRow = decompressed.subarray(srcPos, srcPos + stride);
+    srcPos += stride;
+    switch (filterType) {
+      case 0:
+        currRow.set(rawRow);
+        break;
+      case 1:
+        for (let x4 = 0; x4 < stride; x4++) {
+          currRow[x4] = (rawRow[x4] ?? 0) + (x4 >= bpp ? currRow[x4 - bpp] ?? 0 : 0) & 255;
+        }
+        break;
+      case 2:
+        for (let x4 = 0; x4 < stride; x4++) {
+          currRow[x4] = (rawRow[x4] ?? 0) + (prevRow[x4] ?? 0) & 255;
+        }
+        break;
+      case 3:
+        for (let x4 = 0; x4 < stride; x4++) {
+          const left = x4 >= bpp ? currRow[x4 - bpp] ?? 0 : 0;
+          const up = prevRow[x4] ?? 0;
+          currRow[x4] = (rawRow[x4] ?? 0) + Math.floor((left + up) / 2) & 255;
+        }
+        break;
+      case 4:
+        for (let x4 = 0; x4 < stride; x4++) {
+          const left = x4 >= bpp ? currRow[x4 - bpp] ?? 0 : 0;
+          const up = prevRow[x4] ?? 0;
+          const upLeft = x4 >= bpp ? prevRow[x4 - bpp] ?? 0 : 0;
+          currRow[x4] = (rawRow[x4] ?? 0) + paeth(left, up, upLeft) & 255;
+        }
+        break;
+      default:
+        throw new Error(`${caller}: unknown filter type ${filterType} at row ${y2}`);
+    }
+    rawPixels.set(currRow, y2 * stride);
+    prevRow.set(currRow);
+  }
+  return { width, height, bitDepth, colorType, rawPixels };
+}
+function decodePng(buf) {
+  const { width, height, bitDepth, colorType, rawPixels } = decodePngRaw(buf, "decodePng");
+  if (bitDepth !== 8) {
+    throw new Error(`decodePng: unsupported bit depth ${bitDepth} (expected 8)`);
+  }
+  const output = new Uint8Array(width * height * 4);
+  if (colorType === 6) {
+    output.set(rawPixels);
+  } else {
+    for (let i2 = 0; i2 < width * height; i2++) {
+      output[i2 * 4 + 0] = rawPixels[i2 * 3 + 0] ?? 0;
+      output[i2 * 4 + 1] = rawPixels[i2 * 3 + 1] ?? 0;
+      output[i2 * 4 + 2] = rawPixels[i2 * 3 + 2] ?? 0;
+      output[i2 * 4 + 3] = 255;
+    }
+  }
+  return { width, height, data: output };
+}
+function decodePngToRgb48le(buf) {
+  const { width, height, bitDepth, colorType, rawPixels } = decodePngRaw(buf, "decodePngToRgb48le");
+  if (bitDepth !== 16) {
+    throw new Error(`decodePngToRgb48le: unsupported bit depth ${bitDepth} (expected 16)`);
+  }
+  const bpp = colorType === 6 ? 8 : 6;
+  const output = Buffer.allocUnsafe(width * height * 6);
+  for (let y2 = 0; y2 < height; y2++) {
+    const dstBase = y2 * width * 6;
+    const srcRowBase = y2 * width * bpp;
+    for (let x4 = 0; x4 < width; x4++) {
+      const srcBase = srcRowBase + x4 * bpp;
+      output[dstBase + x4 * 6 + 0] = rawPixels[srcBase + 1] ?? 0;
+      output[dstBase + x4 * 6 + 1] = rawPixels[srcBase + 0] ?? 0;
+      output[dstBase + x4 * 6 + 2] = rawPixels[srcBase + 3] ?? 0;
+      output[dstBase + x4 * 6 + 3] = rawPixels[srcBase + 2] ?? 0;
+      output[dstBase + x4 * 6 + 4] = rawPixels[srcBase + 5] ?? 0;
+      output[dstBase + x4 * 6 + 5] = rawPixels[srcBase + 4] ?? 0;
+    }
+  }
+  return { width, height, data: output };
+}
+function buildSrgbToHdrLut(transfer) {
+  const lut = new Uint16Array(256);
+  const hlgA = 0.17883277;
+  const hlgB = 1 - 4 * hlgA;
+  const hlgC = 0.5 - hlgA * Math.log(4 * hlgA);
+  const pqM1 = 0.1593017578125;
+  const pqM2 = 78.84375;
+  const pqC1 = 0.8359375;
+  const pqC2 = 18.8515625;
+  const pqC3 = 18.6875;
+  const pqMaxNits = 1e4;
+  const sdrNits = 203;
+  for (let i2 = 0; i2 < 256; i2++) {
+    const v = i2 / 255;
+    const linear = v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    let signal;
+    if (transfer === "hlg") {
+      signal = linear <= 1 / 12 ? Math.sqrt(3 * linear) : hlgA * Math.log(12 * linear - hlgB) + hlgC;
+    } else {
+      const Lp = Math.max(0, linear * sdrNits / pqMaxNits);
+      const Lm1 = Math.pow(Lp, pqM1);
+      signal = Math.pow((pqC1 + pqC2 * Lm1) / (1 + pqC3 * Lm1), pqM2);
+    }
+    lut[i2] = Math.min(65535, Math.round(signal * 65535));
+  }
+  return lut;
+}
+function getSrgbToHdrLut(transfer) {
+  return transfer === "pq" ? SRGB_TO_PQ : SRGB_TO_HLG;
+}
+function blitRgba8OverRgb48le(domRgba, canvas, width, height, transfer = "hlg") {
+  const pixelCount = width * height;
+  const lut = getSrgbToHdrLut(transfer);
+  for (let i2 = 0; i2 < pixelCount; i2++) {
+    const da = domRgba[i2 * 4 + 3] ?? 0;
+    if (da === 0) {
+      continue;
+    } else if (da === 255) {
+      const r16 = lut[domRgba[i2 * 4 + 0] ?? 0] ?? 0;
+      const g16 = lut[domRgba[i2 * 4 + 1] ?? 0] ?? 0;
+      const b16 = lut[domRgba[i2 * 4 + 2] ?? 0] ?? 0;
+      canvas.writeUInt16LE(r16, i2 * 6);
+      canvas.writeUInt16LE(g16, i2 * 6 + 2);
+      canvas.writeUInt16LE(b16, i2 * 6 + 4);
+    } else {
+      const alpha = da / 255;
+      const invAlpha = 1 - alpha;
+      const hdrR = (canvas[i2 * 6 + 0] ?? 0) | (canvas[i2 * 6 + 1] ?? 0) << 8;
+      const hdrG = (canvas[i2 * 6 + 2] ?? 0) | (canvas[i2 * 6 + 3] ?? 0) << 8;
+      const hdrB = (canvas[i2 * 6 + 4] ?? 0) | (canvas[i2 * 6 + 5] ?? 0) << 8;
+      const domR = lut[domRgba[i2 * 4 + 0] ?? 0] ?? 0;
+      const domG = lut[domRgba[i2 * 4 + 1] ?? 0] ?? 0;
+      const domB = lut[domRgba[i2 * 4 + 2] ?? 0] ?? 0;
+      canvas.writeUInt16LE(Math.round(domR * alpha + hdrR * invAlpha), i2 * 6);
+      canvas.writeUInt16LE(Math.round(domG * alpha + hdrG * invAlpha), i2 * 6 + 2);
+      canvas.writeUInt16LE(Math.round(domB * alpha + hdrB * invAlpha), i2 * 6 + 4);
+    }
+  }
+}
+function cornerAlpha(px, py, cx, cy, r2) {
+  const dx = px - cx;
+  const dy = py - cy;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  if (dist > r2 + 0.5) return 0;
+  if (dist > r2 - 0.5) return r2 + 0.5 - dist;
+  return 1;
+}
+function roundedRectAlpha(px, py, w, h3, radii) {
+  const [tl, tr, br, bl] = radii;
+  if (px < tl && py < tl) return cornerAlpha(px, py, tl, tl, tl);
+  if (px >= w - tr && py < tr) return cornerAlpha(px, py, w - tr, tr, tr);
+  if (px >= w - br && py >= h3 - br) return cornerAlpha(px, py, w - br, h3 - br, br);
+  if (px < bl && py >= h3 - bl) return cornerAlpha(px, py, bl, h3 - bl, bl);
+  return 1;
+}
+function blitRgb48leRegion(canvas, source, dx, dy, sw, sh, canvasWidth, canvasHeight, opacity, borderRadius) {
+  if (sw <= 0 || sh <= 0) return;
+  const op = opacity ?? 1;
+  const x0 = Math.max(0, dx);
+  const y0 = Math.max(0, dy);
+  const x1 = Math.min(canvasWidth, dx + sw);
+  const y1 = Math.min(canvasHeight, dy + sh);
+  if (x0 >= x1 || y0 >= y1) return;
+  const clippedW = x1 - x0;
+  const srcOffsetX = x0 - dx;
+  const srcOffsetY = y0 - dy;
+  const hasMask = borderRadius !== void 0;
+  if (op >= 0.999 && !hasMask) {
+    for (let y2 = 0; y2 < y1 - y0; y2++) {
+      const srcRowOff = ((srcOffsetY + y2) * sw + srcOffsetX) * 6;
+      const dstRowOff = ((y0 + y2) * canvasWidth + x0) * 6;
+      source.copy(canvas, dstRowOff, srcRowOff, srcRowOff + clippedW * 6);
+    }
+  } else {
+    for (let y2 = 0; y2 < y1 - y0; y2++) {
+      for (let x4 = 0; x4 < clippedW; x4++) {
+        let effectiveOp = op;
+        if (hasMask) {
+          const ma = roundedRectAlpha(srcOffsetX + x4, srcOffsetY + y2, sw, sh, borderRadius);
+          if (ma <= 0) continue;
+          effectiveOp *= ma;
+        }
+        const srcOff = ((srcOffsetY + y2) * sw + srcOffsetX + x4) * 6;
+        const dstOff = ((y0 + y2) * canvasWidth + x0 + x4) * 6;
+        if (effectiveOp >= 0.999) {
+          source.copy(canvas, dstOff, srcOff, srcOff + 6);
+        } else {
+          const invEff = 1 - effectiveOp;
+          const sr = source.readUInt16LE(srcOff);
+          const sg = source.readUInt16LE(srcOff + 2);
+          const sb = source.readUInt16LE(srcOff + 4);
+          const dr = canvas.readUInt16LE(dstOff);
+          const dg = canvas.readUInt16LE(dstOff + 2);
+          const db = canvas.readUInt16LE(dstOff + 4);
+          canvas.writeUInt16LE(Math.round(sr * effectiveOp + dr * invEff), dstOff);
+          canvas.writeUInt16LE(Math.round(sg * effectiveOp + dg * invEff), dstOff + 2);
+          canvas.writeUInt16LE(Math.round(sb * effectiveOp + db * invEff), dstOff + 4);
+        }
+      }
+    }
+  }
+}
+var SRGB_TO_HLG, SRGB_TO_PQ;
+var init_alphaBlit = __esm({
+  "../engine/src/utils/alphaBlit.ts"() {
+    "use strict";
+    SRGB_TO_HLG = buildSrgbToHdrLut("hlg");
+    SRGB_TO_PQ = buildSrgbToHdrLut("pq");
+  }
+});
+
+// ../engine/src/utils/layerCompositor.ts
+function groupIntoLayers(elements) {
+  const sorted = [...elements].sort((a, b) => a.zIndex - b.zIndex);
+  const layers = [];
+  for (const el of sorted) {
+    if (el.isHdr) {
+      layers.push({ type: "hdr", element: el });
+    } else {
+      const last = layers[layers.length - 1];
+      if (last && last.type === "dom") {
+        last.elementIds.push(el.id);
+      } else {
+        layers.push({ type: "dom", elementIds: [el.id] });
+      }
+    }
+  }
+  return layers;
+}
+var init_layerCompositor = __esm({
+  "../engine/src/utils/layerCompositor.ts"() {
+    "use strict";
+  }
+});
+
+// ../engine/src/services/hdrCapture.ts
+import { existsSync as existsSync22, readdirSync as readdirSync10 } from "fs";
+import { join as join25 } from "path";
+import { homedir as homedir6 } from "os";
+function linearToPQ(L2) {
+  const Lp = Math.max(0, L2 * SDR_NITS / PQ_MAX_NITS);
+  const Lm1 = Math.pow(Lp, PQ_M1);
+  return Math.pow((PQ_C1 + PQ_C2 * Lm1) / (1 + PQ_C3 * Lm1), PQ_M2);
+}
+function float16Decode(h3) {
+  const sign = h3 >> 15 & 1;
+  const exp = h3 >> 10 & 31;
+  const frac = h3 & 1023;
+  if (exp === 0) return (sign ? -1 : 1) * Math.pow(2, -14) * (frac / 1024);
+  if (exp === 31) return frac ? NaN : sign ? -Infinity : Infinity;
+  return (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + frac / 1024);
+}
+async function initHdrReadback(page, width, height) {
+  return page.evaluate(
+    async (w, h3) => {
+      if (!navigator.gpu) return false;
+      const adapter2 = await navigator.gpu.requestAdapter();
+      if (!adapter2) return false;
+      const device = await adapter2.requestDevice();
+      const bytesPerPixel = 8;
+      const bytesPerRow = Math.ceil(w * bytesPerPixel / 256) * 256;
+      const renderTexture = device.createTexture({
+        size: [w, h3],
+        format: "rgba16float",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING
+      });
+      const readBuffer = device.createBuffer({
+        size: bytesPerRow * h3,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+      const captureRuntime = {
+        device,
+        renderTexture,
+        readBuffer,
+        bytesPerRow,
+        width: w,
+        height: h3,
+        /**
+         * Upload pre-converted float16 RGBA data and read it back.
+         * The float16 data must be row-aligned to bytesPerRow.
+         *
+         * Input: base64-encoded Uint16Array (float16 RGBA, row-padded)
+         * Output: base64-encoded readback of the same texture
+         */
+        async uploadAndReadback(float16Base64) {
+          const binary = atob(float16Base64);
+          const bytes = new Uint8Array(binary.length);
+          for (let i2 = 0; i2 < binary.length; i2++) bytes[i2] = binary.charCodeAt(i2);
+          device.queue.writeTexture(
+            { texture: renderTexture },
+            bytes.buffer,
+            { bytesPerRow, rowsPerImage: h3 },
+            [w, h3]
+          );
+          const encoder = device.createCommandEncoder();
+          encoder.copyTextureToBuffer(
+            { texture: renderTexture },
+            { buffer: readBuffer, bytesPerRow },
+            [w, h3]
+          );
+          device.queue.submit([encoder.finish()]);
+          await readBuffer.mapAsync(GPUMapMode.READ);
+          const readBytes = new Uint8Array(readBuffer.getMappedRange().slice(0));
+          readBuffer.unmap();
+          let b64 = "";
+          const chunkSize = 32768;
+          for (let i2 = 0; i2 < readBytes.length; i2 += chunkSize) {
+            const slice = readBytes.subarray(i2, Math.min(i2 + chunkSize, readBytes.length));
+            b64 += String.fromCharCode(...slice);
+          }
+          return { base64: btoa(b64), bytesPerRow };
+        }
+      };
+      window.__hfHdrCapture = captureRuntime;
+      return true;
+    },
+    width,
+    height
+  );
+}
+async function uploadAndReadbackHdrFrame(page, float16Base64) {
+  const result = await page.evaluate(
+    async (b64) => {
+      const hdr = window.__hfHdrCapture;
+      if (!hdr) throw new Error("HDR capture not initialized");
+      return hdr.uploadAndReadback(b64);
+    },
+    float16Base64
+  );
+  return {
+    rawBuffer: Buffer.from(result.base64, "base64"),
+    bytesPerRow: result.bytesPerRow
+  };
+}
+function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
+  const data = new Uint16Array(rawBuffer.buffer, rawBuffer.byteOffset, rawBuffer.byteLength / 2);
+  const channelsPerRow = bytesPerRow / 2;
+  const output = Buffer.alloc(width * height * 6);
+  for (let y2 = 0; y2 < height; y2++) {
+    for (let x4 = 0; x4 < width; x4++) {
+      const srcIdx = y2 * channelsPerRow + x4 * 4;
+      const r2 = float16Decode(data[srcIdx] ?? 0);
+      const g = float16Decode(data[srcIdx + 1] ?? 0);
+      const b = float16Decode(data[srcIdx + 2] ?? 0);
+      const dstIdx = (y2 * width + x4) * 6;
+      output.writeUInt16LE(Math.round(Math.min(1, linearToPQ(r2)) * 65535), dstIdx);
+      output.writeUInt16LE(Math.round(Math.min(1, linearToPQ(g)) * 65535), dstIdx + 2);
+      output.writeUInt16LE(Math.round(Math.min(1, linearToPQ(b)) * 65535), dstIdx + 4);
+    }
+  }
+  return output;
+}
+function resolveHeadedChromePath() {
+  const baseDir = join25(homedir6(), ".cache", "puppeteer", "chrome");
+  if (!existsSync22(baseDir)) return void 0;
+  const versions = readdirSync10(baseDir).sort().reverse();
+  for (const version of versions) {
+    const candidates = [
+      join25(
+        baseDir,
+        version,
+        "chrome-mac-arm64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join25(
+        baseDir,
+        version,
+        "chrome-mac-x64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join25(baseDir, version, "chrome-linux64", "chrome"),
+      join25(baseDir, version, "chrome-win64", "chrome.exe")
+    ];
+    for (const binary of candidates) {
+      if (existsSync22(binary)) return binary;
+    }
+  }
+  return void 0;
+}
+async function launchHdrBrowser(width, height) {
+  let ppt;
+  try {
+    const mod = await import("puppeteer");
+    ppt = mod.default;
+  } catch (err) {
+    const code = err?.code;
+    if (code !== "ERR_MODULE_NOT_FOUND" && code !== "MODULE_NOT_FOUND") {
+      throw err;
+    }
+    const mod = await import("puppeteer-core");
+    ppt = mod.default;
+  }
+  if (!ppt) throw new Error("Neither puppeteer nor puppeteer-core found");
+  const chromePath = resolveHeadedChromePath();
+  if (!chromePath) {
+    throw new Error(
+      "[HDR] No Chrome binary found. Install: npx @puppeteer/browsers install chrome@stable"
+    );
+  }
+  const browser = await ppt.launch({
+    headless: false,
+    executablePath: chromePath,
+    args: buildHdrChromeArgs(width, height)
+  });
+  const page = await browser.newPage();
+  await page.setViewport({ width, height });
+  return { browser, page };
+}
+function buildHdrChromeArgs(width, height) {
+  return [
+    "--enable-unsafe-webgpu",
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--window-position=-10000,-10000",
+    `--window-size=${width},${height}`,
+    "--disable-background-timer-throttling",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-renderer-backgrounding",
+    "--disable-background-media-suspend",
+    "--disable-extensions",
+    "--disable-component-update",
+    "--disable-default-apps",
+    "--disable-sync",
+    "--no-zygote",
+    "--force-gpu-mem-available-mb=4096"
+  ];
+}
+var PQ_M1, PQ_M2, PQ_C1, PQ_C2, PQ_C3, PQ_MAX_NITS, SDR_NITS;
+var init_hdrCapture = __esm({
+  "../engine/src/services/hdrCapture.ts"() {
+    "use strict";
+    PQ_M1 = 0.1593017578125;
+    PQ_M2 = 78.84375;
+    PQ_C1 = 0.8359375;
+    PQ_C2 = 18.8515625;
+    PQ_C3 = 18.6875;
+    PQ_MAX_NITS = 1e4;
+    SDR_NITS = 203;
+  }
+});
+
 // ../engine/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -23243,13 +24116,19 @@ __export(src_exports, {
   FrameLookupTable: () => FrameLookupTable,
   MEDIA_VISUAL_STYLE_PROPERTIES: () => MEDIA_VISUAL_STYLE_PROPERTIES,
   acquireBrowser: () => acquireBrowser,
+  analyzeCompositionHdr: () => analyzeCompositionHdr,
   analyzeKeyframeIntervals: () => analyzeKeyframeIntervals,
   applyFaststart: () => applyFaststart,
   beginFrameCapture: () => beginFrameCapture,
+  blitRgb48leRegion: () => blitRgb48leRegion,
+  blitRgba8OverRgb48le: () => blitRgba8OverRgb48le,
   buildChromeArgs: () => buildChromeArgs,
+  buildHdrChromeArgs: () => buildHdrChromeArgs,
   calculateOptimalWorkers: () => calculateOptimalWorkers,
+  captureAlphaPng: () => captureAlphaPng,
   captureFrame: () => captureFrame,
   captureFrameToBuffer: () => captureFrameToBuffer,
+  captureScreenshotWithAlpha: () => captureScreenshotWithAlpha,
   cdpSessionCache: () => cdpSessionCache,
   closeCaptureSession: () => closeCaptureSession,
   createCaptureSession: () => createCaptureSession,
@@ -23257,7 +24136,10 @@ __export(src_exports, {
   createFrameLookupTable: () => createFrameLookupTable,
   createFrameReorderBuffer: () => createFrameReorderBuffer,
   createVideoFrameInjector: () => createVideoFrameInjector,
+  decodePng: () => decodePng,
+  decodePngToRgb48le: () => decodePngToRgb48le,
   detectGpuEncoder: () => detectGpuEncoder,
+  detectTransfer: () => detectTransfer,
   distributeFrames: () => distributeFrames,
   downloadToTemp: () => downloadToTemp,
   encodeFramesChunkedConcat: () => encodeFramesChunkedConcat,
@@ -23267,15 +24149,24 @@ __export(src_exports, {
   extractAudioMetadata: () => extractAudioMetadata,
   extractVideoFramesRange: () => extractVideoFramesRange,
   extractVideoMetadata: () => extractVideoMetadata,
+  float16ToPqRgb: () => float16ToPqRgb,
   getCapturePerfSummary: () => getCapturePerfSummary,
   getCdpSession: () => getCdpSession,
   getCompositionDuration: () => getCompositionDuration,
   getEncoderPreset: () => getEncoderPreset,
   getFrameAtTime: () => getFrameAtTime,
+  getHdrEncoderColorParams: () => getHdrEncoderColorParams,
+  getSrgbToHdrLut: () => getSrgbToHdrLut,
   getSystemResources: () => getSystemResources,
+  groupIntoLayers: () => groupIntoLayers,
+  hideVideoElements: () => hideVideoElements,
+  initHdrReadback: () => initHdrReadback,
+  initTransparentBackground: () => initTransparentBackground,
   initializeSession: () => initializeSession,
   injectVideoFramesBatch: () => injectVideoFramesBatch,
+  isHdrColorSpace: () => isHdrColorSpace,
   isHttpUrl: () => isHttpUrl,
+  launchHdrBrowser: () => launchHdrBrowser,
   mergeWorkerFrames: () => mergeWorkerFrames,
   muxVideoWithAudio: () => muxVideoWithAudio,
   pageScreenshotCapture: () => pageScreenshotCapture,
@@ -23284,11 +24175,15 @@ __export(src_exports, {
   prepareCaptureSessionForReuse: () => prepareCaptureSessionForReuse,
   processCompositionAudio: () => processCompositionAudio,
   quantizeTimeToFrame: () => quantizeTimeToFrame,
+  queryElementStacking: () => queryElementStacking,
+  queryVideoElementBounds: () => queryVideoElementBounds,
   releaseBrowser: () => releaseBrowser,
   resolveConfig: () => resolveConfig,
   resolveHeadlessShellPath: () => resolveHeadlessShellPath,
+  showVideoElements: () => showVideoElements,
   spawnStreamingEncoder: () => spawnStreamingEncoder,
-  syncVideoFrameVisibility: () => syncVideoFrameVisibility
+  syncVideoFrameVisibility: () => syncVideoFrameVisibility,
+  uploadAndReadbackHdrFrame: () => uploadAndReadbackHdrFrame
 });
 var init_src2 = __esm({
   "../engine/src/index.ts"() {
@@ -23307,6 +24202,12 @@ var init_src2 = __esm({
     init_src();
     init_ffprobe();
     init_urlDownloader();
+    init_alphaBlit();
+    init_layerCompositor();
+    init_hdrCapture();
+    init_screenshotService();
+    init_videoFrameInjector();
+    init_hdr();
   }
 });
 
@@ -23391,8 +24292,8 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync15, existsSync as existsSync22 } from "fs";
-import { join as join25, resolve as resolve11, isAbsolute as isAbsolute2, sep as sep2 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync23 } from "fs";
+import { join as join26, resolve as resolve11, isAbsolute as isAbsolute2, sep as sep2 } from "path";
 import { transformSync } from "esbuild";
 function parseHTMLContent(html) {
   const trimmed = html.trimStart().toLowerCase();
@@ -23460,7 +24361,7 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute2(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync22(filePath)) return null;
+  if (!existsSync23(filePath)) return null;
   try {
     return readFileSync15(filePath, "utf-8");
   } catch {
@@ -23468,7 +24369,7 @@ function safeReadFile(filePath) {
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync22(filePath)) return null;
+  if (!existsSync23(filePath)) return null;
   try {
     return readFileSync15(filePath);
   } catch {
@@ -23661,8 +24562,8 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join25(projectDir, "index.html");
-  if (!existsSync22(indexPath)) throw new Error("index.html not found in project directory");
+  const indexPath = join26(projectDir, "index.html");
+  if (!existsSync23(indexPath)) throw new Error("index.html not found in project directory");
   const rawHtml = readFileSync15(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
@@ -23938,7 +24839,7 @@ var init_compiler = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync23, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync16 } from "fs";
 import { dirname as dirname8, resolve as resolve12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -23951,7 +24852,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync23(candidate)) {
+    if (existsSync24(candidate)) {
       return candidate;
     }
   }
@@ -23962,7 +24863,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync23(manifestPath)) {
+  if (!existsSync24(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
@@ -23976,7 +24877,7 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve12(dirname8(manifestPath), runtimeFileName);
-  if (!existsSync23(runtimePath)) {
+  if (!existsSync24(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync16(runtimePath, "utf8");
@@ -24018,8 +24919,8 @@ 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 readFileSync17, existsSync as existsSync24, statSync as statSync7 } from "fs";
-import { join as join26, extname as extname6 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync25, statSync as statSync7 } from "fs";
+import { join as join27, extname as extname6 } from "path";
 function stripEmbeddedRuntimeScripts3(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -24079,8 +24980,22 @@ function injectScriptsIntoHtml2(html, headScripts, bodyScripts, stripEmbedded) {
   }
   return html;
 }
+function injectScriptsAtHeadStart(html, scripts) {
+  if (scripts.length === 0) return html;
+  const headTags = scripts.map((src) => `<script>${src}</script>`).join("\n");
+  if (html.includes("<head")) {
+    return html.replace(/<head\b[^>]*>/i, (match) => `${match}
+${headTags}`);
+  }
+  if (html.includes("<body")) {
+    return html.replace("<body", () => `${headTags}
+<body`);
+  }
+  return headTags + "\n" + html;
+}
 function createFileServer2(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
+  const preHeadScripts = [HF_EARLY_STUB, ...options.preHeadScripts ?? []];
   const headScripts = options.headScripts ?? [getVerifiedHyperframeRuntimeSource()];
   const bodyScripts = options.bodyScripts ?? [RENDER_MODE_SCRIPT, HF_BRIDGE_SCRIPT];
   const app = new Hono3();
@@ -24088,12 +25003,12 @@ function createFileServer2(options) {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join26(compiledDir, relativePath) : null;
+    const compiledPath = compiledDir ? join27(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync24(compiledPath) && statSync7(compiledPath).isFile()
+      compiledPath && existsSync25(compiledPath) && statSync7(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join26(projectDir, relativePath);
-    if (!existsSync24(filePath) || !statSync7(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join27(projectDir, relativePath);
+    if (!existsSync25(filePath) || !statSync7(filePath).isFile()) {
       if (!/favicon\.ico$/i.test(requestPath)) {
         console.warn(`[FileServer] 404 Not Found: ${requestPath}`);
       }
@@ -24104,7 +25019,11 @@ function createFileServer2(options) {
     if (ext === ".html") {
       const rawHtml = readFileSync17(filePath, "utf-8");
       const isIndex = relativePath === "index.html";
-      const html = isIndex ? injectScriptsIntoHtml2(rawHtml, headScripts, bodyScripts, stripEmbeddedRuntime) : rawHtml;
+      let html = rawHtml;
+      if (preHeadScripts.length > 0) {
+        html = injectScriptsAtHeadStart(html, preHeadScripts);
+      }
+      html = isIndex ? injectScriptsIntoHtml2(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
       return c2.text(html, 200, { "Content-Type": contentType });
     }
     const content = readFileSync17(filePath);
@@ -24132,7 +25051,7 @@ function createFileServer2(options) {
     });
   });
 }
-var MIME_TYPES3, RENDER_SEEK_MODE, RENDER_SEEK_DIAGNOSTICS, RENDER_SEEK_STEP, RENDER_SEEK_OFFSET_FRACTION, RENDER_MODE_SCRIPT, HF_BRIDGE_SCRIPT;
+var MIME_TYPES3, VIRTUAL_TIME_SHIM, RENDER_SEEK_MODE, RENDER_SEEK_DIAGNOSTICS, RENDER_SEEK_STEP, RENDER_SEEK_OFFSET_FRACTION, RENDER_MODE_SCRIPT, HF_EARLY_STUB, HF_BRIDGE_SCRIPT;
 var init_fileServer2 = __esm({
   "../producer/src/services/fileServer.ts"() {
     "use strict";
@@ -24159,6 +25078,102 @@ var init_fileServer2 = __esm({
       ".ttf": "font/ttf",
       ".otf": "font/otf"
     };
+    VIRTUAL_TIME_SHIM = String.raw`(function() {
+  if (window.__HF_VIRTUAL_TIME__) return;
+
+  var virtualNowMs = 0;
+  var rafId = 1;
+  var rafQueue = [];
+  var OriginalDate = Date;
+  var originalSetTimeout = window.setTimeout.bind(window);
+  var originalClearTimeout = window.clearTimeout.bind(window);
+  var originalSetInterval = window.setInterval.bind(window);
+  var originalClearInterval = window.clearInterval.bind(window);
+  var originalRequestAnimationFrame = window.requestAnimationFrame
+    ? window.requestAnimationFrame.bind(window)
+    : null;
+  var originalCancelAnimationFrame = window.cancelAnimationFrame
+    ? window.cancelAnimationFrame.bind(window)
+    : null;
+
+  function flushAnimationFrame() {
+    if (!rafQueue.length) return;
+    var current = rafQueue.slice();
+    rafQueue.length = 0;
+    for (var i = 0; i < current.length; i++) {
+      var entry = current[i];
+      if (entry.cancelled) continue;
+      try {
+        entry.callback(virtualNowMs);
+      } catch {}
+    }
+  }
+
+  function VirtualDate() {
+    var args = Array.prototype.slice.call(arguments);
+    if (!(this instanceof VirtualDate)) {
+      return OriginalDate.apply(null, args.length ? args : [virtualNowMs]);
+    }
+    var instance = args.length ? new (Function.prototype.bind.apply(OriginalDate, [null].concat(args)))() : new OriginalDate(virtualNowMs);
+    Object.setPrototypeOf(instance, VirtualDate.prototype);
+    return instance;
+  }
+
+  VirtualDate.prototype = OriginalDate.prototype;
+  Object.setPrototypeOf(VirtualDate, OriginalDate);
+  VirtualDate.now = function() { return virtualNowMs; };
+  VirtualDate.parse = OriginalDate.parse.bind(OriginalDate);
+  VirtualDate.UTC = OriginalDate.UTC.bind(OriginalDate);
+
+  try {
+    Object.defineProperty(window, "Date", {
+      configurable: true,
+      writable: true,
+      value: VirtualDate,
+    });
+  } catch {}
+
+  if (window.performance && typeof window.performance.now === "function") {
+    try {
+      Object.defineProperty(window.performance, "now", {
+        configurable: true,
+        value: function() { return virtualNowMs; },
+      });
+    } catch {}
+  }
+
+  window.requestAnimationFrame = function(callback) {
+    if (typeof callback !== "function") return 0;
+    var entry = { id: rafId++, callback: callback, cancelled: false };
+    rafQueue.push(entry);
+    return entry.id;
+  };
+  window.cancelAnimationFrame = function(id) {
+    for (var i = 0; i < rafQueue.length; i++) {
+      if (rafQueue[i].id === id) {
+        rafQueue[i].cancelled = true;
+      }
+    }
+  };
+
+  window.__HF_VIRTUAL_TIME__ = {
+    originalSetTimeout: originalSetTimeout,
+    originalClearTimeout: originalClearTimeout,
+    originalSetInterval: originalSetInterval,
+    originalClearInterval: originalClearInterval,
+    originalRequestAnimationFrame: originalRequestAnimationFrame,
+    originalCancelAnimationFrame: originalCancelAnimationFrame,
+    seekToTime: function(nextTimeMs) {
+      var safeTimeMs = Math.max(0, Number(nextTimeMs) || 0);
+      virtualNowMs = safeTimeMs;
+      flushAnimationFrame();
+      return virtualNowMs;
+    },
+    getTime: function() {
+      return virtualNowMs;
+    },
+  };
+})();`;
     RENDER_SEEK_MODE = process.env.PRODUCER_RUNTIME_RENDER_SEEK_MODE === "strict-boundary" ? "strict-boundary" : "preview-phase";
     RENDER_SEEK_DIAGNOSTICS = process.env.PRODUCER_DEBUG_SEEK_DIAGNOSTICS === "true";
     RENDER_SEEK_STEP = Math.max(
@@ -24170,6 +25185,10 @@ var init_fileServer2 = __esm({
       Math.min(0.95, Number(process.env.PRODUCER_RUNTIME_RENDER_SEEK_OFFSET_FRACTION || 0.5))
     );
     RENDER_MODE_SCRIPT = `(function() {
+  var __realSetTimeout =
+    window.__HF_VIRTUAL_TIME__ && typeof window.__HF_VIRTUAL_TIME__.originalSetTimeout === "function"
+      ? window.__HF_VIRTUAL_TIME__.originalSetTimeout
+      : window.setTimeout.bind(window);
   var __seekMode = ${JSON.stringify(RENDER_SEEK_MODE)};
   var __seekDiagnostics = ${RENDER_SEEK_DIAGNOSTICS ? "true" : "false"};
   var __seekStep = ${RENDER_SEEK_STEP};
@@ -24263,40 +25282,88 @@ var init_fileServer2 = __esm({
         window.__renderReady = true;
         return;
       }
-      setTimeout(waitForPlayer, 50);
+      __realSetTimeout(waitForPlayer, 50);
       return;
     }
     if (installMediaFallbackPlayer()) {
       return;
     }
-    setTimeout(waitForPlayer, 50);
+    __realSetTimeout(waitForPlayer, 50);
   }
   waitForPlayer();
+})();`;
+    HF_EARLY_STUB = `(function() {
+  if (typeof window === "undefined") return;
+  if (!window.__hf) window.__hf = {};
 })();`;
     HF_BRIDGE_SCRIPT = `(function() {
+  var __realSetInterval =
+    window.__HF_VIRTUAL_TIME__ && typeof window.__HF_VIRTUAL_TIME__.originalSetInterval === "function"
+      ? window.__HF_VIRTUAL_TIME__.originalSetInterval
+      : window.setInterval.bind(window);
+  var __realClearInterval =
+    window.__HF_VIRTUAL_TIME__ && typeof window.__HF_VIRTUAL_TIME__.originalClearInterval === "function"
+      ? window.__HF_VIRTUAL_TIME__.originalClearInterval
+      : window.clearInterval.bind(window);
   function getDeclaredDuration() {
     var root = document.querySelector('[data-composition-id]');
     if (!root) return 0;
     var d = Number(root.getAttribute('data-duration'));
     return Number.isFinite(d) && d > 0 ? d : 0;
   }
+  function seekSameOriginChildFrames(frameWindow, nextTimeMs) {
+    var frames;
+    try {
+      frames = frameWindow.frames;
+    } catch (_error) {
+      return;
+    }
+    if (!frames || typeof frames.length !== "number") return;
+    for (var i = 0; i < frames.length; i++) {
+      var childWindow = null;
+      try {
+        childWindow = frames[i];
+        if (!childWindow || childWindow === frameWindow) continue;
+        if (
+          childWindow.__HF_VIRTUAL_TIME__ &&
+          typeof childWindow.__HF_VIRTUAL_TIME__.seekToTime === "function"
+        ) {
+          childWindow.__HF_VIRTUAL_TIME__.seekToTime(nextTimeMs);
+        }
+      } catch (_error) {
+        continue;
+      }
+      seekSameOriginChildFrames(childWindow, nextTimeMs);
+    }
+  }
   function bridge() {
     var p = window.__player;
     if (!p || typeof p.renderSeek !== "function" || typeof p.getDuration !== "function") {
       return false;
     }
-    window.__hf = {
-      get duration() {
+    var hf = window.__hf || {};
+    Object.defineProperty(hf, "duration", {
+      configurable: true,
+      enumerable: true,
+      get: function() {
         var d = p.getDuration();
         return d > 0 ? d : getDeclaredDuration();
       },
-      seek: function(t) { p.renderSeek(t); },
+    });
+    hf.seek = function(t) {
+      p.renderSeek(t);
+      var nextTimeMs = (Math.max(0, Number(t) || 0)) * 1000;
+      if (window.__HF_VIRTUAL_TIME__ && typeof window.__HF_VIRTUAL_TIME__.seekToTime === "function") {
+        window.__HF_VIRTUAL_TIME__.seekToTime(nextTimeMs);
+      }
+      seekSameOriginChildFrames(window, nextTimeMs);
     };
+    window.__hf = hf;
     return true;
   }
   if (bridge()) return;
-  var iv = setInterval(function() {
-    if (bridge()) clearInterval(iv);
+  var iv = __realSetInterval(function() {
+    if (bridge()) __realClearInterval(iv);
   }, 50);
 })();`;
   }
@@ -24311,7 +25378,7 @@ var init_ffprobe2 = __esm({
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve13, basename, join as join27, relative as relative2, isAbsolute as isAbsolute3 } from "path";
+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);
@@ -24332,7 +25399,7 @@ function toExternalAssetKey(absPath) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = resolve13(projectDir);
   const projectName = basename(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join27(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join28(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve13(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -24405,9 +25472,9 @@ var init_fontData_generated = __esm({
 });
 
 // ../producer/src/services/deterministicFonts.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join29 } from "path";
 function normalizeFamilyName(family) {
   return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
 }
@@ -24518,14 +25585,14 @@ function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function fontCacheDir(slug) {
-  const dir = join28(GOOGLE_FONTS_CACHE_DIR, slug);
-  if (!existsSync25(dir)) {
+  const dir = join29(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync26(dir)) {
     mkdirSync15(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join28(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join29(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -24551,7 +25618,7 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match[3] || "";
     if (!woff2Url) continue;
     const cachePath2 = cachedWoff2Path(slug, weight, style);
-    if (!existsSync25(cachePath2)) {
+    if (!existsSync26(cachePath2)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
@@ -24737,14 +25804,14 @@ var init_deterministicFonts = __esm({
       poppins: "poppins",
       "segoe ui": "roboto"
     };
-    GOOGLE_FONTS_CACHE_DIR = join28(homedir6(), ".cache", "hyperframes", "fonts");
+    GOOGLE_FONTS_CACHE_DIR = join29(homedir7(), ".cache", "hyperframes", "fonts");
     WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
   }
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync19, existsSync as existsSync26, mkdirSync as mkdirSync16 } from "fs";
-import { join as join29, dirname as dirname9, resolve as resolve14 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync27, mkdirSync as mkdirSync16 } from "fs";
+import { join as join30, dirname as dirname9, resolve as resolve14 } from "path";
 import postcss from "postcss";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -24753,19 +25820,49 @@ function dedupeElementsById(elements) {
   }
   return Array.from(deduped.values());
 }
+function stripJsComments(source) {
+  return source.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function detectRenderModeHints(html) {
+  const reasons = [];
+  const { document: document2 } = parseHTML(html);
+  if (document2.querySelector("iframe")) {
+    reasons.push({
+      code: "iframe",
+      message: "Detected <iframe> in the composition DOM. Nested iframe animation is routed through screenshot capture mode for compatibility."
+    });
+  }
+  let scriptMatch;
+  const scriptPattern = new RegExp(INLINE_SCRIPT_PATTERN.source, INLINE_SCRIPT_PATTERN.flags);
+  while ((scriptMatch = scriptPattern.exec(html)) !== null) {
+    const attrs = scriptMatch[1] || "";
+    if (/\bsrc\s*=/i.test(attrs)) continue;
+    const content = stripJsComments(scriptMatch[2] || "");
+    if (!/requestAnimationFrame\s*\(/.test(content)) continue;
+    reasons.push({
+      code: "requestAnimationFrame",
+      message: "Detected raw requestAnimationFrame() in an inline script. This render is routed through screenshot capture mode with virtual time enabled."
+    });
+    break;
+  }
+  return {
+    recommendScreenshot: reasons.length > 0,
+    reasons
+  };
+}
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync26(downloadDir)) mkdirSync16(downloadDir, { recursive: true });
+    if (!existsSync27(downloadDir)) mkdirSync16(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join29(baseDir, filePath);
+    filePath = join30(baseDir, filePath);
   }
-  if (!existsSync26(filePath)) {
+  if (!existsSync27(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractVideoMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -24833,7 +25930,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync26(filePath)) {
+    if (!existsSync27(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync19(filePath, "utf-8");
@@ -25030,7 +26127,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve14(projectDir, srcPath);
-      if (existsSync26(filePath)) {
+      if (existsSync27(filePath)) {
         compHtml = readFileSync19(filePath, "utf-8");
       }
     }
@@ -25254,7 +26351,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync26(absPath)) return null;
+    if (!existsSync27(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -25316,6 +26413,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir) {
     /(<(?:video|audio)\b[^>]*?)\s+preload\s*=\s*["']none["']/gi,
     "$1"
   );
+  const renderModeHints = detectRenderModeHints(sanitizedHtml);
   const coalescedHtml = await injectDeterministicFontFaces(
     coalesceHeadStylesAndBodyScripts2(promoteCssImportsToLinkTags(sanitizedHtml))
   );
@@ -25359,7 +26457,8 @@ async function compileForRender(projectDir, htmlPath, downloadDir) {
     externalAssets,
     width,
     height,
-    staticDuration
+    staticDuration,
+    renderModeHints
   };
 }
 async function discoverMediaFromBrowser(page) {
@@ -25453,9 +26552,11 @@ async function recompileWithResolutions(compiled, resolutions, projectDir, downl
     subCompositions,
     videos,
     audios,
-    unresolvedCompositions: remaining
+    unresolvedCompositions: remaining,
+    renderModeHints: compiled.renderModeHints
   };
 }
+var INLINE_SCRIPT_PATTERN;
 var init_htmlCompiler2 = __esm({
   "../producer/src/services/htmlCompiler.ts"() {
     "use strict";
@@ -25466,6 +26567,7 @@ var init_htmlCompiler2 = __esm({
     init_src2();
     init_urlDownloader2();
     init_deterministicFonts();
+    INLINE_SCRIPT_PATTERN = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
   }
 });
 
@@ -25513,15 +26615,16 @@ var init_logger = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync17,
   rmSync as rmSync6,
   readFileSync as readFileSync20,
+  readdirSync as readdirSync11,
   writeFileSync as writeFileSync10,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join30, dirname as dirname10, resolve as resolve15 } from "path";
+import { join as join31, dirname as dirname10, resolve as resolve15 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -25534,6 +26637,22 @@ async function safeCleanup(label2, fn, log = defaultLogger) {
     });
   }
 }
+function getMaxFrameIndex(frameDir) {
+  const cached2 = frameDirMaxIndexCache.get(frameDir);
+  if (cached2 !== void 0) return cached2;
+  let max = 0;
+  try {
+    for (const name of readdirSync11(frameDir)) {
+      const m2 = FRAME_FILENAME_RE.exec(name);
+      if (!m2) continue;
+      const n = Number(m2[1]);
+      if (Number.isFinite(n) && n > max) max = n;
+    }
+  } catch {
+  }
+  frameDirMaxIndexCache.set(frameDir, max);
+  return max;
+}
 function updateJobStatus(job, status, stage, progress, onProgress) {
   job.status = status;
   job.currentStage = stage;
@@ -25577,16 +26696,16 @@ function installDebugLogger(logPath, log = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join30(workDir, "compiled");
+  const compileDir = join31(workDir, "compiled");
   mkdirSync17(compileDir, { recursive: true });
-  writeFileSync10(join30(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync10(join31(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join30(compileDir, srcPath);
+    const outPath = join31(compileDir, srcPath);
     mkdirSync17(dirname10(outPath), { recursive: true });
     writeFileSync10(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve15(join30(compileDir, relativePath));
+    const outPath = resolve15(join31(compileDir, relativePath));
     if (!isPathInside(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
@@ -25613,11 +26732,20 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
         end: a.end,
         mediaStart: a.mediaStart
       })),
-      subCompositions: Array.from(compiled.subCompositions.keys())
+      subCompositions: Array.from(compiled.subCompositions.keys()),
+      renderModeHints: compiled.renderModeHints
     };
-    writeFileSync10(join30(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync10(join31(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
+function applyRenderModeHints(cfg, compiled, log = defaultLogger) {
+  if (cfg.forceScreenshot || !compiled.renderModeHints.recommendScreenshot) return;
+  cfg.forceScreenshot = true;
+  log.warn("Auto-selected screenshot capture mode for render compatibility", {
+    reasonCodes: compiled.renderModeHints.reasons.map((reason) => reason.code),
+    reasons: compiled.renderModeHints.reasons.map((reason) => reason.message)
+  });
+}
 function createRenderJob(config) {
   return {
     id: randomUUID2(),
@@ -25660,8 +26788,8 @@ 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 debugDir = join30(producerRoot, ".debug");
-  const workDir = job.config.debug ? join30(debugDir, job.id) : join30(dirname10(outputPath), `work-${job.id}`);
+  const debugDir = join31(producerRoot, ".debug");
+  const workDir = job.config.debug ? join31(debugDir, job.id) : join31(dirname10(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -25669,7 +26797,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
   let lastBrowserConsole = [];
   let restoreLogger = null;
   const perfStages = {};
-  const perfOutputPath = join30(workDir, "perf-summary.json");
+  const perfOutputPath = join31(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -25689,22 +26817,22 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync27(workDir)) mkdirSync17(workDir, { recursive: true });
+    if (!existsSync28(workDir)) mkdirSync17(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join30(workDir, "render.log");
+      const logPath = join31(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join30(projectDir, entryFile);
-    if (!existsSync27(htmlPath)) {
+    let htmlPath = join31(projectDir, entryFile);
+    if (!existsSync28(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync20(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join30(workDir, "standalone-entry.html");
-      const projectIndexPath = join30(projectDir, "index.html");
-      if (!existsSync27(projectIndexPath)) {
+      const wrapperPath = join31(workDir, "standalone-entry.html");
+      const projectIndexPath = join31(projectDir, "index.html");
+      if (!existsSync28(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -25727,9 +26855,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const stage1Start = Date.now();
     updateJobStatus(job, "preprocessing", "Compiling composition", 5, onProgress);
     const compileStart = Date.now();
-    let compiled = await compileForRender(projectDir, htmlPath, join30(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join31(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
+    applyRenderModeHints(cfg, compiled, log);
     writeCompiledArtifacts(compiled, workDir, Boolean(job.config.debug));
     log.info("Compiled composition metadata", {
       entryFile,
@@ -25737,7 +26866,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       width: compiled.width,
       height: compiled.height,
       videoCount: compiled.videos.length,
-      audioCount: compiled.audios.length
+      audioCount: compiled.audios.length,
+      renderModeHints: compiled.renderModeHints
     });
     const composition = {
       duration: compiled.staticDuration,
@@ -25756,8 +26886,9 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join30(workDir, "compiled"),
-        port: 0
+        compiledDir: join31(workDir, "compiled"),
+        port: 0,
+        preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
       const captureOpts = {
@@ -25769,7 +26900,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join30(workDir, "probe"),
+        join31(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -25801,7 +26932,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join30(workDir, "downloads")
+            join31(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -25913,7 +27044,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
         }
-      } catch {
+      } catch (err) {
+        log.warn("Failed to gather browser diagnostics for zero-duration composition", {
+          error: err instanceof Error ? err.message : String(err)
+        });
         diagnostics.push("(Could not gather browser diagnostics \u2014 page may have crashed)");
       }
       const hint = diagnostics.length > 0 ? "\n\nDiagnostics:\n  - " + diagnostics.join("\n  - ") : "\n\nCheck that GSAP timelines are registered on window.__timelines.";
@@ -25936,12 +27070,30 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const stage2Start = Date.now();
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
     let frameLookup = null;
-    const compiledDir = join30(workDir, "compiled");
+    const compiledDir = join31(workDir, "compiled");
+    let extractionResult = null;
+    const nativeHdrVideoIds = /* @__PURE__ */ new Set();
+    if (composition.videos.length > 0) {
+      await Promise.all(
+        composition.videos.map(async (v) => {
+          let videoPath = v.src;
+          if (!videoPath.startsWith("/")) {
+            const fromCompiled = existsSync28(join31(compiledDir, videoPath)) ? join31(compiledDir, videoPath) : join31(projectDir, videoPath);
+            videoPath = fromCompiled;
+          }
+          if (!existsSync28(videoPath)) return;
+          const meta = await extractVideoMetadata(videoPath);
+          if (isHdrColorSpace(meta.colorSpace)) {
+            nativeHdrVideoIds.add(v.id);
+          }
+        })
+      );
+    }
     if (composition.videos.length > 0) {
-      const extractionResult = await extractAllVideoFrames(
+      extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join30(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join31(workDir, "video-frames") },
         abortSignal,
         void 0,
         compiledDir
@@ -25973,15 +27125,32 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     } else {
       perfStages.videoExtractMs = Date.now() - stage2Start;
     }
+    let effectiveHdr;
+    if (frameLookup) {
+      const colorSpaces = (extractionResult?.extracted ?? []).map((ext) => ext.metadata.colorSpace);
+      const info = analyzeCompositionHdr(colorSpaces);
+      if (info.hasHdr && info.dominantTransfer) {
+        effectiveHdr = { transfer: info.dominantTransfer };
+      }
+    }
+    if (effectiveHdr && outputFormat !== "mp4") {
+      log.info(`[Render] HDR source detected but format is ${outputFormat} \u2014 using SDR`);
+      effectiveHdr = void 0;
+    }
+    if (effectiveHdr) {
+      log.info(
+        `[Render] HDR source detected \u2014 output: ${effectiveHdr.transfer.toUpperCase()} (BT.2020, 10-bit H.265)`
+      );
+    }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join30(workDir, "audio.aac");
+    const audioOutputPath = join31(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join30(workDir, "audio-work"),
+        join31(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -25999,13 +27168,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join30(workDir, "compiled"),
-        port: 0
+        compiledDir: join31(workDir, "compiled"),
+        port: 0,
+        preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join30(workDir, "captured-frames");
-    if (!existsSync27(framesDir)) mkdirSync17(framesDir, { recursive: true });
+    const framesDir = join31(workDir, "captured-frames");
+    if (!existsSync28(framesDir)) mkdirSync17(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -26016,219 +27186,399 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const workerCount = calculateOptimalWorkers(job.totalFrames, job.config.workers, cfg);
     const FORMAT_EXT2 = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
     const videoExt = FORMAT_EXT2[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join30(workDir, `video-only${videoExt}`);
-    const preset = getEncoderPreset(job.config.quality, outputFormat);
-    const effectiveQuality = job.config.crf ?? preset.quality;
-    const effectiveBitrate = job.config.videoBitrate;
-    const baseEncoderOpts = {
-      fps: job.config.fps,
-      width,
-      height,
-      codec: preset.codec,
-      preset: preset.preset,
-      quality: effectiveQuality,
-      bitrate: effectiveBitrate,
-      pixelFormat: preset.pixelFormat,
-      useGpu: job.config.useGpu
-    };
+    const videoOnlyPath = join31(workDir, `video-only${videoExt}`);
+    const hasHdrVideo = effectiveHdr && composition.videos.length > 0 && frameLookup;
+    const encoderHdr = hasHdrVideo ? effectiveHdr : void 0;
+    const preset = getEncoderPreset(job.config.quality, outputFormat, encoderHdr);
     job.framesRendered = 0;
-    let streamingEncoder = null;
-    if (enableStreamingEncode) {
-      streamingEncoder = await spawnStreamingEncoder(
+    if (hasHdrVideo) {
+      log.info("[Render] HDR layered composite: z-ordered DOM + native HLG video layers");
+      const hdrVideoIds = composition.videos.filter((v) => nativeHdrVideoIds.has(v.id)).map((v) => v.id);
+      const hdrVideoSrcPaths = /* @__PURE__ */ new Map();
+      for (const v of composition.videos) {
+        if (!hdrVideoIds.includes(v.id)) continue;
+        let srcPath = v.src;
+        if (!srcPath.startsWith("/")) {
+          const fromCompiled = join31(compiledDir, srcPath);
+          srcPath = existsSync28(fromCompiled) ? fromCompiled : join31(projectDir, srcPath);
+        }
+        hdrVideoSrcPaths.set(v.id, srcPath);
+      }
+      const domSession = await createCaptureSession(
+        fileServer.url,
+        framesDir,
+        captureOptions,
+        createVideoFrameInjector(frameLookup),
+        cfg
+      );
+      await initializeSession(domSession);
+      assertNotAborted();
+      lastBrowserConsole = domSession.browserConsoleBuffer;
+      await initTransparentBackground(domSession.page);
+      const hdrEncoder = await spawnStreamingEncoder(
         videoOnlyPath,
         {
-          ...baseEncoderOpts,
-          imageFormat: captureOptions.format || "jpeg"
+          fps: job.config.fps,
+          width,
+          height,
+          codec: preset.codec,
+          preset: preset.preset,
+          quality: preset.quality,
+          pixelFormat: preset.pixelFormat,
+          hdr: preset.hdr,
+          rawInputFormat: "rgb48le"
         },
-        abortSignal
+        abortSignal,
+        { ffmpegStreamingTimeout: 36e5 }
       );
       assertNotAborted();
-    }
-    if (enableStreamingEncode && streamingEncoder) {
-      const reorderBuffer = createFrameReorderBuffer(0, job.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,
-          () => 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
+      const { execSync: execSync5 } = await import("child_process");
+      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;
+        try {
+          execSync5(
+            `ffmpeg -ss ${video.mediaStart} -i "${srcPath}" -t ${duration} -r ${job.config.fps} -vf "scale=${width}:${height}:force_original_aspect_ratio=increase,crop=${width}:${height}" -pix_fmt rgb48le -c:v png "${join31(frameDir, "frame_%04d.png")}"`,
+            { maxBuffer: 1024 * 1024, stdio: ["pipe", "pipe", "pipe"] }
+          );
+        } catch (err) {
+          log.warn("HDR frame pre-extraction failed; loop will fill with black", {
+            videoId,
+            srcPath,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+        hdrFrameDirs.set(videoId, frameDir);
+      }
+      assertNotAborted();
+      try {
+        const beforeCaptureHook = domSession.onBeforeCapture;
+        for (let i2 = 0; i2 < job.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, nativeHdrVideoIds);
+          const layers = groupIntoLayers(stackingInfo);
+          if (i2 % 30 === 0) {
+            const hdrEl = stackingInfo.find((e2) => e2.isHdr);
+            const hdrInLayers = layers.some((l) => l.type === "hdr");
+            log.debug("[Render] HDR layer composite frame", {
+              frame: i2,
+              time: time.toFixed(2),
+              hdrElement: hdrEl ? { z: hdrEl.zIndex, visible: hdrEl.visible, width: hdrEl.width } : null,
+              hdrLayerPresent: hdrInLayers,
+              layerCount: layers.length
+            });
+          }
+          const canvas = Buffer.alloc(width * height * 6);
+          for (const layer of layers) {
+            if (layer.type === "hdr") {
+              const el = layer.element;
+              const frameDir = hdrFrameDirs.get(el.id);
+              const video = composition.videos.find((v) => v.id === el.id);
+              if (!frameDir || !video) continue;
+              const videoFrameIndex = Math.round((time - video.start) * job.config.fps) + 1;
+              const maxIndex = getMaxFrameIndex(frameDir);
+              const inBounds = videoFrameIndex >= 1 && (maxIndex === 0 || videoFrameIndex <= maxIndex);
+              const framePath = inBounds ? join31(frameDir, `frame_${String(videoFrameIndex).padStart(4, "0")}.png`) : null;
+              if (framePath !== null && existsSync28(framePath)) {
+                try {
+                  const hdrRgb = decodePngToRgb48le(readFileSync20(framePath)).data;
+                  blitRgb48leRegion(
+                    canvas,
+                    hdrRgb,
+                    el.x,
+                    el.y,
+                    el.width,
+                    el.height,
+                    width,
+                    height,
+                    el.opacity < 0.999 ? el.opacity : void 0
+                  );
+                } catch (err) {
+                  log.warn("HDR layer decode/blit failed; skipping layer for frame", {
+                    frameIndex: i2,
+                    videoId: el.id,
+                    framePath,
+                    error: err instanceof Error ? err.message : String(err)
+                  });
+                }
+              }
+            } else {
+              const allElementIds = stackingInfo.map((e2) => e2.id);
+              const layerIds = new Set(layer.elementIds);
+              const hideIds = allElementIds.filter(
+                (id) => !layerIds.has(id) || nativeHdrVideoIds.has(id)
               );
+              await hideVideoElements(domSession.page, hideIds);
+              const domPng = await captureAlphaPng(domSession.page, width, height);
+              await showVideoElements(domSession.page, hideIds);
+              await domSession.page.evaluate((t3) => {
+                if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t3);
+              }, time);
+              try {
+                const { data: domRgba } = decodePng(domPng);
+                const hdrTransfer = effectiveHdr ? effectiveHdr.transfer : "hlg";
+                blitRgba8OverRgb48le(domRgba, canvas, width, height, hdrTransfer);
+              } catch (err) {
+                log.warn("DOM layer decode/blit failed; skipping overlay for frame", {
+                  frameIndex: i2,
+                  layerIds: layer.elementIds,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              }
             }
-          },
-          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,
-          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 < job.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;
+          hdrEncoder.writeFrame(canvas);
+          job.framesRendered = i2 + 1;
+          if ((i2 + 1) % 10 === 0 || i2 + 1 === job.totalFrames) {
             const frameProgress = (i2 + 1) / job.totalFrames;
-            const progress = 25 + frameProgress * 55;
             updateJobStatus(
               job,
               "rendering",
-              `Streaming frame ${i2 + 1}/${job.totalFrames}`,
-              Math.round(progress),
+              `HDR composite frame ${i2 + 1}/${job.totalFrames}`,
+              Math.round(25 + frameProgress * 55),
               onProgress
             );
           }
-        } finally {
-          lastBrowserConsole = session.browserConsoleBuffer;
-          await closeCaptureSession(session);
         }
+      } finally {
+        lastBrowserConsole = domSession.browserConsoleBuffer;
+        await closeCaptureSession(domSession);
       }
-      const encodeResult = await currentEncoder.close();
+      const hdrEncodeResult = await hdrEncoder.close();
       assertNotAborted();
-      if (!encodeResult.success) {
-        throw new Error(`Streaming encode failed: ${encodeResult.error}`);
+      if (!hdrEncodeResult.success) {
+        throw new Error(`HDR encode failed: ${hdrEncodeResult.error}`);
       }
       perfStages.captureMs = Date.now() - stage4Start;
-      perfStages.encodeMs = encodeResult.durationMs;
+      perfStages.encodeMs = hdrEncodeResult.durationMs;
     } else {
-      if (workerCount > 1) {
-        const tasks = distributeFrames(job.totalFrames, workerCount, workDir);
-        await executeParallelCapture(
-          fileServer.url,
-          workDir,
-          tasks,
-          captureOptions,
-          () => 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) {
+      let streamingEncoder = null;
+      if (enableStreamingEncode) {
+        streamingEncoder = await spawnStreamingEncoder(
+          videoOnlyPath,
+          {
+            fps: job.config.fps,
+            width,
+            height,
+            codec: preset.codec,
+            preset: preset.preset,
+            quality: preset.quality,
+            pixelFormat: preset.pixelFormat,
+            useGpu: job.config.useGpu,
+            imageFormat: captureOptions.format || "jpeg",
+            hdr: preset.hdr
+          },
+          abortSignal
+        );
+        assertNotAborted();
+      }
+      if (enableStreamingEncode && streamingEncoder) {
+        const reorderBuffer = createFrameReorderBuffer(0, job.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,
+            () => 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,
+            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 < job.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) / job.totalFrames;
+              const progress = 25 + frameProgress * 55;
               updateJobStatus(
                 job,
                 "rendering",
-                `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-                Math.round(progressPct),
+                `Streaming 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,
-          framesDir,
-          captureOptions,
-          videoInjector,
-          cfg
-        );
-        if (probeSession) {
-          prepareCaptureSessionForReuse(session, framesDir, videoInjector);
-          probeSession = null;
+        const encodeResult = await currentEncoder.close();
+        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,
+            () => 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 < 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
-            );
+        } else {
+          const videoInjector = createVideoFrameInjector(frameLookup);
+          const session = probeSession ?? await createCaptureSession(
+            fileServer.url,
+            framesDir,
+            captureOptions,
+            videoInjector,
+            cfg
+          );
+          if (probeSession) {
+            prepareCaptureSessionForReuse(session, framesDir, videoInjector);
+            probeSession = null;
           }
-        } finally {
-          lastBrowserConsole = session.browserConsoleBuffer;
-          await closeCaptureSession(session);
+          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);
+          }
+        }
+        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;
       }
-      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 = baseEncoderOpts;
-      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) {
       const remainingProbeSession = probeSession;
@@ -26291,8 +27641,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync27(outputPath)) {
-        const debugOutput = join30(workDir, `output${videoExt}`);
+      if (existsSync28(outputPath)) {
+        const debugOutput = join31(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else {
@@ -26375,7 +27725,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync27(workDir)) rmSync6(workDir, { recursive: true, force: true });
+          if (existsSync28(workDir)) rmSync6(workDir, { recursive: true, force: true });
         },
         log
       );
@@ -26384,7 +27734,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     throw error;
   }
 }
-var RenderCancelledError;
+var frameDirMaxIndexCache, FRAME_FILENAME_RE, RenderCancelledError;
 var init_renderOrchestrator = __esm({
   "../producer/src/services/renderOrchestrator.ts"() {
     "use strict";
@@ -26394,6 +27744,8 @@ var init_renderOrchestrator = __esm({
     init_htmlCompiler2();
     init_logger();
     init_paths();
+    frameDirMaxIndexCache = /* @__PURE__ */ new Map();
+    FRAME_FILENAME_RE = /^frame_(\d+)\.png$/;
     RenderCancelledError = class extends Error {
       reason;
       constructor(message = "render_cancelled", reason = "aborted") {
@@ -26430,8 +27782,8 @@ var init_config3 = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21, statSync as statSync8 } from "fs";
-import { resolve as resolve16, join as join31 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync21, statSync as statSync8 } from "fs";
+import { resolve as resolve16, join as join32 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -26459,7 +27811,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve16(projectDir);
-  if (!existsSync28(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  if (!existsSync29(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -26470,7 +27822,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync28(absoluteEntryPath) && statSync8(absoluteEntryPath).isFile()) {
+    if (existsSync29(absoluteEntryPath) && statSync8(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync21(absoluteEntryPath, "utf-8"),
@@ -26479,7 +27831,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join31(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join32(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -26567,7 +27919,7 @@ var init_semaphore = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   mkdirSync as mkdirSync18,
   statSync as statSync9,
   mkdtempSync,
@@ -26575,7 +27927,7 @@ import {
   rmSync as rmSync7,
   createReadStream
 } from "fs";
-import { resolve as resolve17, dirname as dirname11, join as join32 } from "path";
+import { resolve as resolve17, dirname as dirname11, join as join33 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -26598,11 +27950,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve17(projectDir);
-    if (!existsSync29(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
+    if (!existsSync30(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync29(resolve17(absProjectDir, entry))) {
+    if (!existsSync30(resolve17(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -26627,8 +27979,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir2();
-  const tempProjectDir = mkdtempSync(join32(tempRoot, "producer-project-"));
-  writeFileSync11(join32(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync(join33(tempRoot, "producer-project-"));
+  writeFileSync11(join33(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -26751,7 +28103,7 @@ function createRenderHandlers(options = {}) {
       log
     );
     const outputDir = dirname11(absoluteOutputPath);
-    if (!existsSync29(outputDir)) mkdirSync18(outputDir, { recursive: true });
+    if (!existsSync30(outputDir)) mkdirSync18(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log.info("render started", {
       requestId,
@@ -26778,7 +28130,7 @@ function createRenderHandlers(options = {}) {
           log.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync29(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
+      const fileSize = existsSync30(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -26862,7 +28214,7 @@ function createRenderHandlers(options = {}) {
         log
       );
       const outputDir = dirname11(absoluteOutputPath);
-      if (!existsSync29(outputDir)) mkdirSync18(outputDir, { recursive: true });
+      if (!existsSync30(outputDir)) mkdirSync18(outputDir, { recursive: true });
       log.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -26907,7 +28259,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync29(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
+        const fileSize = existsSync30(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -26966,7 +28318,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync29(artifact.path)) {
+    if (!existsSync30(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -27103,18 +28455,18 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { existsSync as existsSync30, readFileSync as readFileSync22, writeFileSync as writeFileSync12, statSync as statSync10 } from "fs";
-import { resolve as resolve18, join as join33, basename as basename2 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync12, statSync as statSync10 } from "fs";
+import { resolve as resolve18, join as join34, basename as basename2 } from "path";
 function resolveDistDir() {
   const builtPath = resolve18(__dirname, "studio");
-  if (existsSync30(resolve18(builtPath, "index.html"))) return builtPath;
+  if (existsSync31(resolve18(builtPath, "index.html"))) return builtPath;
   const devPath = resolve18(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync30(resolve18(devPath, "index.html"))) return devPath;
+  if (existsSync31(resolve18(devPath, "index.html"))) return devPath;
   return builtPath;
 }
 function resolveRuntimePath() {
   const builtPath = resolve18(__dirname, "hyperframe-runtime.js");
-  if (existsSync30(builtPath)) return builtPath;
+  if (existsSync31(builtPath)) return builtPath;
   const devPath = resolve18(
     __dirname,
     "..",
@@ -27124,7 +28476,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync30(devPath)) return devPath;
+  if (existsSync31(devPath)) return devPath;
   return builtPath;
 }
 async function getThumbnailBrowser() {
@@ -27186,7 +28538,7 @@ function createStudioServer(options) {
       return lintHyperframeHtml2(html, opts);
     },
     runtimeUrl: "/api/runtime.js",
-    rendersDir: () => join33(projectDir, "renders"),
+    rendersDir: () => join34(projectDir, "renders"),
     startRender(opts) {
       const state = {
         id: opts.jobId,
@@ -27276,7 +28628,7 @@ function createStudioServer(options) {
     });
   });
   app.get("/api/runtime.js", (c2) => {
-    if (!existsSync30(runtimePath)) return c2.text("runtime not built", 404);
+    if (!existsSync31(runtimePath)) return c2.text("runtime not built", 404);
     return c2.body(readFileSync22(runtimePath, "utf-8"), 200, {
       "Content-Type": "text/javascript",
       "Cache-Control": "no-store"
@@ -27309,7 +28661,7 @@ function createStudioServer(options) {
   });
   app.get("/assets/*", (c2) => {
     const filePath = resolve18(studioDir, c2.req.path.slice(1));
-    if (!existsSync30(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync31(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync22(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -27317,7 +28669,7 @@ function createStudioServer(options) {
   });
   app.get("/icons/*", (c2) => {
     const filePath = resolve18(studioDir, c2.req.path.slice(1));
-    if (!existsSync30(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync31(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync22(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -27325,7 +28677,7 @@ function createStudioServer(options) {
   });
   app.get("*", (c2) => {
     const indexPath = resolve18(studioDir, "index.html");
-    if (!existsSync30(indexPath)) {
+    if (!existsSync31(indexPath)) {
       return c2.text("Studio not found. Rebuild with: pnpm run build", 500);
     }
     return c2.html(readFileSync22(indexPath, "utf-8"));
@@ -27351,20 +28703,20 @@ __export(preview_exports, {
   examples: () => examples
 });
 import { spawn as spawn8 } from "child_process";
-import { existsSync as existsSync31, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync19 } from "fs";
-import { resolve as resolve19, dirname as dirname12, basename as basename3, join as join34 } from "path";
+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 { 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 projectsDir = join34(repoRoot, "packages", "studio", "data", "projects");
+  const projectsDir = join35(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename3(dir);
-  const symlinkPath = join34(projectsDir, pName);
+  const symlinkPath = join35(projectsDir, pName);
   mkdirSync19(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync31(symlinkPath)) {
+    if (existsSync32(symlinkPath)) {
       try {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
@@ -27376,7 +28728,7 @@ async function runDevMode(dir, projectName) {
       } catch {
       }
     }
-    if (!existsSync31(symlinkPath)) {
+    if (!existsSync32(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -27384,7 +28736,7 @@ async function runDevMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview"));
   const s2 = be();
   s2.start("Starting studio...");
-  const studioPkgDir = join34(repoRoot, "packages", "studio");
+  const studioPkgDir = join35(repoRoot, "packages", "studio");
   const child = spawn8("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -27418,7 +28770,7 @@ async function runDevMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync31(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync32(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -27429,7 +28781,7 @@ async function runDevMode(dir, projectName) {
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join34(dir, "package.json"));
+    const req = createRequire(join35(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -27437,20 +28789,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir, projectName) {
-  const req = createRequire(join34(dir, "package.json"));
+  const req = createRequire(join35(dir, "package.json"));
   const studioPkgPath = dirname12(req.resolve("@hyperframes/studio/package.json"));
   const pName = projectName ?? basename3(dir);
-  const projectsDir = join34(studioPkgPath, "data", "projects");
-  const symlinkPath = join34(projectsDir, pName);
+  const projectsDir = join35(studioPkgPath, "data", "projects");
+  const symlinkPath = join35(projectsDir, pName);
   mkdirSync19(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync31(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync32(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve19(readlinkSync(symlinkPath)) !== resolve19(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
-    if (!existsSync31(symlinkPath)) {
+    if (!existsSync32(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -27489,7 +28841,7 @@ async function runLocalStudioMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync31(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync32(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -27629,8 +28981,8 @@ var init_preview2 = __esm({
         const dir = resolve19(rawArg ?? ".");
         const isImplicitCwd = !rawArg || rawArg === "." || rawArg === "./";
         const projectName = isImplicitCwd ? basename3(process.env.PWD ?? dir) : basename3(dir);
-        const indexPath = join34(dir, "index.html");
-        if (existsSync31(indexPath)) {
+        const indexPath = join35(dir, "index.html");
+        if (existsSync32(indexPath)) {
           const project = { dir, name: projectName, indexPath };
           const lintResult = lintProject(project);
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
@@ -27659,15 +29011,15 @@ __export(init_exports, {
   examples: () => examples2
 });
 import {
-  existsSync as existsSync32,
+  existsSync as existsSync33,
   mkdirSync as mkdirSync20,
   copyFileSync as copyFileSync3,
   cpSync,
   writeFileSync as writeFileSync13,
   readFileSync as readFileSync23,
-  readdirSync as readdirSync10
+  readdirSync as readdirSync12
 } from "fs";
-import { resolve as resolve20, basename as basename4, join as join35, dirname as dirname13 } from "path";
+import { resolve as resolve20, 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) {
@@ -27739,7 +29091,7 @@ function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname13(fileURLToPath5(import.meta.url));
   const devPath = resolve20(base, ...devSegments);
   const builtPath = resolve20(base, ...builtSegments);
-  return existsSync32(devPath) ? devPath : builtPath;
+  return existsSync33(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -27748,7 +29100,7 @@ function getSharedTemplateDir() {
   return resolveAssetDir(["..", "templates", "_shared"], ["templates", "_shared"]);
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync10(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join35(e2.parentPath ?? e2.path, e2.name));
+  const htmlFiles = readdirSync12(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join36(e2.parentPath ?? e2.path, e2.name));
   for (const file of htmlFiles) {
     let content = readFileSync23(file, "utf-8");
     if (videoFilename) {
@@ -27855,7 +29207,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
   mkdirSync20(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
-  if (existsSync32(templateDir)) {
+  if (existsSync33(templateDir)) {
     cpSync(templateDir, destDir, { recursive: true });
   } else {
     await fetchRemoteTemplate(templateId, destDir);
@@ -27874,14 +29226,14 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync32(resolve20(destDir, "hyperframes.json"))) {
+  if (!existsSync33(resolve20(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);
   }
   const sharedDir = getSharedTemplateDir();
-  if (existsSync32(sharedDir)) {
-    for (const entry of readdirSync10(sharedDir, { withFileTypes: true })) {
-      const src = join35(sharedDir, entry.name);
+  if (existsSync33(sharedDir)) {
+    for (const entry of readdirSync12(sharedDir, { withFileTypes: true })) {
+      const src = join36(sharedDir, entry.name);
       const dest = resolve20(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
@@ -27995,7 +29347,7 @@ var init_init = __esm({
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve20(name2);
-          if (existsSync32(destDir2) && readdirSync10(destDir2).length > 0) {
+          if (existsSync33(destDir2) && readdirSync12(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
@@ -28009,7 +29361,7 @@ var init_init = __esm({
           }
           if (videoFlag) {
             const videoPath = resolve20(videoFlag);
-            if (!existsSync32(videoPath)) {
+            if (!existsSync33(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -28023,7 +29375,7 @@ var init_init = __esm({
           }
           if (audioFlag) {
             const audioPath = resolve20(audioFlag);
-            if (!existsSync32(audioPath)) {
+            if (!existsSync33(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -28069,11 +29421,11 @@ var init_init = __esm({
           }
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve20(destDir2, "transcript.json");
-          if (existsSync32(transcriptFile2)) {
+          if (existsSync33(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f3 of readdirSync10(destDir2).filter((f4) => !f4.startsWith("."))) {
+          for (const f3 of readdirSync12(destDir2).filter((f4) => !f4.startsWith("."))) {
             console.log(`  ${c.accent(f3)}`);
           }
           console.log();
@@ -28121,7 +29473,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve20(name);
-        if (existsSync32(destDir) && readdirSync10(destDir).length > 0) {
+        if (existsSync33(destDir) && readdirSync12(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -28136,7 +29488,7 @@ var init_init = __esm({
         let videoDuration;
         if (videoFlag) {
           const videoPath = resolve20(videoFlag);
-          if (!existsSync32(videoPath)) {
+          if (!existsSync33(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -28148,7 +29500,7 @@ var init_init = __esm({
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
           const audioPath = resolve20(audioFlag);
-          if (!existsSync32(audioPath)) {
+          if (!existsSync33(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -28241,10 +29593,10 @@ ${c.dim("Use --example blank for offline use.")}`
         }
         trackInitTemplate(templateId);
         const transcriptFile = resolve20(destDir, "transcript.json");
-        if (existsSync32(transcriptFile)) {
+        if (existsSync33(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
-        const files = readdirSync10(destDir);
+        const files = readdirSync12(destDir);
         Vt2(files.map((f3) => c.accent(f3)).join("\n"), c.success(`Created ${name}/`));
         if (!skipSkills) {
           const installSkills = await Rt({
@@ -28288,9 +29640,10 @@ function detectProvider() {
     { cmd: "xclip", args: ["-selection", "clipboard"] },
     { cmd: "xsel", args: ["--clipboard", "--input"] }
   ];
+  const cmd = process.platform === "win32" ? "where" : "which";
   for (const p of candidates) {
-    const which = spawnSync("which", [p.cmd], { stdio: "ignore" });
-    if (which.status === 0) return p;
+    const result = spawnSync(cmd, [p.cmd], { stdio: "ignore" });
+    if (result.status === 0) return p;
   }
   return void 0;
 }
@@ -28326,7 +29679,7 @@ __export(add_exports, {
   remapTarget: () => remapTarget,
   runAdd: () => runAdd
 });
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { resolve as resolve21, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
@@ -28352,8 +29705,8 @@ function buildSnippet(item, relativeTarget) {
 async function runAdd(opts) {
   const projectDir = resolve21(opts.projectDir);
   let config = loadProjectConfig(projectDir);
-  const hasConfig = existsSync33(projectConfigPath(projectDir));
-  if (!hasConfig && existsSync33(resolve21(projectDir, "index.html"))) {
+  const hasConfig = existsSync34(projectConfigPath(projectDir));
+  if (!hasConfig && existsSync34(resolve21(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -28452,10 +29805,10 @@ var init_add = __esm({
         const projectDir = resolve21(args.dir ?? process.cwd());
         const json = args.json === true;
         const skipClipboard = args["no-clipboard"] === true;
-        const hasConfigBefore = existsSync33(projectConfigPath(projectDir));
+        const hasConfigBefore = existsSync34(projectConfigPath(projectDir));
         try {
           const result = await runAdd({ name: args.name, projectDir, skipClipboard });
-          const wroteConfig = !hasConfigBefore && existsSync33(projectConfigPath(projectDir));
+          const wroteConfig = !hasConfigBefore && existsSync34(projectConfigPath(projectDir));
           if (json) {
             console.log(JSON.stringify(result));
             return;
@@ -28665,17 +30018,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync34, statSync as statSync11 } from "fs";
+import { existsSync as existsSync35, statSync as statSync11 } from "fs";
 import { resolve as resolve23, basename as basename5 } from "path";
 function resolveProject(dirArg) {
   const dir = resolve23(dirArg ?? ".");
   const name = basename5(dir);
   const indexPath = resolve23(dir, "index.html");
-  if (!existsSync34(dir) || !statSync11(dir).isDirectory()) {
+  if (!existsSync35(dir) || !statSync11(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync34(indexPath)) {
+  if (!existsSync35(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -28698,7 +30051,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync35, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync24 } from "fs";
 import { resolve as resolve24, dirname as dirname14 } from "path";
 function commandDir() {
   return dirname14(new URL(import.meta.url).pathname);
@@ -28713,7 +30066,7 @@ function resolveRuntimePath2() {
     resolve24(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
-    if (existsSync35(p)) return p;
+    if (existsSync36(p)) return p;
   }
   return null;
 }
@@ -28727,7 +30080,7 @@ function resolvePlayerPath() {
     resolve24(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
-    if (existsSync35(p)) return p;
+    if (existsSync36(p)) return p;
   }
   return null;
 }
@@ -28829,7 +30182,7 @@ var init_play = __esm({
           const reqPath = ctx.req.path.replace("/composition/", "");
           const filePath = resolve24(project.dir, reqPath);
           if (!filePath.startsWith(project.dir)) return ctx.text("Forbidden", 403);
-          if (!existsSync35(filePath)) return ctx.text("Not found", 404);
+          if (!existsSync36(filePath)) return ctx.text("Not found", 404);
           const content = readFileSync24(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
@@ -28945,12 +30298,14 @@ __export(ffmpeg_exports, {
 import { execSync as execSync2 } from "child_process";
 function findFFmpeg() {
   try {
-    const result = execSync2("which ffmpeg", {
+    const cmd = process.platform === "win32" ? "where ffmpeg" : "which ffmpeg";
+    const output = execSync2(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5e3
-    }).trim();
-    return result || void 0;
+    });
+    const first = output.split(/\r?\n/).map((s2) => s2.trim()).find(Boolean);
+    return first || void 0;
   } catch {
     return void 0;
   }
@@ -28979,7 +30334,7 @@ __export(render_exports, {
 });
 import { mkdirSync as mkdirSync21, readFileSync as readFileSync25, statSync as statSync12, writeFileSync as writeFileSync14, rmSync as rmSync8 } from "fs";
 import { cpus as cpus3, freemem as freemem3, tmpdir as tmpdir3 } from "os";
-import { resolve as resolve25, dirname as dirname15, join as join36, basename as basename6 } from "path";
+import { resolve as resolve25, dirname as dirname15, join as join37, basename as basename6 } 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));
@@ -29016,9 +30371,9 @@ function ensureDockerImage(version, quiet) {
   }
   if (!quiet) console.log(c.dim(`  Building Docker image: ${tag}...`));
   const dockerfilePath = resolveDockerfilePath();
-  const tmpDir = join36(tmpdir3(), `hyperframes-docker-${Date.now()}`);
+  const tmpDir = join37(tmpdir3(), `hyperframes-docker-${Date.now()}`);
   mkdirSync21(tmpDir, { recursive: true });
-  writeFileSync14(join36(tmpDir, "Dockerfile"), readFileSync25(dockerfilePath));
+  writeFileSync14(join37(tmpDir, "Dockerfile"), readFileSync25(dockerfilePath));
   try {
     execFileSync5(
       "docker",
@@ -29377,7 +30732,7 @@ var init_render2 = __esm({
         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 ? resolve25(args.output) : join36(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        const outputPath = args.output ? resolve25(args.output) : join37(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
         mkdirSync21(dirname15(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
@@ -29702,12 +31057,12 @@ __export(info_exports, {
   default: () => info_default,
   examples: () => examples8
 });
-import { readFileSync as readFileSync26, readdirSync as readdirSync11, statSync as statSync13 } from "fs";
-import { join as join37 } from "path";
+import { readFileSync as readFileSync26, readdirSync as readdirSync13, statSync as statSync13 } from "fs";
+import { join as join38 } from "path";
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync11(dir, { withFileTypes: true })) {
-    const path2 = join37(dir, entry.name);
+  for (const entry of readdirSync13(dir, { withFileTypes: true })) {
+    const path2 = join38(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
     } else {
@@ -29795,7 +31150,7 @@ __export(compositions_exports, {
   default: () => compositions_default,
   examples: () => examples9
 });
-import { existsSync as existsSync36, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync27 } from "fs";
 import { resolve as resolve26, dirname as dirname16 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
@@ -29809,7 +31164,7 @@ function parseCompositions(html, baseDir) {
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
       const subPath = resolve26(baseDir, compositionSrc);
-      if (existsSync36(subPath)) {
+      if (existsSync37(subPath)) {
         const subHtml = readFileSync27(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
@@ -29942,8 +31297,8 @@ __export(benchmark_exports, {
   default: () => benchmark_default,
   examples: () => examples10
 });
-import { existsSync as existsSync37, statSync as statSync14 } from "fs";
-import { resolve as resolve27, join as join38 } from "path";
+import { existsSync as existsSync38, statSync as statSync14 } from "fs";
+import { resolve as resolve27, join as join39 } from "path";
 var examples10, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -30018,7 +31373,7 @@ var init_benchmark = __esm({
           s2?.start(`Benchmarking ${config.label}...`);
           for (let i2 = 0; i2 < runsPerConfig; i2++) {
             s2?.message(`${config.label} \u2014 run ${i2 + 1}/${runsPerConfig}`);
-            const outputPath = join38(
+            const outputPath = join39(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i2}.mp4`
             );
@@ -30032,7 +31387,7 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync37(outputPath)) {
+              if (existsSync38(outputPath)) {
                 const stat3 = statSync14(outputPath);
                 fileSize = stat3.size;
               }
@@ -30248,8 +31603,8 @@ __export(transcribe_exports2, {
   default: () => transcribe_default,
   examples: () => examples12
 });
-import { existsSync as existsSync38, writeFileSync as writeFileSync15 } from "fs";
-import { resolve as resolve28, join as join39, extname as extname7 } from "path";
+import { existsSync as existsSync39, writeFileSync as writeFileSync15 } from "fs";
+import { resolve as resolve28, join as join40, extname as extname7 } 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);
@@ -30257,7 +31612,7 @@ async function importTranscript(inputPath, dir, json) {
     console.error(c.error("No words found in transcript."));
     process.exit(1);
   }
-  const outPath = join39(dir, "transcript.json");
+  const outPath = join40(dir, "transcript.json");
   writeFileSync15(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
@@ -30374,7 +31729,7 @@ var init_transcribe2 = __esm({
       },
       async run({ args }) {
         const inputPath = resolve28(args.input);
-        if (!existsSync38(inputPath)) {
+        if (!existsSync39(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
@@ -30395,12 +31750,12 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync22 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join40 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync22 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join41 } from "path";
 async function ensureModel2(model = DEFAULT_MODEL2, options) {
-  const modelPath = join40(MODELS_DIR2, `${model}.onnx`);
-  if (existsSync39(modelPath)) return modelPath;
+  const modelPath = join41(MODELS_DIR2, `${model}.onnx`);
+  if (existsSync40(modelPath)) return modelPath;
   const url = MODEL_URLS[model];
   if (!url) {
     throw new Error(
@@ -30410,18 +31765,18 @@ async function ensureModel2(model = DEFAULT_MODEL2, options) {
   mkdirSync22(MODELS_DIR2, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath);
-  if (!existsSync39(modelPath)) {
+  if (!existsSync40(modelPath)) {
     throw new Error(`Model download failed: ${model}`);
   }
   return modelPath;
 }
 async function ensureVoices(options) {
-  const voicesPath = join40(VOICES_DIR, "voices-v1.0.bin");
-  if (existsSync39(voicesPath)) return voicesPath;
+  const voicesPath = join41(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync40(voicesPath)) return voicesPath;
   mkdirSync22(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
-  if (!existsSync39(voicesPath)) {
+  if (!existsSync40(voicesPath)) {
     throw new Error("Voice data download failed");
   }
   return voicesPath;
@@ -30431,9 +31786,9 @@ var init_manager3 = __esm({
   "src/tts/manager.ts"() {
     "use strict";
     init_download();
-    CACHE_DIR3 = join40(homedir7(), ".cache", "hyperframes", "tts");
-    MODELS_DIR2 = join40(CACHE_DIR3, "models");
-    VOICES_DIR = join40(CACHE_DIR3, "voices");
+    CACHE_DIR3 = join41(homedir8(), ".cache", "hyperframes", "tts");
+    MODELS_DIR2 = join41(CACHE_DIR3, "models");
+    VOICES_DIR = join41(CACHE_DIR3, "voices");
     DEFAULT_MODEL2 = "kokoro-v1.0";
     MODEL_URLS = {
       "kokoro-v1.0": "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx"
@@ -30459,23 +31814,26 @@ __export(synthesize_exports, {
   synthesize: () => synthesize
 });
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync40, writeFileSync as writeFileSync16, mkdirSync as mkdirSync23 } from "fs";
-import { join as join41, dirname as dirname17 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync41, writeFileSync as writeFileSync16, mkdirSync as mkdirSync23 } from "fs";
+import { join as join42, dirname as dirname17 } from "path";
+import { homedir as homedir9 } from "os";
 function findPython() {
   for (const name of ["python3", "python"]) {
     try {
-      const result = execFileSync6("which", [name], {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      const output = execFileSync6(cmd, [name], {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 5e3
-      }).trim();
-      const version = execFileSync6(result, ["--version"], {
+      });
+      const first = output.split(/\r?\n/).map((s2) => s2.trim()).find(Boolean);
+      if (!first) continue;
+      const version = execFileSync6(first, ["--version"], {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 5e3
       }).trim();
-      if (version.includes("Python 3")) return result;
+      if (version.includes("Python 3")) return first;
     } catch {
     }
   }
@@ -30493,7 +31851,7 @@ function hasPythonPackage(python, pkg) {
   }
 }
 function ensureSynthScript() {
-  if (!existsSync40(SCRIPT_PATH)) {
+  if (!existsSync41(SCRIPT_PATH)) {
     mkdirSync23(SCRIPT_DIR, { recursive: true });
     writeFileSync16(SCRIPT_PATH, SYNTH_SCRIPT);
   }
@@ -30534,7 +31892,7 @@ async function synthesize(text, outputPath, options) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    if (!existsSync40(outputPath)) {
+    if (!existsSync41(outputPath)) {
       throw new Error("Synthesis completed but no output file was created");
     }
     const lines = stdout2.trim().split("\n");
@@ -30546,7 +31904,7 @@ async function synthesize(text, outputPath, options) {
       durationSeconds: result.durationSeconds
     };
   } catch (err) {
-    if (err instanceof SyntaxError && existsSync40(outputPath)) {
+    if (err instanceof SyntaxError && existsSync41(outputPath)) {
       throw new Error(
         "Speech was generated but metadata could not be read. Check the output file manually."
       );
@@ -30589,8 +31947,8 @@ print(json.dumps({
     "durationSeconds": round(duration, 3),
 }))
 `;
-    SCRIPT_DIR = join41(homedir8(), ".cache", "hyperframes", "tts");
-    SCRIPT_PATH = join41(SCRIPT_DIR, "synth.py");
+    SCRIPT_DIR = join42(homedir9(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join42(SCRIPT_DIR, "synth.py");
   }
 });
 
@@ -30600,7 +31958,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples13
 });
-import { existsSync as existsSync41, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync28 } from "fs";
 import { resolve as resolve29, extname as extname8 } from "path";
 function listVoices(json) {
   if (json) {
@@ -30690,7 +32048,7 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve29(args.input);
-        if (existsSync41(maybeFile) && extname8(maybeFile).toLowerCase() === ".txt") {
+        if (existsSync42(maybeFile) && extname8(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync28(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
@@ -30756,15 +32114,15 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples14
 });
-import { readFileSync as readFileSync29, existsSync as existsSync42 } from "fs";
-import { resolve as resolve30, dirname as dirname18, join as join42 } from "path";
+import { readFileSync as readFileSync29, existsSync as existsSync43 } from "fs";
+import { resolve as resolve30, dirname as dirname18, join as join43 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath6(import.meta.url);
   const dir = dirname18(thisFile);
   const devPath = resolve30(dir, "..", "docs");
   const builtPath = resolve30(dir, "docs");
-  return existsSync42(devPath) ? devPath : builtPath;
+  return existsSync43(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -30861,8 +32219,8 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join42(docsDir(), entry.file);
-        if (!existsSync42(filePath)) {
+        const filePath = join43(docsDir(), entry.file);
+        if (!existsSync43(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
@@ -31292,8 +32650,8 @@ var validate_exports = {};
 __export(validate_exports, {
   default: () => validate_default
 });
-import { existsSync as existsSync43, readFileSync as readFileSync30 } from "fs";
-import { resolve as resolve31, join as join43, dirname as dirname19 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync30 } from "fs";
+import { resolve as resolve31, join as join44, dirname as dirname19 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -31348,7 +32706,7 @@ async function validateInBrowser(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync43(runtimePath)) {
+  if (existsSync44(runtimePath)) {
     const runtimeSource = readFileSync30(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -31364,8 +32722,8 @@ async function validateInBrowser(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = join43(projectDir, decodeURIComponent(url));
-    if (existsSync43(filePath)) {
+    const filePath = join44(projectDir, decodeURIComponent(url));
+    if (existsSync44(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync30(filePath));
       return;
@@ -31557,8 +32915,8 @@ __export(snapshot_exports, {
   default: () => snapshot_default,
   examples: () => examples18
 });
-import { existsSync as existsSync44, readFileSync as readFileSync31, mkdirSync as mkdirSync24 } from "fs";
-import { resolve as resolve32, join as join44, dirname as dirname20, relative as relative4, isAbsolute as isAbsolute4 } from "path";
+import { existsSync as existsSync45, readFileSync as readFileSync31, mkdirSync as mkdirSync24 } from "fs";
+import { resolve as resolve32, join as join45, dirname as dirname20, relative as relative4, isAbsolute as isAbsolute4 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function captureSnapshots(projectDir, opts) {
   const { bundleToSingleHtml: bundleToSingleHtml2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
@@ -31574,7 +32932,7 @@ async function captureSnapshots(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync44(runtimePath)) {
+  if (existsSync45(runtimePath)) {
     const runtimeSource = readFileSync31(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -31597,7 +32955,7 @@ async function captureSnapshots(projectDir, opts) {
       res.end();
       return;
     }
-    if (existsSync44(filePath)) {
+    if (existsSync45(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync31(filePath));
       return;
@@ -31672,7 +33030,7 @@ async function captureSnapshots(projectDir, opts) {
         return [];
       }
       const positions = opts.at?.length ? opts.at : numFrames === 1 ? [duration / 2] : Array.from({ length: numFrames }, (_2, i2) => i2 / (numFrames - 1) * duration);
-      const snapshotDir = join44(projectDir, "snapshots");
+      const snapshotDir = join45(projectDir, "snapshots");
       mkdirSync24(snapshotDir, { recursive: true });
       for (let i2 = 0; i2 < positions.length; i2++) {
         const time = positions[i2];
@@ -31698,7 +33056,7 @@ async function captureSnapshots(projectDir, opts) {
         await new Promise((r2) => setTimeout(r2, 200));
         const timeLabel = opts.at?.length ? `${time.toFixed(1)}s` : `${Math.round(time / duration * 100)}pct`;
         const filename = `frame-${String(i2).padStart(2, "0")}-at-${timeLabel}.png`;
-        const framePath = join44(snapshotDir, filename);
+        const framePath = join45(snapshotDir, filename);
         await page.screenshot({ path: framePath, type: "png" });
         savedPaths.push(`snapshots/${filename}`);
       }
@@ -31783,13 +33141,13 @@ ${c.error("\u2717")} Snapshot failed: ${msg}`);
 
 // src/capture/assetDownloader.ts
 import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync25 } from "fs";
-import { join as join45, extname as extname9 } from "path";
-async function downloadAssets(tokens, outputDir, catalogedAssets) {
-  const assetsDir = join45(outputDir, "assets");
+import { join as join46, extname as extname9 } from "path";
+async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
+  const assetsDir = join46(outputDir, "assets");
   mkdirSync25(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync25(join45(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync25(join46(outputDir, "assets", "svgs"), { recursive: true });
   for (let i2 = 0; i2 < tokens.svgs.length && i2 < 30; i2++) {
     const svg = tokens.svgs[i2];
     if (!svg.outerHTML || svg.outerHTML.length < 50) continue;
@@ -31797,12 +33155,12 @@ async function downloadAssets(tokens, outputDir, catalogedAssets) {
     const name = label2 ? slugify(label2) + ".svg" : svg.isLogo ? `logo-${i2}.svg` : `icon-${i2}.svg`;
     const localPath = `assets/svgs/${name}`;
     try {
-      writeFileSync17(join45(outputDir, localPath), svg.outerHTML, "utf-8");
+      writeFileSync17(join46(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
   }
-  for (const icon of tokens.icons) {
+  for (const icon of faviconLinks || []) {
     if (!icon.href) continue;
     try {
       const ext = extname9(new URL(icon.href).pathname) || ".ico";
@@ -31810,7 +33168,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets) {
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
       if (buffer) {
-        writeFileSync17(join45(outputDir, localPath), buffer);
+        writeFileSync17(join46(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -31832,12 +33190,6 @@ async function downloadAssets(tokens, outputDir, catalogedAssets) {
       const isPoster = a.contexts.includes("video[poster]");
       imageUrls.push({ url: a.url, isPoster });
     }
-  } else {
-    for (const img of tokens.images) {
-      if (img.width > 200 && img.src.startsWith("http")) {
-        imageUrls.push({ url: img.src, isPoster: false });
-      }
-    }
   }
   const toDownload = [];
   for (const { url, isPoster } of imageUrls) {
@@ -31873,7 +33225,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets) {
         const slug = isMeaningful ? slugify(rawName) : `${prefix}-${imgIdx}`;
         const name = `${slug}${ext}`;
         const localPath = `assets/${name}`;
-        writeFileSync17(join45(outputDir, localPath), buffer);
+        writeFileSync17(join46(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -31886,7 +33238,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets) {
       const localPath = `assets/og-image${ext}`;
       const buffer = await fetchBuffer(tokens.ogImage);
       if (buffer && buffer.length > 5e3) {
-        writeFileSync17(join45(outputDir, localPath), buffer);
+        writeFileSync17(join46(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -31909,7 +33261,7 @@ function normalizeUrl(u) {
   }
 }
 async function downloadAndRewriteFonts(css, outputDir) {
-  const assetsDir = join45(outputDir, "assets", "fonts");
+  const assetsDir = join46(outputDir, "assets", "fonts");
   mkdirSync25(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
@@ -31945,7 +33297,7 @@ async function downloadAndRewriteFonts(css, outputDir) {
     try {
       const urlObj = new URL(fontUrl);
       const filename = urlObj.pathname.split("/").pop() || `font-${count}.woff2`;
-      const localPath = join45(assetsDir, filename);
+      const localPath = join46(assetsDir, filename);
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
@@ -32010,19 +33362,6 @@ var init_assetDownloader = __esm({
 // src/capture/htmlExtractor.ts
 async function extractHtml(page, opts = {}) {
   const settleTime = opts.settleTime ?? DEFAULT_SETTLE_TIME;
-  await page.evaluate(`(async () => {
-    var pageHeight = document.body.scrollHeight;
-    var viewportH = window.innerHeight;
-    var step = Math.floor(viewportH * 0.7);
-    for (var y = 0; y < pageHeight + viewportH; y += step) {
-      window.scrollTo(0, y);
-      await new Promise(function(r) { setTimeout(r, 200); });
-    }
-    window.scrollTo(0, pageHeight);
-    await new Promise(function(r) { setTimeout(r, 300); });
-    window.scrollTo(0, 0);
-    await new Promise(function(r) { setTimeout(r, 300); });
-  })()`);
   await new Promise((r2) => setTimeout(r2, settleTime));
   const stylesheetUrls = await page.evaluate(`(() => {
     return Array.from(document.querySelectorAll('link[rel="stylesheet"][href]')).map(function(l) { return l.href; });
@@ -32251,12 +33590,49 @@ var init_tokenExtractor = __esm({
   var ogImgEl = document.querySelector('meta[property="og:image"]');
   var ogImage = ogImgEl ? ogImgEl.content : undefined;
 
-  // 3. Fonts
-  var fontSet = {};
-  var fontSamples = [document.body, document.querySelector("h1"), document.querySelector("h2"), document.querySelector("p"), document.querySelector("button")].filter(Boolean);
-  for (var fi = 0; fi < fontSamples.length; fi++) {
-    var family = getComputedStyle(fontSamples[fi]).fontFamily.split(",")[0].replace(/['"]/g, "").trim();
-    if (family && ["serif","sans-serif","monospace","cursive"].indexOf(family) === -1) fontSet[family] = true;
+  // 3. Fonts \u2014 enumerate loaded FontFaces + supplement with DOM sampling
+  var fontMap = {};
+  function ensureFont(name) {
+    if (!fontMap[name]) fontMap[name] = { family: name, weights: [], variable: false, weightRange: undefined };
+    return fontMap[name];
+  }
+  function addWeight(entry, w) {
+    var n = parseInt(w, 10);
+    if (!isNaN(n) && entry.weights.indexOf(n) === -1) entry.weights.push(n);
+  }
+  var genericFonts = ["serif","sans-serif","monospace","cursive","system-ui","ui-serif","ui-sans-serif","ui-monospace","ui-rounded","emoji","math","fangsong"];
+  try {
+    document.fonts.forEach(function(face) {
+      var name = face.family.replace(/['"]/g, "").trim();
+      if (!name || genericFonts.indexOf(name.toLowerCase()) !== -1) return;
+      // Skip placeholder/fallback fonts (Framer loads hundreds of these)
+      if (name.indexOf("Placeholder") !== -1 || name.indexOf("Fallback") !== -1) return;
+      var entry = ensureFont(name);
+      var w = (face.weight || "").trim();
+      if (w.indexOf(" ") !== -1) {
+        var parts = w.split(" ");
+        var lo = parseInt(parts[0], 10);
+        var hi = parseInt(parts[1], 10);
+        if (!isNaN(lo) && !isNaN(hi)) {
+          entry.variable = true;
+          entry.weightRange = [lo, hi];
+        }
+      } else {
+        addWeight(entry, w);
+      }
+    });
+  } catch(e) {}
+  // Supplement with DOM sampling
+  var domSamples = Array.from(document.querySelectorAll("h1,h2,h3,h4,h5,h6,p,a,button,span,li,strong,b")).slice(0, 100);
+  for (var fi = 0; fi < domSamples.length; fi++) {
+    try {
+      var cs = getComputedStyle(domSamples[fi]);
+      var family = cs.fontFamily.split(",")[0].replace(/['"]/g, "").trim();
+      if (family && genericFonts.indexOf(family.toLowerCase()) === -1) {
+        var entry = ensureFont(family);
+        addWeight(entry, cs.fontWeight);
+      }
+    } catch(e) {}
   }
 
   // 4. Colors \u2014 hybrid: DOM computed styles + visual pixel sampling
@@ -32414,10 +33790,7 @@ var init_tokenExtractor = __esm({
     return { level: parseInt(h.tagName[1]), text: (h.innerText || h.textContent || "").trim().replace(/\\s+/g, ' ').slice(0, 200), fontSize: s.fontSize, fontWeight: s.fontWeight, color: rgbToHex(s.color) || s.color };
   });
 
-  // 6. Paragraphs
-  var paragraphs = Array.from(document.querySelectorAll("p")).slice(0, 10).map(function(p) { return (p.textContent || "").trim().slice(0, 300); }).filter(function(t) { return t.length > 20; });
-
-  // 7. CTAs \u2014 match by class AND by text content patterns
+  // 6. CTAs \u2014 match by class AND by text content patterns
   // Conservative class selectors (avoid nav links with "action" or "start" in class)
   var ctaSelectors = 'a[class*="btn"], a[class*="button"], a[class*="cta"], button[class*="primary"], button[class*="cta"], [role="button"]';
   var ctaEls = Array.from(document.querySelectorAll(ctaSelectors));
@@ -32488,15 +33861,7 @@ var init_tokenExtractor = __esm({
     };
   }).filter(Boolean).slice(0, 50);
 
-  // 9. Images
-  var imgEls = Array.from(document.querySelectorAll("img[src]")).filter(function(img) { return img.naturalWidth > 200 && isVisible(img); }).slice(0, 15);
-  var images = imgEls.map(function(img) { return { src: img.src, alt: img.alt || "", width: img.naturalWidth, height: img.naturalHeight }; });
-
-  // 10. Icons
-  var iconEls = Array.from(document.querySelectorAll('link[rel*="icon"], link[rel="apple-touch-icon"]'));
-  var icons = iconEls.map(function(l) { return { rel: l.rel, href: l.href }; });
-
-  // 11. Sections \u2014 find large visual blocks regardless of HTML tag
+  // 9. Sections \u2014 find large visual blocks regardless of HTML tag
   var sectionResults = [];
   // Start with semantic elements, then fall back to large direct children of body/main
   var candidates = Array.from(document.querySelectorAll(
@@ -32546,17 +33911,45 @@ var init_tokenExtractor = __esm({
       }
       if (!sectionBg || sectionBg === "rgba(0, 0, 0, 0)" || sectionBg === "transparent") sectionBg = "#FFFFFF";
     }
+    // Check for background-image when color is transparent/default white
+    var sectionBgImage = undefined;
+    var rawBgImg = getComputedStyle(el).backgroundImage;
+    if (rawBgImg && rawBgImg !== "none" && rawBgImg.indexOf("url(") !== -1) {
+      var start = rawBgImg.indexOf("url(") + 4;
+      var end = rawBgImg.indexOf(")", start);
+      if (end > start) {
+        sectionBgImage = rawBgImg.slice(start, end).replace(/['"]/g, "");
+      }
+    }
     sectionBg = rgbToHex(sectionBg) || sectionBg;
-    sectionResults.push({ selector: selector, type: type, y: Math.round(y), height: Math.round(rect.height), heading: headingText, backgroundColor: sectionBg });
+    var sectionEntry = { selector: selector, type: type, y: Math.round(y), height: Math.round(rect.height), heading: headingText, backgroundColor: sectionBg };
+    if (sectionBgImage) sectionEntry.backgroundImage = sectionBgImage;
+    sectionResults.push(sectionEntry);
   }
   sectionResults.sort(function(a, b) { return a.y - b.y; });
   var filtered = sectionResults.filter(function(s, i) { return i === 0 || Math.abs(s.y - sectionResults[i-1].y) > 100; });
 
+  // Filter cssVariables \u2014 keep only color-like values or design-relevant names
+  var colorValueRe = /^(#|rgb|hsl|oklch|oklab|lch|lab|color)/i;
+  var designNameRe = /(color|bg|background|border|text|font|radius|shadow)/i;
+  var filteredVars = {};
+  var varKeys = Object.keys(cssVariables);
+  for (var vi = 0; vi < varKeys.length; vi++) {
+    var varName = varKeys[vi];
+    var varVal = cssVariables[varName];
+    if (colorValueRe.test(varVal) || designNameRe.test(varName)) {
+      filteredVars[varName] = varVal;
+    }
+  }
+
+  // Filter sections \u2014 only keep those with a non-empty heading
+  var filteredSections = filtered.filter(function(s) { return s.heading && s.heading.length > 0; });
+
   return {
     title: title, description: description, ogImage: ogImage,
-    cssVariables: cssVariables, fonts: Object.keys(fontSet), colors: Object.keys(colorSet).sort(function(a,b) { return colorSet[b] - colorSet[a]; }).slice(0, 20),
-    headings: headings, paragraphs: paragraphs, ctas: ctas,
-    svgs: svgs, images: images, icons: icons, sections: filtered
+    cssVariables: filteredVars, fonts: Object.keys(fontMap).map(function(k) { var f = fontMap[k]; f.weights.sort(function(a,b){return a-b;}); return f; }).filter(function(f) { return f.weights.length > 0 || f.variable; }).slice(0, 20), colors: Object.keys(colorSet).sort(function(a,b) { return colorSet[b] - colorSet[a]; }).slice(0, 20),
+    headings: headings, ctas: ctas,
+    svgs: svgs, sections: filteredSections
   };
 })()`;
   }
@@ -32701,8 +34094,8 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync26, writeFileSync as writeFileSync18, readdirSync as readdirSync12, readFileSync as readFileSync32, statSync as statSync15 } from "fs";
-import { join as join46 } from "path";
+import { mkdirSync as mkdirSync26, writeFileSync as writeFileSync18, readdirSync as readdirSync14, readFileSync as readFileSync32, statSync as statSync15 } from "fs";
+import { join as join47 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -32735,7 +34128,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
             const hash = buf.toString("base64").slice(0, 100);
             if (savedHashes.has(hash)) continue;
             savedHashes.add(hash);
-            writeFileSync18(join46(lottieDir, `animation-${savedCount}.lottie`), buf);
+            writeFileSync18(join47(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -32753,7 +34146,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync18(join46(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync18(join47(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -32763,22 +34156,22 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
-  const previewDir = join46(lottieDir, "previews");
+  const previewDir = join47(lottieDir, "previews");
   mkdirSync26(previewDir, { recursive: true });
-  for (const file of readdirSync12(lottieDir)) {
+  for (const file of readdirSync14(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync32(join46(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync32(join47(lottieDir, file), "utf-8"));
       const fr = raw.fr || 30;
       const dur = ((raw.op || 0) - (raw.ip || 0)) / fr;
       const previewName = file.replace(".json", "-preview.png");
-      const fileSize = statSync15(join46(lottieDir, file)).size;
+      const fileSize = statSync15(join47(lottieDir, file)).size;
       if (fileSize > 2e6) continue;
       let previewPage;
       try {
         previewPage = await chromeBrowser.newPage();
         await previewPage.setViewport({ width: 400, height: 400 });
-        const animData = JSON.parse(readFileSync32(join46(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync32(join47(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -32808,7 +34201,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
         await previewPage.waitForFunction(() => window.__READY === true, { timeout: 5e3 }).catch(() => {
         });
         await previewPage.screenshot({
-          path: join46(previewDir, previewName),
+          path: join47(previewDir, previewName),
           type: "png",
           omitBackground: true
         });
@@ -32832,7 +34225,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   }
   if (manifest.length > 0) {
     writeFileSync18(
-      join46(outputDir, "extracted", "lottie-manifest.json"),
+      join47(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -32894,15 +34287,15 @@ async function captureVideoManifest(page, outputDir, progress) {
     return true;
   });
   if (uniqueVideos.length > 0) {
-    const videoManifestDir = join46(outputDir, "assets", "videos");
+    const videoManifestDir = join47(outputDir, "assets", "videos");
     mkdirSync26(videoManifestDir, { recursive: true });
-    const previewDir = join46(videoManifestDir, "previews");
+    const previewDir = join47(videoManifestDir, "previews");
     mkdirSync26(previewDir, { recursive: true });
     const videoManifest = [];
     for (let vi = 0; vi < uniqueVideos.length && vi < 20; vi++) {
       const v = uniqueVideos[vi];
       const previewName = `video-${vi}-preview.png`;
-      const previewPath = join46(previewDir, previewName);
+      const previewPath = join47(previewDir, previewName);
       try {
         await page.evaluate(`window.scrollTo(0, ${Math.max(0, v.top - 100)})`);
         await new Promise((r2) => setTimeout(r2, 300));
@@ -32941,7 +34334,7 @@ async function captureVideoManifest(page, outputDir, progress) {
     }
     if (videoManifest.length > 0) {
       writeFileSync18(
-        join46(outputDir, "extracted", "video-manifest.json"),
+        join47(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
       );
@@ -73396,8 +74789,8 @@ ${underline2}`);
 });
 
 // src/capture/contentExtractor.ts
-import { readdirSync as readdirSync13, statSync as statSync17, readFileSync as readFileSync33 } from "fs";
-import { join as join47 } from "path";
+import { readdirSync as readdirSync15, statSync as statSync17, readFileSync as readFileSync33 } from "fs";
+import { join as join48 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
   try {
@@ -73479,6 +74872,7 @@ async function extractVisibleText(page) {
   let visibleTextContent = "";
   try {
     visibleTextContent = await page.evaluate(`(() => {
+      var cookieRe = /^(accept|cookie|privacy|that's fine|got it|i agree|reject all|accept all|manage cookies|consent)$/i;
       var walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null);
       var texts = [];
       var node;
@@ -73491,7 +74885,13 @@ async function extractVisibleText(page) {
         if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') continue;
         var tag = el.tagName.toLowerCase();
         if (tag === 'script' || tag === 'style' || tag === 'noscript') continue;
-        texts.push(text);
+        // Skip very short text inside nav/footer (catches single-word nav links)
+        // Threshold is 8 chars to preserve footer copy like "\xA9 2026 Stripe" (16 chars)
+        var inNavOrFooter = el.closest('nav, footer, [role="navigation"]');
+        if (inNavOrFooter && text.length < 8) continue;
+        // Skip common cookie/consent patterns
+        if (cookieRe.test(text)) continue;
+        texts.push('[' + tag + '] ' + text);
       }
       return texts.join('\\n');
     })()`);
@@ -73510,7 +74910,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings) {
   try {
     const { GoogleGenAI: GoogleGenAI2 } = await Promise.resolve().then(() => (init_node4(), node_exports));
     const ai = new GoogleGenAI2({ apiKey: geminiKey });
-    const imageFiles = readdirSync13(join47(outputDir, "assets")).filter(
+    const imageFiles = readdirSync15(join48(outputDir, "assets")).filter(
       (f3) => /\.(png|jpg|jpeg|webp|gif)$/i.test(f3)
     );
     const model = process.env.HYPERFRAMES_GEMINI_MODEL || "gemini-3.1-flash-lite-preview";
@@ -73519,7 +74919,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings) {
       const batch = imageFiles.slice(i2, i2 + BATCH_SIZE);
       const results = await Promise.allSettled(
         batch.map(async (file) => {
-          const filePath = join47(outputDir, "assets", file);
+          const filePath = join48(outputDir, "assets", file);
           const stat3 = statSync17(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
           const buffer = readFileSync33(filePath);
@@ -73568,11 +74968,11 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join47(outputDir, "assets");
+  const assetsPath = join48(outputDir, "assets");
   try {
-    for (const file of readdirSync13(assetsPath)) {
+    for (const file of readdirSync15(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join47(assetsPath, file);
+      const filePath = join48(assetsPath, file);
       const stat3 = statSync17(filePath);
       if (!stat3.isFile()) continue;
       const sizeKb = Math.round(stat3.size / 1024);
@@ -73601,8 +75001,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join47(assetsPath, "svgs");
-    for (const file of readdirSync13(svgsPath)) {
+    const svgsPath = join48(assetsPath, "svgs");
+    for (const file of readdirSync15(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
         (s2) => s2.label && file.includes(
@@ -73616,8 +75016,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join47(assetsPath, "fonts");
-    for (const file of readdirSync13(fontsPath)) {
+    const fontsPath = join48(assetsPath, "fonts");
+    for (const file of readdirSync15(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
   } catch {
@@ -73636,111 +75036,71 @@ __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
 import { writeFileSync as writeFileSync19 } from "fs";
-import { join as join48 } from "path";
-function generateAgentPrompt(outputDir, url, tokens, animations, hasScreenshot, hasLottie, hasShaders, catalogedAssets) {
-  const prompt = buildPrompt(
-    url,
-    tokens,
-    animations,
-    hasScreenshot,
-    hasLottie,
-    hasShaders,
-    catalogedAssets
-  );
-  writeFileSync19(join48(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync19(join48(outputDir, ".cursorrules"), prompt, "utf-8");
-}
-function buildPrompt(url, tokens, animations, hasScreenshot, hasLottie, hasShaders, catalogedAssets) {
-  const hostname = new URL(url).hostname.replace(/^www\./, "");
-  const title = tokens.title || hostname;
-  const cues = detectImplementationCues(tokens, animations);
+import { join as join49 } from "path";
+function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, detectedLibraries) {
+  const prompt = buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries);
+  writeFileSync19(join49(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync19(join49(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync19(join49(outputDir, ".cursorrules"), prompt, "utf-8");
+}
+function buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries) {
+  const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
   const colorSummary = tokens.colors.slice(0, 10).join(", ");
-  const fontSummary = tokens.fonts.join(", ") || "none detected";
-  const sectionCount = tokens.sections?.length ?? 0;
-  const headingCount = tokens.headings?.length ?? 0;
-  const ctaCount = tokens.ctas?.length ?? 0;
-  const videoUrls = catalogedAssets ? catalogedAssets.filter((a) => a.type === "Video" && a.url.startsWith("http")).map((a) => a.url).filter((u, i2, arr) => arr.indexOf(u) === i2) : [];
-  return `# ${title} \u2014 Captured Website
+  const fontSummary = tokens.fonts.map(
+    (f3) => f3.family + (f3.variable && f3.weightRange ? ` (${f3.weightRange[0]}-${f3.weightRange[1]} variable)` : f3.weights.length > 0 ? ` (${f3.weights.join(",")})` : "")
+  ).join(", ") || "none detected";
+  const tableRows = [];
+  if (hasScreenshot) {
+    tableRows.push(
+      "| `screenshots/scroll-*.png` | Viewport screenshots of the full page. Start with `scroll-000.png` (hero). |"
+    );
+  }
+  tableRows.push(
+    "| `extracted/asset-descriptions.md` | One-line description of every downloaded asset. **Read this first.** |"
+  );
+  tableRows.push(
+    `| \`extracted/tokens.json\` | Design tokens: ${tokens.colors.length} colors, ${tokens.fonts.length} fonts, ${tokens.headings?.length ?? 0} headings, ${tokens.ctas?.length ?? 0} CTAs |`
+  );
+  tableRows.push(
+    "| `extracted/visible-text.txt` | Page text in DOM order, prefixed with HTML tag (`[h1]`, `[p]`, `[a]`). Use as context \u2014 rephrase freely. |"
+  );
+  if (hasLottie) {
+    tableRows.push(
+      "| `extracted/lottie-manifest.json` | Lottie animations with previews at `assets/lottie/previews/`. |"
+    );
+  }
+  if (hasShaders) {
+    tableRows.push("| `extracted/shaders.json` | WebGL shader source (GLSL). |");
+  }
+  if (detectedLibraries && detectedLibraries.length > 0) {
+    tableRows.push(
+      `| \`extracted/detected-libraries.json\` | Libraries: ${detectedLibraries.join(", ")} |`
+    );
+  }
+  tableRows.push("| `assets/` | Downloaded images, SVGs, and font files. |");
+  const brandLines = [];
+  brandLines.push(`- **Colors**: ${colorSummary || "see tokens.json"}`);
+  brandLines.push(`- **Fonts**: ${fontSummary}`);
+  if (detectedLibraries && detectedLibraries.length > 0) {
+    brandLines.push(`- **Built with**: ${detectedLibraries.join(", ")}`);
+  }
+  return `# ${title}
 
 Source: ${url}
 
-## How to Create a Video
-
-Invoke the \`/website-to-hyperframes\` skill. It walks you through the full workflow: read data \u2192 create DESIGN.md \u2192 plan video \u2192 build compositions \u2192 lint/validate/preview.
-
-If you don't have the skill installed, run: \`npx skills add heygen-com/hyperframes\`
+To create a video from this capture, use the \`website-to-hyperframes\` skill.
 
 ## What's in This Capture
 
 | File | Contents |
 |------|----------|
-${hasScreenshot ? "| `screenshots/scroll-*.png` | Viewport screenshots covering the full page (1920x1080 each, 30% overlap). **View scroll-000.png FIRST** (hero section), then scan through the rest to understand the full page. |" : ""}
-| \`extracted/tokens.json\` | Design tokens: ${tokens.colors.length} colors, ${tokens.fonts.length} fonts, ${headingCount} headings, ${ctaCount} CTAs, ${sectionCount} sections |
-| \`extracted/visible-text.txt\` | All visible text content in DOM order \u2014 use exact strings, never paraphrase |
-| \`extracted/assets-catalog.json\` | Every asset URL (images, fonts, videos, icons) with HTML context |
-| \`extracted/animations.json\` | Animation catalog: ${animations?.summary?.webAnimations ?? 0} web animations, ${animations?.summary?.scrollTargets ?? 0} scroll triggers, ${animations?.summary?.canvases ?? 0} canvases |
-| \`assets/svgs/\` | Extracted inline SVGs (logos, icons, illustrations) |
-| \`assets/\` | Downloaded images and font files \u2014 **Read every image file to see what it contains** |
-${hasLottie ? "| `extracted/lottie-manifest.json` | Lottie animations found on this site \u2014 read this to see what animations are available (name, dimensions, duration). Embed via `lottie.loadAnimation({ path: 'assets/lottie/animation-0.json' })`. Do NOT read the raw JSON files \u2014 they are machine data. |" : ""}
-${videoUrls.length > 0 ? "| `extracted/video-manifest.json` | Video manifest: every `<video>` element with its URL, surrounding heading/caption context, and a preview screenshot. **Read this + view each preview image** to understand what each video shows before using it. |" : ""}
-${hasShaders ? "| `extracted/shaders.json` | Captured WebGL shader source code (GLSL vertex + fragment shaders) |" : ""}
-| \`extracted/asset-descriptions.md\` | One-line description of every downloaded asset \u2014 read this first |
-
-> **DESIGN.md does not exist yet.** It will be created when you run the \`/website-to-hyperframes\` workflow. Do not write compositions without it.
+${tableRows.join("\n")}
 
 ## Brand Summary
 
-- **Colors**: ${colorSummary || "see tokens.json"}
-- **Fonts**: ${fontSummary}
-- **Sections**: ${sectionCount} page sections detected
-- **Headings**: ${headingCount} headings extracted
-- **CTAs**: ${ctaCount} calls-to-action found
-${cues.length > 0 ? `
-## Source Patterns Detected
-
-${cues.map((c2) => `- ${c2}`).join("\n")}
-` : ""}
-## Example Prompts
-
-Try asking:
-
-- "Make me a 15-second social ad from this capture"
-- "Create a 30-second product tour video"
-- "Turn this into a vertical Instagram reel"
-- "Build a feature announcement video highlighting the top 3 features"
+${brandLines.join("\n")}
 `;
 }
-function detectImplementationCues(tokens, animations) {
-  const cues = [];
-  if (Object.keys(tokens.cssVariables).length > 10) {
-    cues.push(
-      "CSS custom properties used extensively \u2014 preserve design tokens for colors, spacing, and typography."
-    );
-  }
-  if (tokens.fonts.length > 0) {
-    cues.push(
-      `Typography: ${tokens.fonts.join(", ")}. Match these exact font families and weights.`
-    );
-  }
-  if (animations?.summary) {
-    if (animations.summary.scrollTargets > 20) {
-      cues.push(`${animations.summary.scrollTargets} scroll-triggered animations detected.`);
-    }
-    if (animations.summary.webAnimations > 5) {
-      cues.push(`${animations.summary.webAnimations} active Web Animations detected.`);
-    }
-    if (animations.summary.canvases > 0) {
-      cues.push(`${animations.summary.canvases} Canvas/WebGL elements detected.`);
-    }
-  }
-  const hasMarquee = animations?.cssDeclarations?.some(
-    (d) => d.animation?.name?.toLowerCase().includes("marquee") || d.animation?.name?.toLowerCase().includes("scroll")
-  );
-  if (hasMarquee) {
-    cues.push("Marquee/ticker animation present \u2014 preserve continuous scrolling behavior.");
-  }
-  return cues;
-}
 var init_agentPromptGenerator = __esm({
   "src/capture/agentPromptGenerator.ts"() {
     "use strict";
@@ -73748,8 +75108,8 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync45, writeFileSync as writeFileSync20, readFileSync as readFileSync34 } from "fs";
-import { join as join49, resolve as resolve33 } from "path";
+import { existsSync as existsSync46, writeFileSync as writeFileSync20, readFileSync as readFileSync34 } from "fs";
+import { join as join50, resolve as resolve33 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve33(startDir);
@@ -73774,9 +75134,9 @@ function loadEnvFile(startDir) {
   } catch {
   }
 }
-async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings) {
-  const metaPath = join49(outputDir, "meta.json");
-  if (!existsSync45(metaPath)) {
+async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
+  const metaPath = join50(outputDir, "meta.json");
+  if (!existsSync46(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
     writeFileSync20(
       metaPath,
@@ -73794,11 +75154,12 @@ async function generateProjectScaffold(outputDir, url, tokens, animationCatalog,
       hasScreenshots,
       hasLotties,
       hasShaders,
-      catalogedAssets
+      catalogedAssets,
+      detectedLibraries
     );
-    progress("agent", "CLAUDE.md generated");
+    progress("agent", "AGENTS.md + CLAUDE.md generated");
   } catch (err) {
-    warnings.push(`CLAUDE.md generation failed: ${err}`);
+    warnings.push(`AGENTS.md/CLAUDE.md generation failed: ${err}`);
   }
 }
 var init_scaffolding = __esm({
@@ -73813,9 +75174,9 @@ __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
 import { writeFileSync as writeFileSync21, mkdirSync as mkdirSync27 } from "fs";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
-  const screenshotsDir = join50(outputDir, "screenshots");
+  const screenshotsDir = join51(outputDir, "screenshots");
   mkdirSync27(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
@@ -73849,7 +75210,7 @@ async function captureScrollScreenshots(page, outputDir) {
         finalPositions[i2] / Math.max(1, scrollHeight - viewportHeight) * 100
       );
       const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
-      const filePath = join50(screenshotsDir, filename);
+      const filePath = join51(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
       writeFileSync21(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
@@ -74162,8 +75523,8 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync22, existsSync as existsSync46 } from "fs";
-import { join as join51 } from "path";
+import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync22, existsSync as existsSync47 } from "fs";
+import { join as join52 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -74180,9 +75541,9 @@ async function captureWebsite(opts, onProgress) {
     onProgress?.(stage, detail);
   };
   loadEnvFile(outputDir);
-  mkdirSync28(join51(outputDir, "extracted"), { recursive: true });
-  mkdirSync28(join51(outputDir, "screenshots"), { recursive: true });
-  mkdirSync28(join51(outputDir, "assets"), { recursive: true });
+  mkdirSync28(join52(outputDir, "extracted"), { recursive: true });
+  mkdirSync28(join52(outputDir, "screenshots"), { recursive: true });
+  mkdirSync28(join52(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -74338,7 +75699,7 @@ async function captureWebsite(opts, onProgress) {
     } catch {
     }
     if (discoveredLotties.length > 0) {
-      const lottieDir = join51(outputDir, "assets", "lottie");
+      const lottieDir = join52(outputDir, "assets", "lottie");
       mkdirSync28(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
@@ -74358,7 +75719,7 @@ async function captureWebsite(opts, onProgress) {
         });
         capturedShaders = unique;
         writeFileSync22(
-          join51(outputDir, "extracted", "shaders.json"),
+          join52(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -74369,7 +75730,7 @@ async function captureWebsite(opts, onProgress) {
     progress("tokens", "Extracting design tokens...");
     const tokens = await extractTokens(page1);
     writeFileSync22(
-      join51(outputDir, "extracted", "tokens.json"),
+      join52(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokens, null, 2),
       "utf-8"
     );
@@ -74385,8 +75746,13 @@ async function captureWebsite(opts, onProgress) {
       const { catalogAssets: catalogAssets2 } = await Promise.resolve().then(() => (init_assetCataloger(), assetCataloger_exports));
       catalogedAssets = await catalogAssets2(page1);
       progress("design", `${catalogedAssets.length} assets cataloged`);
+      if (catalogedAssets.length === 0) {
+        warnings.push(
+          "Asset catalog is empty \u2014 no images will be downloaded. The page may use non-standard image loading."
+        );
+      }
     } catch (err) {
-      warnings.push(`Asset cataloging failed: ${err}`);
+      warnings.push(`Asset cataloging failed (no images will be downloaded): ${err}`);
     }
     progress("extract", "Extracting HTML & CSS...");
     const extracted = await extractHtml(page1, { settleTime: 1e3 });
@@ -74419,6 +75785,10 @@ async function captureWebsite(opts, onProgress) {
     }
     const detectedLibraries = await detectLibraries(page1, capturedShaders);
     const visibleTextContent = await extractVisibleText(page1);
+    const faviconLinks = await page1.evaluate(`(() => {
+      var iconEls = Array.from(document.querySelectorAll('link[rel*="icon"], link[rel="apple-touch-icon"]'));
+      return iconEls.map(function(l) { return { rel: l.rel, href: l.href }; });
+    })()`);
     await page1.close();
     extracted.headHtml = await downloadAndRewriteFonts(extracted.headHtml, outputDir);
     if (animationCatalog) {
@@ -74434,7 +75804,7 @@ async function captureWebsite(opts, onProgress) {
         representativeAnimations: representativeAnims
       };
       writeFileSync22(
-        join51(outputDir, "extracted", "animations.json"),
+        join52(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -74442,21 +75812,21 @@ async function captureWebsite(opts, onProgress) {
     let assets = [];
     if (!skipAssets) {
       progress("assets", "Downloading assets...");
-      assets = await downloadAssets(tokens, outputDir, catalogedAssets);
+      assets = await downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks);
     }
     if (visibleTextContent) {
-      writeFileSync22(join51(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync22(join52(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     if (catalogedAssets.length > 0) {
       writeFileSync22(
-        join51(outputDir, "extracted", "assets-catalog.json"),
+        join52(outputDir, "extracted", "assets-catalog.json"),
         JSON.stringify(catalogedAssets, null, 2),
         "utf-8"
       );
     }
     if (detectedLibraries.length > 0) {
       writeFileSync22(
-        join51(outputDir, "extracted", "detected-libraries.json"),
+        join52(outputDir, "extracted", "detected-libraries.json"),
         JSON.stringify(detectedLibraries, null, 2),
         "utf-8"
       );
@@ -74467,7 +75837,7 @@ async function captureWebsite(opts, onProgress) {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
         writeFileSync22(
-          join51(outputDir, "extracted", "asset-descriptions.md"),
+          join52(outputDir, "extracted", "asset-descriptions.md"),
           "# Asset Descriptions\n\nOne line per file. Read this instead of opening every image individually.\n\n" + lines.map((l) => "- " + l).join("\n") + "\n",
           "utf-8"
         );
@@ -74483,10 +75853,11 @@ async function captureWebsite(opts, onProgress) {
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync46(join51(outputDir, "extracted", "shaders.json")),
+      existsSync47(join52(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
-      warnings
+      warnings,
+      detectedLibraries
     );
     progress("done", "Capture complete");
     return {
@@ -74628,7 +75999,8 @@ var init_capture2 = __esm({
                   screenshots: result.screenshots.length,
                   assets: result.assets.length,
                   detectedSections: result.tokens.sections.length,
-                  fonts: result.tokens.fonts,
+                  fonts: result.tokens.fonts.map((f3) => f3.family),
+                  fontsDetailed: result.tokens.fonts,
                   animations: result.animationCatalog?.summary,
                   warnings: result.warnings
                 },
@@ -74644,7 +76016,11 @@ var init_capture2 = __esm({
             console.log(`  ${c2.dim("Screenshots:")} ${result.screenshots.length}`);
             console.log(`  ${c2.dim("Assets:")} ${result.assets.length}`);
             console.log(`  ${c2.dim("Sections:")} ${result.tokens.sections.length}`);
-            console.log(`  ${c2.dim("Fonts:")} ${result.tokens.fonts.join(", ")}`);
+            console.log(
+              `  ${c2.dim("Fonts:")} ${result.tokens.fonts.map(function(f3) {
+                return f3.family + " (" + (f3.variable && f3.weightRange ? f3.weightRange[0] + "-" + f3.weightRange[1] + " variable" : f3.weights.join(",")) + ")";
+              }).join(", ")}`
+            );
             if (result.warnings.length > 0) {
               console.log();
               for (const w of result.warnings) {