hyperframes 0.4.19 → 0.4.21

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.19" : "0.0.0-dev";
+    VERSION = true ? "0.4.21" : "0.0.0-dev";
   }
 });
 
@@ -4801,6 +4801,7 @@ function extractGsapWindows(script) {
       position: animation.position,
       end: animation.position + meta.effectiveDuration,
       properties: meta.properties.length > 0 ? meta.properties : Object.keys(animation.properties),
+      propertyValues: meta.propertyValues,
       overwriteAuto: meta.overwriteAuto,
       method: match[1] ?? "to",
       raw
@@ -4809,8 +4810,14 @@ function extractGsapWindows(script) {
   return windows;
 }
 function parseGsapWindowMeta(method, argsStr) {
+  const emptyMeta = {
+    effectiveDuration: 0,
+    properties: [],
+    propertyValues: {},
+    overwriteAuto: false
+  };
   const selectorMatch = argsStr.match(/^\s*["']([^"']+)["']\s*,/);
-  if (!selectorMatch) return { effectiveDuration: 0, properties: [], overwriteAuto: false };
+  if (!selectorMatch) return emptyMeta;
   const afterSelector = argsStr.slice(selectorMatch[0].length);
   let properties = {};
   let fromProperties = {};
@@ -4848,6 +4855,7 @@ function parseGsapWindowMeta(method, argsStr) {
   return {
     effectiveDuration: method === "set" ? 0 : effectiveDuration,
     properties: [...propertyNames],
+    propertyValues: properties,
     overwriteAuto
   };
 }
@@ -4895,6 +4903,94 @@ function stringValue(value) {
   if (typeof value === "number") return String(value);
   return null;
 }
+function zeroValue(value) {
+  if (typeof value === "number") return value === 0;
+  if (typeof value !== "string") return false;
+  return Number(value.trim()) === 0;
+}
+function isHiddenGsapState(values) {
+  const visibility = stringValue(values.visibility)?.toLowerCase();
+  const display = stringValue(values.display)?.toLowerCase();
+  return zeroValue(values.opacity) || zeroValue(values.autoAlpha) || visibility === "hidden" || display === "none";
+}
+function isSceneBoundaryExit(win) {
+  if (win.end <= win.position) return false;
+  if (win.method !== "to" && win.method !== "fromTo") return false;
+  return isHiddenGsapState(win.propertyValues);
+}
+function isHardKillSet(win, selector, boundary) {
+  return win.method === "set" && win.targetSelector === selector && Math.abs(win.position - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS && isHiddenGsapState(win.propertyValues);
+}
+function hiddenStateLiteral(values) {
+  if (zeroValue(values.autoAlpha)) return "{ autoAlpha: 0 }";
+  if (zeroValue(values.opacity)) return "{ opacity: 0 }";
+  if (stringValue(values.visibility)?.toLowerCase() === "hidden") return '{ visibility: "hidden" }';
+  if (stringValue(values.display)?.toLowerCase() === "none") return '{ display: "none" }';
+  return "{ opacity: 0 }";
+}
+function findTagEnd(source, tag) {
+  const escapedTagName = tag.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<\\/?${escapedTagName}\\b[^>]*>`, "gi");
+  pattern.lastIndex = tag.index;
+  let depth = 0;
+  let match;
+  while ((match = pattern.exec(source)) !== null) {
+    const raw = match[0];
+    const isClosing = /^<\s*\//.test(raw);
+    const isSelfClosing = /\/\s*>$/.test(raw);
+    if (!isClosing && !isSelfClosing) depth += 1;
+    if (isClosing) depth -= 1;
+    if (depth === 0) return pattern.lastIndex;
+  }
+  return source.length;
+}
+function collectCompositionRanges(source, tags) {
+  return tags.map((tag) => {
+    const id = readAttr(tag.raw, "data-composition-id");
+    if (!id) return null;
+    return {
+      id,
+      start: tag.index,
+      end: findTagEnd(source, tag)
+    };
+  }).filter((range) => range !== null);
+}
+function findContainingCompositionId(tag, ranges) {
+  let match = null;
+  for (const range of ranges) {
+    if (tag.index < range.start || tag.index >= range.end) continue;
+    if (!match || range.start >= match.start) match = range;
+  }
+  return match?.id || null;
+}
+function collectClipStartBoundariesByComposition(source, tags) {
+  const ranges = collectCompositionRanges(source, tags);
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const classAttr = readAttr(tag.raw, "class") || "";
+    const classes = classAttr.split(/\s+/).filter(Boolean);
+    if (!classes.includes("clip")) continue;
+    const compositionId = findContainingCompositionId(tag, ranges);
+    if (!compositionId) continue;
+    const start = numberValue(readAttr(tag.raw, "data-start") ?? void 0);
+    if (start == null || start <= 0) continue;
+    const compositionBoundaries = boundaries.get(compositionId) ?? /* @__PURE__ */ new Set();
+    compositionBoundaries.add(start);
+    boundaries.set(compositionId, compositionBoundaries);
+  }
+  return new Map(
+    [...boundaries.entries()].map(([compositionId, values]) => [
+      compositionId,
+      [...values].sort((a, b) => a - b)
+    ])
+  );
+}
+function findMatchingSceneBoundary(time, boundaries) {
+  for (const boundary of boundaries) {
+    if (Math.abs(time - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS) return boundary;
+  }
+  return null;
+}
 function isSuspiciousGlobalSelector(selector) {
   if (!selector) return false;
   if (selector.includes("[data-composition-id=")) return false;
@@ -4933,16 +5029,17 @@ function cssTransformToGsapProps(cssTransform) {
   }
   return parts.length > 0 ? parts.join(", ") : null;
 }
-var META_GSAP_KEYS, gsapRules;
+var META_GSAP_KEYS, SCENE_BOUNDARY_EPSILON_SECONDS, gsapRules;
 var init_gsap = __esm({
   "../core/src/lint/rules/gsap.ts"() {
     "use strict";
     init_gsapParser();
     init_utils();
     META_GSAP_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "repeat", "yoyo", "overwrite", "delay"]);
+    SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
     gsapRules = [
       // overlapping_gsap_tweens + gsap_animates_clip_element + unscoped_gsap_selector
-      ({ tags, scripts, rootCompositionId }) => {
+      ({ source, tags, scripts, rootCompositionId }) => {
         const findings = [];
         const clipIds = /* @__PURE__ */ new Map();
         const clipClasses = /* @__PURE__ */ new Map();
@@ -4962,9 +5059,11 @@ var init_gsap = __esm({
           }
         }
         const classUsage = countClassUsage(tags);
+        const clipStartBoundariesByComposition = collectClipStartBoundariesByComposition(source, tags);
         for (const script of scripts) {
           const localTimelineCompId = readRegisteredTimelineCompositionId(script.content);
           const gsapWindows = extractGsapWindows(script.content);
+          const clipStartBoundaries = clipStartBoundariesByComposition.get(localTimelineCompId || rootCompositionId || "") ?? [];
           for (let i2 = 0; i2 < gsapWindows.length; i2++) {
             const left = gsapWindows[i2];
             if (!left) continue;
@@ -4993,6 +5092,25 @@ ${right.raw}`)
               });
             }
           }
+          if (clipStartBoundaries.length > 0) {
+            for (const win of gsapWindows) {
+              if (!isSceneBoundaryExit(win)) continue;
+              const boundary = findMatchingSceneBoundary(win.end, clipStartBoundaries);
+              if (boundary == null) continue;
+              const hasHardKill = gsapWindows.some(
+                (candidate) => isHardKillSet(candidate, win.targetSelector, boundary)
+              );
+              if (hasHardKill) continue;
+              findings.push({
+                code: "gsap_exit_missing_hard_kill",
+                severity: "warning",
+                message: `GSAP exit on "${win.targetSelector}" ends at the ${boundary.toFixed(2)}s clip start boundary without a matching tl.set hard kill. Non-linear seeking can land after the fade and leave stale visibility state.`,
+                selector: win.targetSelector,
+                fixHint: `Add \`tl.set("${win.targetSelector}", ${hiddenStateLiteral(win.propertyValues)}, ${boundary.toFixed(2)})\` after the exit tween.`,
+                snippet: truncateSnippet(win.raw)
+              });
+            }
+          }
           for (const win of gsapWindows) {
             const sel = win.targetSelector;
             const clipInfo = clipIds.get(sel) || clipClasses.get(sel);
@@ -8231,22 +8349,22 @@ function getMeasureContext() {
   throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
 }
 function getSegmentMetricCache(font) {
-  let cache = segmentMetricCaches.get(font);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    segmentMetricCaches.set(font, cache);
+  let cache2 = segmentMetricCaches.get(font);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    segmentMetricCaches.set(font, cache2);
   }
-  return cache;
+  return cache2;
 }
-function getSegmentMetrics(seg, cache) {
-  let metrics = cache.get(seg);
+function getSegmentMetrics(seg, cache2) {
+  let metrics = cache2.get(seg);
   if (metrics === void 0) {
     const ctx = getMeasureContext();
     metrics = {
       width: ctx.measureText(seg).width,
       containsCJK: isCJK(seg)
     };
-    cache.set(seg, metrics);
+    cache2.set(seg, metrics);
   }
   return metrics;
 }
@@ -8335,7 +8453,7 @@ function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
     return metrics.width;
   return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
 }
-function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mode) {
+function getSegmentBreakableFitAdvances(seg, metrics, cache2, emojiCorrection, mode) {
   if (metrics.breakableFitAdvances !== void 0)
     return metrics.breakableFitAdvances;
   const graphemeSegmenter = getSharedGraphemeSegmenter();
@@ -8350,7 +8468,7 @@ function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mo
   if (mode === "sum-graphemes") {
     const advances2 = [];
     for (const grapheme of graphemes) {
-      const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+      const graphemeMetrics = getSegmentMetrics(grapheme, cache2);
       advances2.push(getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection));
     }
     metrics.breakableFitAdvances = advances2;
@@ -8361,13 +8479,13 @@ function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mo
     let previousGrapheme = null;
     let previousWidth = 0;
     for (const grapheme of graphemes) {
-      const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+      const graphemeMetrics = getSegmentMetrics(grapheme, cache2);
       const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
       if (previousGrapheme === null) {
         advances2.push(currentWidth);
       } else {
         const pair = previousGrapheme + grapheme;
-        const pairMetrics = getSegmentMetrics(pair, cache);
+        const pairMetrics = getSegmentMetrics(pair, cache2);
         advances2.push(getCorrectedSegmentWidth(pair, pairMetrics, emojiCorrection) - previousWidth);
       }
       previousGrapheme = grapheme;
@@ -8381,7 +8499,7 @@ function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mo
   let prefixWidth = 0;
   for (const grapheme of graphemes) {
     prefix += grapheme;
-    const prefixMetrics = getSegmentMetrics(prefix, cache);
+    const prefixMetrics = getSegmentMetrics(prefix, cache2);
     const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
     advances.push(nextPrefixWidth - prefixWidth);
     prefixWidth = nextPrefixWidth;
@@ -8392,10 +8510,10 @@ function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mo
 function getFontMeasurementState(font, needsEmojiCorrection) {
   const ctx = getMeasureContext();
   ctx.font = font;
-  const cache = getSegmentMetricCache(font);
+  const cache2 = getSegmentMetricCache(font);
   const fontSize = parseFontSize(font);
   const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;
-  return { cache, fontSize, emojiCorrection };
+  return { cache: cache2, fontSize, emojiCorrection };
 }
 var measureContext, segmentMetricCaches, cachedEngineProfile, MAX_PREFIX_FIT_GRAPHEMES, emojiPresentationRe, maybeEmojiRe, sharedGraphemeSegmenter, emojiCorrectionCache;
 var init_measurement = __esm({
@@ -8939,9 +9057,9 @@ function mergeKeepAllTextUnits(units) {
 }
 function measureAnalysis(analysis, font, includeSegments, wordBreak) {
   const engineProfile = getEngineProfile();
-  const { cache, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
-  const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache), emojiCorrection);
-  const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache), emojiCorrection);
+  const { cache: cache2, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
+  const discretionaryHyphenWidth = getCorrectedSegmentWidth("-", getSegmentMetrics("-", cache2), emojiCorrection);
+  const spaceWidth = getCorrectedSegmentWidth(" ", getSegmentMetrics(" ", cache2), emojiCorrection);
   const tabStopAdvance = spaceWidth * 8;
   if (analysis.len === 0)
     return createEmptyPrepared(includeSegments);
@@ -8968,7 +9086,7 @@ function measureAnalysis(analysis, font, includeSegments, wordBreak) {
       segments.push(text);
   }
   function pushMeasuredTextSegment(text, kind, start, wordLike, allowOverflowBreaks) {
-    const textMetrics = getSegmentMetrics(text, cache);
+    const textMetrics = getSegmentMetrics(text, cache2);
     const width = getCorrectedSegmentWidth(text, textMetrics, emojiCorrection);
     const lineEndFitAdvance = kind === "space" || kind === "preserved-space" || kind === "zero-width-break" ? 0 : width;
     const lineEndPaintAdvance = kind === "space" || kind === "zero-width-break" ? 0 : width;
@@ -8979,7 +9097,7 @@ function measureAnalysis(analysis, font, includeSegments, wordBreak) {
       } else if (engineProfile.preferPrefixWidthsForBreakableRuns) {
         fitMode = "segment-prefixes";
       }
-      const fitAdvances = getSegmentBreakableFitAdvances(text, textMetrics, cache, emojiCorrection, fitMode);
+      const fitAdvances = getSegmentBreakableFitAdvances(text, textMetrics, cache2, emojiCorrection, fitMode);
       pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, fitAdvances);
       return;
     }
@@ -9003,7 +9121,7 @@ function measureAnalysis(analysis, font, includeSegments, wordBreak) {
       pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null);
       continue;
     }
-    const segMetrics = getSegmentMetrics(segText, cache);
+    const segMetrics = getSegmentMetrics(segText, cache2);
     if (segKind === "text" && segMetrics.containsCJK) {
       const baseUnits = buildBaseCjkUnits(segText, engineProfile);
       const measuredUnits = wordBreak === "keep-all" ? mergeKeepAllTextUnits(baseUnits) : baseUnits;
@@ -9801,7 +9919,24 @@ function trackRenderComplete(props) {
     capture_avg_ms: props.captureAvgMs,
     capture_peak_ms: props.capturePeakMs,
     peak_memory_mb: props.peakMemoryMb,
-    memory_free_mb: props.memoryFreeMb
+    memory_free_mb: props.memoryFreeMb,
+    tmp_peak_bytes: props.tmpPeakBytes,
+    stage_compile_ms: props.stageCompileMs,
+    stage_video_extract_ms: props.stageVideoExtractMs,
+    stage_audio_process_ms: props.stageAudioProcessMs,
+    stage_capture_ms: props.stageCaptureMs,
+    stage_encode_ms: props.stageEncodeMs,
+    stage_assemble_ms: props.stageAssembleMs,
+    extract_resolve_ms: props.extractResolveMs,
+    extract_hdr_probe_ms: props.extractHdrProbeMs,
+    extract_hdr_preflight_ms: props.extractHdrPreflightMs,
+    extract_hdr_preflight_count: props.extractHdrPreflightCount,
+    extract_vfr_probe_ms: props.extractVfrProbeMs,
+    extract_vfr_preflight_ms: props.extractVfrPreflightMs,
+    extract_vfr_preflight_count: props.extractVfrPreflightCount,
+    extract_phase3_ms: props.extractPhase3Ms,
+    extract_cache_hits: props.extractCacheHits,
+    extract_cache_misses: props.extractCacheMisses
   });
 }
 function trackRenderError(props) {
@@ -24970,7 +25105,8 @@ function resolveConfig(overrides) {
       DEFAULT_CONFIG2.renderReadyTimeout
     ),
     verifyRuntime: env("PRODUCER_VERIFY_HYPERFRAME_RUNTIME") !== "false",
-    runtimeManifestPath: env("PRODUCER_HYPERFRAME_MANIFEST_PATH")
+    runtimeManifestPath: env("PRODUCER_HYPERFRAME_MANIFEST_PATH"),
+    extractCacheDir: env("HYPERFRAMES_EXTRACT_CACHE_DIR")
   };
   const cleanEnv = Object.fromEntries(Object.entries(fromEnv).filter(([, v]) => v !== void 0));
   return {
@@ -27127,13 +27263,130 @@ var init_urlDownloader = __esm({
   }
 });
 
+// ../engine/src/utils/htmlTemplate.ts
+function parseHTMLContent(html) {
+  const trimmed = html.trimStart().toLowerCase();
+  if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html")) {
+    return parseHTML(html).document;
+  }
+  return parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`).document;
+}
+function getSingleMeaningfulChild(container) {
+  let child = null;
+  for (const node of Array.from(container.childNodes)) {
+    if (node.nodeType === 3 && !(node.textContent || "").trim()) continue;
+    if (node.nodeType === 8) continue;
+    if (node.nodeType !== 1) return null;
+    if (child) return null;
+    child = node;
+  }
+  return child;
+}
+function unwrapTemplate(html) {
+  const lowered = html.toLowerCase();
+  if (!lowered.includes("<template") || !lowered.includes("</template>")) {
+    return html;
+  }
+  const { body } = parseHTMLContent(html);
+  if (!body) return html;
+  let container = body;
+  const bodyWrapper = getSingleMeaningfulChild(container);
+  if (bodyWrapper?.tagName === "BODY") {
+    container = bodyWrapper;
+  }
+  const template = getSingleMeaningfulChild(container);
+  if (template?.tagName !== "TEMPLATE") {
+    return html;
+  }
+  return template.innerHTML ?? html;
+}
+var init_htmlTemplate = __esm({
+  "../engine/src/utils/htmlTemplate.ts"() {
+    "use strict";
+    init_esm10();
+  }
+});
+
+// ../engine/src/services/extractionCache.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync12, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync20 } from "fs";
+import { join as join22 } from "path";
+function readKeyStat(videoPath) {
+  try {
+    const stat3 = statSync6(videoPath);
+    return { mtimeMs: Math.floor(stat3.mtimeMs), size: stat3.size };
+  } catch {
+    return null;
+  }
+}
+function canonicalKeyBlob(input) {
+  const durationForKey = Number.isFinite(input.duration) ? input.duration : -1;
+  return JSON.stringify({
+    p: input.videoPath,
+    m: input.mtimeMs,
+    s: input.size,
+    ms: input.mediaStart,
+    d: durationForKey,
+    f: input.fps,
+    fmt: input.format
+  });
+}
+function computeCacheKey(input) {
+  return createHash2("sha256").update(canonicalKeyBlob(input)).digest("hex");
+}
+function cacheEntryDirName(keyHash) {
+  return SCHEMA_PREFIX + keyHash.slice(0, KEY_HEX_CHARS);
+}
+function lookupCacheEntry(rootDir, input) {
+  const keyHash = computeCacheKey(input);
+  const dir = join22(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync20(join22(dir, COMPLETE_SENTINEL));
+  return { entry: { dir, keyHash }, hit: complete };
+}
+function ensureCacheEntryDir(entry) {
+  mkdirSync12(entry.dir, { recursive: true });
+}
+function markCacheEntryComplete(entry) {
+  writeFileSync10(join22(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
+}
+function rehydrateCacheEntry(entry, options) {
+  const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${options.format}`;
+  const framePaths = /* @__PURE__ */ new Map();
+  const suffix = `.${options.format}`;
+  const files = readdirSync8(entry.dir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(suffix)).sort();
+  files.forEach((file, idx) => {
+    framePaths.set(idx, join22(entry.dir, file));
+  });
+  return {
+    videoId: options.videoId,
+    srcPath: options.srcPath,
+    outputDir: entry.dir,
+    framePattern,
+    fps: options.fps,
+    totalFrames: framePaths.size,
+    metadata: options.metadata,
+    framePaths
+  };
+}
+var FRAME_FILENAME_PREFIX, COMPLETE_SENTINEL, SCHEMA_PREFIX, KEY_HEX_CHARS;
+var init_extractionCache = __esm({
+  "../engine/src/services/extractionCache.ts"() {
+    "use strict";
+    FRAME_FILENAME_PREFIX = "frame_";
+    COMPLETE_SENTINEL = ".hf-complete";
+    SCHEMA_PREFIX = "hfcache-v2-";
+    KEY_HEX_CHARS = 16;
+  }
+});
+
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readdirSync as readdirSync8, rmSync as rmSync5 } from "fs";
-import { isAbsolute as isAbsolute2, join as join22 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readdirSync as readdirSync9, rmSync as rmSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join23 } from "path";
 function parseVideoElements(html) {
   const videos = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const videoEls = document2.querySelectorAll("video[src]");
   let autoIdCounter = 0;
   for (const el of videoEls) {
@@ -27170,7 +27423,7 @@ function parseVideoElements(html) {
 }
 function parseImageElements(html) {
   const images = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const imgEls = document2.querySelectorAll("img[src]");
   let autoIdCounter = 0;
   for (const el of imgEls) {
@@ -27196,14 +27449,14 @@ function parseImageElements(html) {
   }
   return images;
 }
-async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config) {
+async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const { fps, outputDir, quality = 95, format = "jpg" } = options;
-  const videoOutputDir = join22(outputDir, videoId);
-  if (!existsSync20(videoOutputDir)) mkdirSync12(videoOutputDir, { recursive: true });
+  const videoOutputDir = outputDirOverride ?? join23(outputDir, videoId);
+  if (!existsSync21(videoOutputDir)) mkdirSync13(videoOutputDir, { recursive: true });
   const metadata = await extractMediaMetadata(videoPath);
-  const framePattern = `frame_%05d.${format}`;
-  const outputPattern = join22(videoOutputDir, framePattern);
+  const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
+  const outputPattern = join23(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -27251,9 +27504,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
         return;
       }
       const framePaths = /* @__PURE__ */ new Map();
-      const files = readdirSync8(videoOutputDir).filter((f3) => f3.startsWith("frame_") && f3.endsWith(`.${format}`)).sort();
+      const files = readdirSync9(videoOutputDir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(`.${format}`)).sort();
       files.forEach((file, index) => {
-        framePaths.set(index, join22(videoOutputDir, file));
+        framePaths.set(index, join23(videoOutputDir, file));
       });
       resolve38({
         videoId,
@@ -27277,12 +27530,19 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     });
   });
 }
-async function convertSdrToHdr(inputPath, outputPath, targetTransfer, signal, config) {
+async function convertSdrToHdr(inputPath, outputPath, startTime, duration, targetTransfer, signal, config) {
+  if (duration <= 0) {
+    throw new Error(`convertSdrToHdr: duration must be positive (got ${duration})`);
+  }
   const timeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const colorTrc = targetTransfer === "pq" ? "smpte2084" : "arib-std-b67";
   const args = [
+    "-ss",
+    String(startTime),
     "-i",
     inputPath,
+    "-t",
+    String(duration),
     "-vf",
     "colorspace=all=bt2020:iall=bt709:range=tv",
     "-color_primaries",
@@ -27309,6 +27569,11 @@ async function convertSdrToHdr(inputPath, outputPath, targetTransfer, signal, co
     );
   }
 }
+function resolveSegmentDuration(requested, mediaStart, metadata) {
+  if (Number.isFinite(requested) && requested > 0) return requested;
+  const sourceRemaining = metadata.durationSeconds - mediaStart;
+  return sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+}
 async function convertVfrToCfr(inputPath, outputPath, targetFps, startTime, duration, signal, config) {
   const timeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const args = [
@@ -27345,21 +27610,34 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   const extracted = [];
   const errors = [];
   let totalFramesExtracted = 0;
+  const breakdown = {
+    resolveMs: 0,
+    hdrProbeMs: 0,
+    hdrPreflightMs: 0,
+    hdrPreflightCount: 0,
+    vfrProbeMs: 0,
+    vfrPreflightMs: 0,
+    vfrPreflightCount: 0,
+    extractMs: 0,
+    cacheHits: 0,
+    cacheMisses: 0
+  };
+  const phase1Start = Date.now();
   const resolvedVideos = [];
   for (const video of videos) {
     if (signal?.aborted) break;
     try {
       let videoPath = video.src;
       if (!isAbsolute2(videoPath) && !isHttpUrl(videoPath)) {
-        const fromCompiled = compiledDir ? join22(compiledDir, videoPath) : null;
-        videoPath = fromCompiled && existsSync20(fromCompiled) ? fromCompiled : join22(baseDir, videoPath);
+        const fromCompiled = compiledDir ? join23(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync21(fromCompiled) ? fromCompiled : join23(baseDir, videoPath);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join22(options.outputDir, "_downloads");
-        mkdirSync12(downloadDir, { recursive: true });
+        const downloadDir = join23(options.outputDir, "_downloads");
+        mkdirSync13(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(videoPath, downloadDir);
       }
-      if (!existsSync20(videoPath)) {
+      if (!existsSync21(videoPath)) {
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }
@@ -27368,27 +27646,66 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       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 extractMediaMetadata(videoPath);
-      return metadata.colorSpace;
-    })
+  breakdown.resolveMs = Date.now() - phase1Start;
+  const cacheKeyInputs = resolvedVideos.map(({ video, videoPath }) => {
+    const stat3 = readKeyStat(videoPath);
+    if (!stat3) return null;
+    return {
+      videoPath,
+      mtimeMs: stat3.mtimeMs,
+      size: stat3.size,
+      mediaStart: video.mediaStart,
+      start: video.start,
+      end: video.end
+    };
+  });
+  const phase2ProbeStart = Date.now();
+  const videoMetadata = await Promise.all(
+    resolvedVideos.map(({ videoPath }) => extractMediaMetadata(videoPath))
   );
+  const videoColorSpaces = videoMetadata.map((m2) => m2.colorSpace);
+  breakdown.hdrProbeMs = Date.now() - phase2ProbeStart;
+  const hdrPreflightStart = Date.now();
   const hdrInfo = analyzeCompositionHdr(videoColorSpaces);
+  const hdrSkippedIndices = /* @__PURE__ */ new Set();
   if (hdrInfo.hasHdr && hdrInfo.dominantTransfer) {
     const targetTransfer = hdrInfo.dominantTransfer;
-    const convertDir = join22(options.outputDir, "_hdr_normalized");
-    mkdirSync12(convertDir, { recursive: true });
+    const convertDir = join23(options.outputDir, "_hdr_normalized");
+    mkdirSync13(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 = join22(convertDir, `${entry.video.id}_hdr.mp4`);
+        const metadata = videoMetadata[i2];
+        if (!entry || !metadata) continue;
+        if (entry.video.mediaStart >= metadata.durationSeconds) {
+          errors.push({
+            videoId: entry.video.id,
+            error: `SDR\u2192HDR conversion skipped: mediaStart (${entry.video.mediaStart}s) \u2265 source duration (${metadata.durationSeconds}s)`
+          });
+          hdrSkippedIndices.add(i2);
+          continue;
+        }
+        let segDuration = entry.video.end - entry.video.start;
+        if (!Number.isFinite(segDuration) || segDuration <= 0) {
+          const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
+          segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+        }
+        const convertedPath = join23(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
-          await convertSdrToHdr(entry.videoPath, convertedPath, targetTransfer, signal, config);
+          await convertSdrToHdr(
+            entry.videoPath,
+            convertedPath,
+            entry.video.mediaStart,
+            segDuration,
+            targetTransfer,
+            signal,
+            config
+          );
           entry.videoPath = convertedPath;
+          entry.video = { ...entry.video, mediaStart: 0 };
+          breakdown.hdrPreflightCount += 1;
         } catch (err) {
           errors.push({
             videoId: entry.video.id,
@@ -27398,20 +27715,34 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       }
     }
   }
-  const vfrNormDir = join22(options.outputDir, "_vfr_normalized");
+  breakdown.hdrPreflightMs = Date.now() - hdrPreflightStart;
+  if (hdrSkippedIndices.size > 0) {
+    for (let i2 = resolvedVideos.length - 1; i2 >= 0; i2--) {
+      if (hdrSkippedIndices.has(i2)) {
+        resolvedVideos.splice(i2, 1);
+        videoMetadata.splice(i2, 1);
+        videoColorSpaces.splice(i2, 1);
+        cacheKeyInputs.splice(i2, 1);
+      }
+    }
+  }
+  const vfrPreflightStart = Date.now();
+  const vfrNormDir = join23(options.outputDir, "_vfr_normalized");
   for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i2];
     if (!entry) continue;
+    const vfrProbeStart = Date.now();
     const metadata = await extractMediaMetadata(entry.videoPath);
+    breakdown.vfrProbeMs += Date.now() - vfrProbeStart;
     if (!metadata.isVFR) continue;
     let segDuration = entry.video.end - entry.video.start;
     if (!Number.isFinite(segDuration) || segDuration <= 0) {
       const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
-    mkdirSync12(vfrNormDir, { recursive: true });
-    const normalizedPath = join22(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    mkdirSync13(vfrNormDir, { recursive: true });
+    const normalizedPath = join23(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
         entry.videoPath,
@@ -27424,6 +27755,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       );
       entry.videoPath = normalizedPath;
       entry.video = { ...entry.video, mediaStart: 0 };
+      breakdown.vfrPreflightCount += 1;
     } catch (err) {
       errors.push({
         videoId: entry.video.id,
@@ -27431,19 +27763,72 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       });
     }
   }
+  breakdown.vfrPreflightMs = Date.now() - vfrPreflightStart;
+  const phase3Start = Date.now();
+  const cacheRootDir = config?.extractCacheDir;
+  const cacheFormat = options.format ?? "jpg";
+  async function tryCachedExtract(video, videoPath, videoDuration, i2) {
+    if (!cacheRootDir) return null;
+    const keyInput = cacheKeyInputs[i2];
+    const probedMeta = videoMetadata[i2];
+    if (!keyInput || !probedMeta) return null;
+    const keyDuration = resolveSegmentDuration(
+      keyInput.end - keyInput.start,
+      keyInput.mediaStart,
+      probedMeta
+    );
+    const lookup = lookupCacheEntry(cacheRootDir, {
+      videoPath: keyInput.videoPath,
+      mtimeMs: keyInput.mtimeMs,
+      size: keyInput.size,
+      mediaStart: keyInput.mediaStart,
+      duration: keyDuration,
+      fps: options.fps,
+      format: cacheFormat
+    });
+    if (lookup.hit) {
+      breakdown.cacheHits += 1;
+      const rehydrated = rehydrateCacheEntry(lookup.entry, {
+        videoId: video.id,
+        srcPath: keyInput.videoPath,
+        fps: options.fps,
+        format: cacheFormat,
+        metadata: probedMeta
+      });
+      return { ...rehydrated, ownedByLookup: true };
+    }
+    breakdown.cacheMisses += 1;
+    ensureCacheEntryDir(lookup.entry);
+    const result = await extractVideoFramesRange(
+      videoPath,
+      video.id,
+      video.mediaStart,
+      videoDuration,
+      options,
+      signal,
+      config,
+      lookup.entry.dir
+    );
+    markCacheEntryComplete(lookup.entry);
+    return { ...result, ownedByLookup: true };
+  }
   const results = await Promise.all(
-    resolvedVideos.map(async ({ video, videoPath }) => {
+    resolvedVideos.map(async ({ video, videoPath }, i2) => {
       if (signal?.aborted) {
         throw new Error("Video frame extraction cancelled");
       }
       try {
-        let videoDuration = video.end - video.start;
-        if (!Number.isFinite(videoDuration) || videoDuration <= 0) {
-          const metadata = await extractMediaMetadata(videoPath);
-          const sourceDuration = metadata.durationSeconds - video.mediaStart;
-          videoDuration = sourceDuration > 0 ? sourceDuration : metadata.durationSeconds;
+        const probedMeta = videoMetadata[i2] ?? await extractMediaMetadata(videoPath);
+        const videoDuration = resolveSegmentDuration(
+          video.end - video.start,
+          video.mediaStart,
+          probedMeta
+        );
+        if (video.end - video.start !== videoDuration) {
           video.end = video.start + videoDuration;
         }
+        const cached2 = await tryCachedExtract(video, videoPath, videoDuration, i2);
+        if (cached2) return { result: cached2 };
         const result = await extractVideoFramesRange(
           videoPath,
           video.id,
@@ -27464,6 +27849,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       }
     })
   );
+  breakdown.extractMs = Date.now() - phase3Start;
   for (const item of results) {
     if ("error" in item && item.error) {
       errors.push(item.error);
@@ -27477,7 +27863,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     extracted,
     errors,
     totalFramesExtracted,
-    durationMs: Date.now() - startTime
+    durationMs: Date.now() - startTime,
+    phaseBreakdown: breakdown
   };
 }
 function getFrameAtTime(extracted, globalTime, videoStart) {
@@ -27507,6 +27894,8 @@ var init_videoFrameExtractor = __esm({
     init_urlDownloader();
     init_runFfmpeg();
     init_config2();
+    init_htmlTemplate();
+    init_extractionCache();
     FrameLookupTable = class {
       videos = /* @__PURE__ */ new Map();
       orderedVideos = [];
@@ -27590,7 +27979,8 @@ var init_videoFrameExtractor = __esm({
       }
       cleanup() {
         for (const video of this.videos.values()) {
-          if (existsSync20(video.extracted.outputDir)) {
+          if (video.extracted.ownedByLookup) continue;
+          if (existsSync21(video.extracted.outputDir)) {
             rmSync5(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -27605,23 +27995,23 @@ var init_videoFrameExtractor = __esm({
 // ../engine/src/services/videoFrameInjector.ts
 import { promises as fs } from "fs";
 function createFrameDataUriCache(cacheLimit) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
   function remember(framePath, dataUri) {
-    if (cache.has(framePath)) {
-      cache.delete(framePath);
+    if (cache2.has(framePath)) {
+      cache2.delete(framePath);
     }
-    cache.set(framePath, dataUri);
-    if (cache.size > cacheLimit) {
-      const oldestKey = cache.keys().next().value;
+    cache2.set(framePath, dataUri);
+    if (cache2.size > cacheLimit) {
+      const oldestKey = cache2.keys().next().value;
       if (oldestKey) {
-        cache.delete(oldestKey);
+        cache2.delete(oldestKey);
       }
     }
     return dataUri;
   }
   async function get(framePath) {
-    const cached2 = cache.get(framePath);
+    const cached2 = cache2.get(framePath);
     if (cached2) {
       remember(framePath, cached2);
       return cached2;
@@ -27898,11 +28288,11 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, rmSync as rmSync6 } from "fs";
-import { isAbsolute as isAbsolute3, join as join23, dirname as dirname8 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, rmSync as rmSync6 } from "fs";
+import { isAbsolute as isAbsolute3, join as join24, dirname as dirname8 } from "path";
 function parseAudioElements(html) {
   const elements = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const audioEls = document2.querySelectorAll("audio[id][src]");
   for (const el of audioEls) {
     const id = el.getAttribute("id");
@@ -27950,7 +28340,7 @@ function parseAudioElements(html) {
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync21(outputDir)) mkdirSync13(outputDir, { recursive: true });
+  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = ["-i", videoPath];
   if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
   if (options?.duration !== void 0) args.push("-t", String(options.duration));
@@ -27977,7 +28367,7 @@ async function extractAudioFromVideo(videoPath, outputPath, options, signal, con
 async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync21(outputDir)) mkdirSync13(outputDir, { recursive: true });
+  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -28013,7 +28403,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, sign
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync21(outputDir)) mkdirSync13(outputDir, { recursive: true });
+  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -28056,7 +28446,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     };
   }
   const outputDir = dirname8(outputPath);
-  if (!existsSync21(outputDir)) mkdirSync13(outputDir, { recursive: true });
+  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i2) => {
@@ -28117,7 +28507,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync21(workDir)) mkdirSync13(workDir, { recursive: true });
+  if (!existsSync22(workDir)) mkdirSync14(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -28127,8 +28517,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!isAbsolute3(srcPath) && !isHttpUrl(srcPath)) {
-          const fromCompiled = compiledDir ? join23(compiledDir, srcPath) : null;
-          srcPath = fromCompiled && existsSync21(fromCompiled) ? fromCompiled : join23(baseDir, srcPath);
+          const fromCompiled = compiledDir ? join24(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync22(fromCompiled) ? fromCompiled : join24(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -28140,7 +28530,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync21(srcPath)) {
+        if (!existsSync22(srcPath)) {
           errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
@@ -28151,7 +28541,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join23(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join24(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -28168,7 +28558,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join23(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join24(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -28216,14 +28606,15 @@ var init_audioMixer = __esm({
     init_urlDownloader();
     init_config2();
     init_runFfmpeg();
+    init_htmlTemplate();
   }
 });
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus2, freemem, totalmem as totalmem2 } from "os";
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readdirSync as readdirSync9 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readdirSync as readdirSync10 } from "fs";
 import { copyFile, rename } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
   const effectiveMaxWorkers = (() => {
     const concurrency = config?.concurrency ?? DEFAULT_CONFIG2.concurrency;
@@ -28266,7 +28657,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i2,
       startFrame,
       endFrame,
-      outputDir: join24(workDir, `worker-${i2}`)
+      outputDir: join25(workDir, `worker-${i2}`)
     });
   }
   return tasks;
@@ -28274,7 +28665,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
 async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCaptureHook, signal, onFrameCaptured, onFrameBuffer, config) {
   const startTime = Date.now();
   let framesCaptured = 0;
-  if (!existsSync22(task.outputDir)) mkdirSync14(task.outputDir, { recursive: true });
+  if (!existsSync23(task.outputDir)) mkdirSync15(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -28364,17 +28755,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync15(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync22(task.outputDir)) {
+    if (!existsSync23(task.outputDir)) {
       continue;
     }
-    const files = readdirSync9(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
+    const files = readdirSync10(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join24(task.outputDir, file);
-      const targetPath = join24(outputDir, file);
+      const sourcePath = join25(task.outputDir, file);
+      const targetPath = join25(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -28411,8 +28802,8 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync16, existsSync as existsSync23, statSync as statSync6 } from "fs";
-import { join as join25, extname as extname6 } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync24, statSync as statSync7 } from "fs";
+import { join as join26, extname as extname6 } from "path";
 function stripEmbeddedRuntimeScripts(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -28481,12 +28872,12 @@ function createFileServer(options) {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join25(compiledDir, relativePath) : null;
+    const compiledPath = compiledDir ? join26(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync23(compiledPath) && statSync6(compiledPath).isFile()
+      compiledPath && existsSync24(compiledPath) && statSync7(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join25(projectDir, relativePath);
-    if (!existsSync23(filePath) || !statSync6(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join26(projectDir, relativePath);
+    if (!existsSync24(filePath) || !statSync7(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname6(filePath).toLowerCase();
@@ -29764,8 +30155,8 @@ var init_shaderTransitions = __esm({
 });
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
+import { join as join27 } from "path";
 import { homedir as homedir6 } from "os";
 function linearToPQ(L2) {
   const Lp = Math.max(0, L2 * SDR_NITS / PQ_MAX_NITS);
@@ -29881,12 +30272,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join26(homedir6(), ".cache", "puppeteer", "chrome");
-  if (!existsSync24(baseDir)) return void 0;
-  const versions = readdirSync10(baseDir).sort().reverse();
+  const baseDir = join27(homedir6(), ".cache", "puppeteer", "chrome");
+  if (!existsSync25(baseDir)) return void 0;
+  const versions = readdirSync11(baseDir).sort().reverse();
   for (const version of versions) {
     const candidates = [
-      join26(
+      join27(
         baseDir,
         version,
         "chrome-mac-arm64",
@@ -29895,7 +30286,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join26(
+      join27(
         baseDir,
         version,
         "chrome-mac-x64",
@@ -29904,11 +30295,11 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join26(baseDir, version, "chrome-linux64", "chrome"),
-      join26(baseDir, version, "chrome-win64", "chrome.exe")
+      join27(baseDir, version, "chrome-linux64", "chrome"),
+      join27(baseDir, version, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
-      if (existsSync24(binary)) return binary;
+      if (existsSync25(binary)) return binary;
     }
   }
   return void 0;
@@ -30179,10 +30570,10 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync17, existsSync as existsSync25 } from "fs";
-import { join as join27, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync26 } from "fs";
+import { join as join28, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
 import { transformSync } from "esbuild";
-function parseHTMLContent(html) {
+function parseHTMLContent2(html) {
   const trimmed = html.trimStart().toLowerCase();
   if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html")) {
     return parseHTML(html).document;
@@ -30248,7 +30639,7 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute4(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync25(filePath)) return null;
+  if (!existsSync26(filePath)) return null;
   try {
     return readFileSync17(filePath, "utf-8");
   } catch {
@@ -30256,7 +30647,7 @@ function safeReadFile(filePath) {
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync25(filePath)) return null;
+  if (!existsSync26(filePath)) return null;
   try {
     return readFileSync17(filePath);
   } catch {
@@ -30449,8 +30840,8 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join27(projectDir, "index.html");
-  if (!existsSync25(indexPath)) throw new Error("index.html not found in project directory");
+  const indexPath = join28(projectDir, "index.html");
+  if (!existsSync26(indexPath)) throw new Error("index.html not found in project directory");
   const rawHtml = readFileSync17(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
@@ -30531,11 +30922,11 @@ async function bundleToSingleHtml(projectDir, options) {
       console.warn(`[Bundler] Composition file not found: ${src}`);
       continue;
     }
-    const compDoc = parseHTMLContent(compHtml);
+    const compDoc = parseHTMLContent2(compHtml);
     const compId = hostEl.getAttribute("data-composition-id");
     const contentRoot = compDoc.querySelector("template");
     const contentHtml = contentRoot ? contentRoot.innerHTML || "" : compDoc.body.innerHTML || "";
-    const contentDoc = parseHTMLContent(contentHtml);
+    const contentDoc = parseHTMLContent2(contentHtml);
     const innerRoot = compId ? contentDoc.querySelector(`[data-composition-id="${compId}"]`) : contentDoc.querySelector("[data-composition-id]");
     if (!contentRoot && compDoc.head) {
       for (const s2 of [...compDoc.head.querySelectorAll("style")]) {
@@ -30600,7 +30991,7 @@ async function bundleToSingleHtml(projectDir, options) {
     if (!host) continue;
     if (host.children.length > 0) continue;
     const templateHtml = templateEl.innerHTML || "";
-    const innerDoc = parseHTMLContent(templateHtml);
+    const innerDoc = parseHTMLContent2(templateHtml);
     const innerRoot = innerDoc.querySelector(`[data-composition-id="${compId}"]`);
     if (innerRoot) {
       for (const styleEl of [...innerRoot.querySelectorAll("style")]) {
@@ -30725,8 +31116,8 @@ var init_compiler = __esm({
 });
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync26, readFileSync as readFileSync18 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync27, readFileSync as readFileSync18 } from "fs";
 import { dirname as dirname9, resolve as resolve13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -30739,7 +31130,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync26(candidate)) {
+    if (existsSync27(candidate)) {
       return candidate;
     }
   }
@@ -30750,7 +31141,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync26(manifestPath)) {
+  if (!existsSync27(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
@@ -30764,11 +31155,11 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve13(dirname9(manifestPath), runtimeFileName);
-  if (!existsSync26(runtimePath)) {
+  if (!existsSync27(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync18(runtimePath, "utf8");
-  const runtimeSha = createHash2("sha256").update(runtimeSource, "utf8").digest("hex");
+  const runtimeSha = createHash3("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
       `[HyperframeRuntimeLoader] Runtime checksum mismatch. expected=${manifest.sha256} actual=${runtimeSha}`
@@ -30806,16 +31197,16 @@ 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 readFileSync19, existsSync as existsSync27, realpathSync, statSync as statSync7 } from "fs";
-import { join as join28, extname as extname7, resolve as resolve14, sep as sep3 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync28, realpathSync, statSync as statSync8 } from "fs";
+import { join as join29, extname as extname7, resolve as resolve14, sep as sep3 } from "path";
 function isPathInside(child, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve14;
   const separator = pathModule?.sep ?? sep3;
   const resolvedChild = resolveFn(child);
   const resolvedParent = resolveFn(parent);
-  const normalizedChild = resolveSymlinks && existsSync27(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
-  const normalizedParent = resolveSymlinks && existsSync27(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
+  const normalizedChild = resolveSymlinks && existsSync28(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync28(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -30904,14 +31295,14 @@ function createFileServer2(options) {
     const relativePath = requestPath.replace(/^\//, "");
     let filePath = null;
     if (compiledDir) {
-      const candidate = join28(compiledDir, relativePath);
-      if (existsSync27(candidate) && isPathInside(candidate, compiledDir, { resolveSymlinks: true }) && statSync7(candidate).isFile()) {
+      const candidate = join29(compiledDir, relativePath);
+      if (existsSync28(candidate) && isPathInside(candidate, compiledDir, { resolveSymlinks: true }) && statSync8(candidate).isFile()) {
         filePath = candidate;
       }
     }
     if (!filePath) {
-      const candidate = join28(projectDir, relativePath);
-      if (existsSync27(candidate) && isPathInside(candidate, projectDir, { resolveSymlinks: true }) && statSync7(candidate).isFile()) {
+      const candidate = join29(projectDir, relativePath);
+      if (existsSync28(candidate) && isPathInside(candidate, projectDir, { resolveSymlinks: true }) && statSync8(candidate).isFile()) {
         filePath = candidate;
       }
     }
@@ -31285,7 +31676,7 @@ var init_ffprobe2 = __esm({
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve15, basename as basename2, join as join29, relative as relative2, isAbsolute as isAbsolute5 } from "path";
+import { resolve as resolve15, basename as basename2, join as join30, relative as relative2, isAbsolute as isAbsolute5 } from "path";
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve15(childPath);
   const absParent = resolve15(parentPath);
@@ -31306,7 +31697,7 @@ function toExternalAssetKey(absPath) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = resolve15(projectDir);
   const projectName = basename2(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join29(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join30(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve15(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -31379,9 +31770,9 @@ var init_fontData_generated = __esm({
 });
 
 // ../producer/src/services/deterministicFonts.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync15, readFileSync as readFileSync20, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function normalizeFamilyName(family) {
   return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
 }
@@ -31492,14 +31883,14 @@ function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function fontCacheDir(slug) {
-  const dir = join30(GOOGLE_FONTS_CACHE_DIR, slug);
-  if (!existsSync28(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  const dir = join31(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync29(dir)) {
+    mkdirSync16(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join30(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join31(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -31525,12 +31916,12 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match[3] || "";
     if (!woff2Url) continue;
     const cachePath2 = cachedWoff2Path(slug, weight, style);
-    if (!existsSync28(cachePath2)) {
+    if (!existsSync29(cachePath2)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
         const buffer = Buffer.from(await fontRes.arrayBuffer());
-        writeFileSync10(cachePath2, buffer);
+        writeFileSync11(cachePath2, buffer);
       } catch {
         continue;
       }
@@ -31711,14 +32102,14 @@ var init_deterministicFonts = __esm({
       poppins: "poppins",
       "segoe ui": "roboto"
     };
-    GOOGLE_FONTS_CACHE_DIR = join30(homedir7(), ".cache", "hyperframes", "fonts");
+    GOOGLE_FONTS_CACHE_DIR = join31(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 readFileSync21, existsSync as existsSync29, mkdirSync as mkdirSync16 } from "fs";
-import { join as join31, dirname as dirname10, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync21, existsSync as existsSync30, mkdirSync as mkdirSync17 } from "fs";
+import { join as join32, dirname as dirname10, resolve as resolve16 } from "path";
 import postcss from "postcss";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -31769,16 +32160,16 @@ function detectRenderModeHints(html) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync29(downloadDir)) mkdirSync16(downloadDir, { recursive: true });
+    if (!existsSync30(downloadDir)) mkdirSync17(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join31(baseDir, filePath);
+    filePath = join32(baseDir, filePath);
   }
-  if (!existsSync29(filePath)) {
+  if (!existsSync30(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractMediaMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -31847,7 +32238,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync29(filePath)) {
+    if (!existsSync30(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync21(filePath, "utf-8");
@@ -32057,7 +32448,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve16(projectDir, srcPath);
-      if (existsSync29(filePath)) {
+      if (existsSync30(filePath)) {
         compHtml = readFileSync21(filePath, "utf-8");
       }
     }
@@ -32285,7 +32676,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync29(absPath)) return null;
+    if (!existsSync30(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -32481,9 +32872,10 @@ async function recompileWithResolutions(compiled, resolutions, projectDir, downl
   const mainVideos = parseVideoElements(html);
   const mainAudios = parseAudioElements(html);
   const mainImages = parseImageElements(html);
-  const videos = dedupeElementsById([...mainVideos, ...subVideos]);
-  const audios = dedupeElementsById([...mainAudios, ...subAudios]);
-  const images = dedupeElementsById([...mainImages, ...subImages]);
+  const hasSubMedia = subVideos.length > 0 || subAudios.length > 0 || subImages.length > 0;
+  const videos = hasSubMedia ? dedupeElementsById([...mainVideos, ...subVideos]) : compiled.videos;
+  const audios = hasSubMedia ? dedupeElementsById([...mainAudios, ...subAudios]) : compiled.audios;
+  const images = hasSubMedia ? dedupeElementsById([...mainImages, ...subImages]) : compiled.images;
   const remaining = compiled.unresolvedCompositions.filter(
     (c2) => !resolutions.some((r2) => r2.id === c2.id)
   );
@@ -32560,18 +32952,124 @@ var init_logger = __esm({
   }
 });
 
+// ../producer/src/services/frameDirCache.ts
+import { readdirSync as readdirSync12 } from "fs";
+function getMaxFrameIndex(frameDir) {
+  const cached2 = cache.get(frameDir);
+  if (cached2 !== void 0) {
+    cache.delete(frameDir);
+    cache.set(frameDir, cached2);
+    return cached2;
+  }
+  let max = 0;
+  try {
+    for (const name of readdirSync12(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 {
+  }
+  if (cache.size >= MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(frameDir, max);
+  return max;
+}
+function clearMaxFrameIndex(frameDir) {
+  return cache.delete(frameDir);
+}
+var cache, FRAME_FILENAME_RE, MAX_ENTRIES;
+var init_frameDirCache = __esm({
+  "../producer/src/services/frameDirCache.ts"() {
+    "use strict";
+    cache = /* @__PURE__ */ new Map();
+    FRAME_FILENAME_RE = /^frame_(\d+)\.png$/;
+    MAX_ENTRIES = 1e3;
+  }
+});
+
+// ../producer/src/services/hdrImageTransferCache.ts
+function createHdrImageTransferCache(options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+    throw new Error(
+      `createHdrImageTransferCache: maxBytes must be a non-negative integer, got ${String(maxBytes)}`
+    );
+  }
+  const entries2 = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  function makeKey(imageId, targetTransfer) {
+    return `${imageId}|${targetTransfer}`;
+  }
+  function evictUntilRoom(needed) {
+    while (totalBytes + needed > maxBytes && entries2.size > 0) {
+      const lruKey = entries2.keys().next().value;
+      if (lruKey === void 0) break;
+      const evicted = entries2.get(lruKey);
+      if (evicted) totalBytes -= evicted.byteLength;
+      entries2.delete(lruKey);
+    }
+  }
+  return {
+    getConverted(imageId, sourceTransfer, targetTransfer, source) {
+      if (sourceTransfer === targetTransfer) {
+        return source;
+      }
+      if (maxBytes === 0) {
+        const fresh = Buffer.from(source);
+        convertTransfer(fresh, sourceTransfer, targetTransfer);
+        return fresh;
+      }
+      const key2 = makeKey(imageId, targetTransfer);
+      const existing = entries2.get(key2);
+      if (existing) {
+        entries2.delete(key2);
+        entries2.set(key2, existing);
+        return existing;
+      }
+      const converted = Buffer.from(source);
+      convertTransfer(converted, sourceTransfer, targetTransfer);
+      if (converted.byteLength > maxBytes) {
+        return converted;
+      }
+      evictUntilRoom(converted.byteLength);
+      entries2.set(key2, converted);
+      totalBytes += converted.byteLength;
+      return converted;
+    },
+    size() {
+      return entries2.size;
+    },
+    bytesUsed() {
+      return totalBytes;
+    }
+  };
+}
+var DEFAULT_MAX_BYTES;
+var init_hdrImageTransferCache = __esm({
+  "../producer/src/services/hdrImageTransferCache.ts"() {
+    "use strict";
+    init_src2();
+    DEFAULT_MAX_BYTES = 200 * 1024 * 1024;
+  }
+});
+
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync18,
   rmSync as rmSync7,
   readFileSync as readFileSync22,
-  readdirSync as readdirSync11,
-  writeFileSync as writeFileSync11,
+  readdirSync as readdirSync13,
+  statSync as statSync9,
+  writeFileSync as writeFileSync12,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join32, dirname as dirname11, resolve as resolve17 } from "path";
+import { join as join33, dirname as dirname11, resolve as resolve17 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -32584,21 +33082,32 @@ async function safeCleanup(label2, fn, log2 = 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;
+function sampleDirectoryBytes(dir) {
+  let total = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries2 = [];
+    try {
+      entries2 = readdirSync13(current);
+    } catch {
+      continue;
+    }
+    for (const name of entries2) {
+      const full = join33(current, name);
+      try {
+        const st2 = statSync9(full);
+        if (st2.isDirectory()) {
+          stack.push(full);
+        } else if (st2.isFile()) {
+          total += st2.size;
+        }
+      } catch {
+      }
     }
-  } catch {
   }
-  frameDirMaxIndexCache.set(frameDir, max);
-  return max;
+  return total;
 }
 function countNonZeroAlpha(rgba) {
   let n = 0;
@@ -32615,6 +33124,9 @@ function countNonZeroRgb48(buf) {
   }
   return n;
 }
+function projectBrowserEndToCompositionTimeline(existingStart, browserStart, browserEnd) {
+  return browserEnd + (existingStart - browserStart);
+}
 function updateJobStatus(job, status, stage, progress, onProgress) {
   job.status = status;
   job.currentStage = stage;
@@ -32658,21 +33170,21 @@ function installDebugLogger(logPath, log2 = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join32(workDir, "compiled");
-  mkdirSync17(compileDir, { recursive: true });
-  writeFileSync11(join32(compileDir, "index.html"), compiled.html, "utf-8");
+  const compileDir = join33(workDir, "compiled");
+  mkdirSync18(compileDir, { recursive: true });
+  writeFileSync12(join33(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join32(compileDir, srcPath);
-    mkdirSync17(dirname11(outPath), { recursive: true });
-    writeFileSync11(outPath, html, "utf-8");
+    const outPath = join33(compileDir, srcPath);
+    mkdirSync18(dirname11(outPath), { recursive: true });
+    writeFileSync12(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve17(join32(compileDir, relativePath));
+    const outPath = resolve17(join33(compileDir, relativePath));
     if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync17(dirname11(outPath), { recursive: true });
+    mkdirSync18(dirname11(outPath), { recursive: true });
     copyFileSync2(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -32697,7 +33209,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       subCompositions: Array.from(compiled.subCompositions.keys()),
       renderModeHints: compiled.renderModeHints
     };
-    writeFileSync11(join32(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync12(join33(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(cfg, compiled, log2 = defaultLogger) {
@@ -32718,8 +33230,8 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrFrameDirs, hdrStartTimes, w
   if (videoFrameIndex < 1) return;
   const maxIndex = getMaxFrameIndex(frameDir);
   const effectiveIndex = maxIndex > 0 ? Math.min(videoFrameIndex, maxIndex) : videoFrameIndex;
-  const framePath = join32(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
-  if (!existsSync30(framePath)) {
+  const framePath = join33(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
+  if (!existsSync31(framePath)) {
     return;
   }
   try {
@@ -32765,17 +33277,13 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrFrameDirs, hdrStartTimes, w
     }
   }
 }
-function blitHdrImageLayer(canvas, el, hdrImageBuffers, width, height, log2, sourceTransfer, targetTransfer) {
+function blitHdrImageLayer(canvas, el, hdrImageBuffers, hdrImageTransferCache, width, height, log2, sourceTransfer, targetTransfer) {
   const buf = hdrImageBuffers.get(el.id);
   if (!buf) {
     return;
   }
   try {
-    let hdrRgb = buf.data;
-    if (sourceTransfer && targetTransfer && sourceTransfer !== targetTransfer) {
-      hdrRgb = Buffer.from(buf.data);
-      convertTransfer(hdrRgb, sourceTransfer, targetTransfer);
-    }
+    const hdrRgb = sourceTransfer && targetTransfer ? hdrImageTransferCache.getConverted(el.id, sourceTransfer, targetTransfer, buf.data) : buf.data;
     const viewportMatrix = parseTransformMatrix(el.transform);
     const br = el.borderRadius;
     const hasBorderRadius = br[0] > 0 || br[1] > 0 || br[2] > 0 || br[3] > 0;
@@ -32825,6 +33333,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
     effectiveHdr,
     nativeHdrImageIds,
     hdrImageBuffers,
+    hdrImageTransferCache,
     hdrFrameDirs,
     hdrVideoStartTimes,
     imageTransfers,
@@ -32864,6 +33373,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           canvas,
           layer.element,
           hdrImageBuffers,
+          hdrImageTransferCache,
           width,
           height,
           log2,
@@ -32904,7 +33414,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
           const localTime = time - startTime;
           const frameNum = Math.floor(localTime * fps) + 1;
-          const expectedFrame = frameDir ? join32(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
+          const expectedFrame = frameDir ? join33(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
           log2.info("[diag] hdr layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -32916,7 +33426,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
             localTime: localTime.toFixed(3),
             hdrFrameNum: frameNum,
             expectedFrame,
-            expectedFrameExists: expectedFrame ? existsSync30(expectedFrame) : false
+            expectedFrameExists: expectedFrame ? existsSync31(expectedFrame) : false
           });
         }
       }
@@ -32941,8 +33451,8 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
         if (shouldLog && debugDumpDir) {
           const after2 = countNonZeroRgb48(canvas);
           const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-          const dumpPath = join32(debugDumpDir, dumpName);
-          writeFileSync11(dumpPath, domPng);
+          const dumpPath = join33(debugDumpDir, dumpName);
+          writeFileSync12(dumpPath, domPng);
           log2.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -33015,8 +33525,8 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
   const moduleDir = dirname11(fileURLToPath3(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve17(process.env.PRODUCER_RENDERS_DIR, "..") : resolve17(moduleDir, "../..");
-  const debugDir = join32(producerRoot, ".debug");
-  const workDir = job.config.debug ? join32(debugDir, job.id) : join32(dirname11(outputPath), `work-${job.id}`);
+  const debugDir = join33(producerRoot, ".debug");
+  const workDir = job.config.debug ? join33(debugDir, job.id) : join33(dirname11(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log2 = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -33028,7 +33538,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     videoExtractionFailures: 0,
     imageDecodeFailures: 0
   };
-  const perfOutputPath = join32(workDir, "perf-summary.json");
+  const perfOutputPath = join33(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -33061,22 +33571,22 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync30(workDir)) mkdirSync17(workDir, { recursive: true });
+    if (!existsSync31(workDir)) mkdirSync18(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join32(workDir, "render.log");
+      const logPath = join33(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log2);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join32(projectDir, entryFile);
-    if (!existsSync30(htmlPath)) {
+    let htmlPath = join33(projectDir, entryFile);
+    if (!existsSync31(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync22(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join32(workDir, "standalone-entry.html");
-      const projectIndexPath = join32(projectDir, "index.html");
-      if (!existsSync30(projectIndexPath)) {
+      const wrapperPath = join33(workDir, "standalone-entry.html");
+      const projectIndexPath = join33(projectDir, "index.html");
+      if (!existsSync31(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -33090,7 +33600,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync11(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync12(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log2.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -33099,7 +33609,7 @@ 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, join32(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join33(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     applyRenderModeHints(cfg, compiled, log2);
@@ -33131,7 +33641,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join32(workDir, "compiled"),
+        compiledDir: join33(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
@@ -33145,7 +33655,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join32(workDir, "probe"),
+        join33(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -33177,7 +33687,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join32(workDir, "downloads")
+            join33(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -33204,10 +33714,15 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 1e-4)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end
+                );
+                if (projectedEnd > 0 && (existing.end <= 0 || Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)) {
+                  existing.end = projectedEnd;
                 }
-                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > 1e-4)) {
+                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                   existing.mediaStart = el.mediaStart;
                 }
                 if (el.hasAudio && !existing.hasAudio) {
@@ -33232,13 +33747,18 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 1e-4)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end
+                );
+                if (projectedEnd > 0 && (existing.end <= 0 || Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)) {
+                  existing.end = projectedEnd;
                 }
-                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > 1e-4)) {
+                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                   existing.mediaStart = el.mediaStart;
                 }
-                if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > 1e-4) {
+                if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON) {
                   existing.volume = el.volume;
                 }
               }
@@ -33317,7 +33837,7 @@ 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 = join32(workDir, "compiled");
+    const compiledDir = join33(workDir, "compiled");
     let extractionResult = null;
     const nativeHdrVideoIds = /* @__PURE__ */ new Set();
     const videoTransfers = /* @__PURE__ */ new Map();
@@ -33326,10 +33846,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.videos.map(async (v) => {
           let videoPath = v.src;
           if (!videoPath.startsWith("/")) {
-            const fromCompiled = existsSync30(join32(compiledDir, videoPath)) ? join32(compiledDir, videoPath) : join32(projectDir, videoPath);
+            const fromCompiled = existsSync31(join33(compiledDir, videoPath)) ? join33(compiledDir, videoPath) : join33(projectDir, videoPath);
             videoPath = fromCompiled;
           }
-          if (!existsSync30(videoPath)) return;
+          if (!existsSync31(videoPath)) return;
           const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
@@ -33347,10 +33867,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.images.map(async (img) => {
           let imgPath = img.src;
           if (!imgPath.startsWith("/")) {
-            const fromCompiled = existsSync30(join32(compiledDir, imgPath)) ? join32(compiledDir, imgPath) : join32(projectDir, imgPath);
+            const fromCompiled = existsSync31(join33(compiledDir, imgPath)) ? join33(compiledDir, imgPath) : join33(projectDir, imgPath);
             imgPath = fromCompiled;
           }
-          if (!existsSync30(imgPath)) return null;
+          if (!existsSync31(imgPath)) return null;
           const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
@@ -33366,9 +33886,9 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join32(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join33(workDir, "video-frames") },
         abortSignal,
-        void 0,
+        { extractCacheDir: cfg.extractCacheDir },
         compiledDir
       );
       assertNotAborted();
@@ -33424,13 +33944,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join32(workDir, "audio.aac");
+    const audioOutputPath = join33(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join32(workDir, "audio-work"),
+        join33(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -33448,14 +33968,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join32(workDir, "compiled"),
+        compiledDir: join33(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join32(workDir, "captured-frames");
-    if (!existsSync30(framesDir)) mkdirSync17(framesDir, { recursive: true });
+    const framesDir = join33(workDir, "captured-frames");
+    if (!existsSync31(framesDir)) mkdirSync18(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -33470,7 +33990,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const workerCount = calculateOptimalWorkers(totalFrames, job.config.workers, cfg);
     const FORMAT_EXT2 = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
     const videoExt = FORMAT_EXT2[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join32(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join33(workDir, `video-only${videoExt}`);
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
@@ -33492,8 +34012,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         if (!hdrVideoIds.includes(v.id)) continue;
         let srcPath = v.src;
         if (!srcPath.startsWith("/")) {
-          const fromCompiled = join32(compiledDir, srcPath);
-          srcPath = existsSync30(fromCompiled) ? fromCompiled : join32(projectDir, srcPath);
+          const fromCompiled = join33(compiledDir, srcPath);
+          srcPath = existsSync31(fromCompiled) ? fromCompiled : join33(projectDir, srcPath);
         }
         hdrVideoSrcPaths.set(v.id, srcPath);
       }
@@ -33623,8 +34143,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         for (const [videoId, srcPath] of hdrVideoSrcPaths) {
           const video = composition.videos.find((v) => v.id === videoId);
           if (!video) continue;
-          const frameDir = join32(framesDir, `hdr_${videoId}`);
-          mkdirSync17(frameDir, { recursive: true });
+          const frameDir = join33(framesDir, `hdr_${videoId}`);
+          mkdirSync18(frameDir, { recursive: true });
           const duration = video.end - video.start;
           const dims = hdrExtractionDims.get(videoId) ?? { width, height };
           const ffmpegArgs = [
@@ -33643,7 +34163,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             "-c:v",
             "png",
             "-y",
-            join32(frameDir, "frame_%04d.png")
+            join33(frameDir, "frame_%04d.png")
           ];
           const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
           if (!result.success) {
@@ -33711,15 +34231,19 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
           const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-          const debugDumpDir = debugDumpEnabled ? join32(framesDir, "debug-composite") : null;
-          if (debugDumpDir && !existsSync30(debugDumpDir)) {
-            mkdirSync17(debugDumpDir, { recursive: true });
+          const debugDumpDir = debugDumpEnabled ? join33(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync31(debugDumpDir)) {
+            mkdirSync18(debugDumpDir, { recursive: true });
           }
           if (!effectiveHdr) {
             throw new Error(
               "Internal: HDR render path entered without effectiveHdr \u2014 this is a bug."
             );
           }
+          const hdrCacheMaxBytes = process.env.HDR_TRANSFER_CACHE_MAX_BYTES ? Number(process.env.HDR_TRANSFER_CACHE_MAX_BYTES) : void 0;
+          const hdrImageTransferCache = createHdrImageTransferCache(
+            hdrCacheMaxBytes !== void 0 ? { maxBytes: hdrCacheMaxBytes } : {}
+          );
           const hdrCompositeCtx = {
             log: log2,
             domSession,
@@ -33730,6 +34254,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             effectiveHdr,
             nativeHdrImageIds,
             hdrImageBuffers,
+            hdrImageTransferCache,
             hdrFrameDirs,
             hdrVideoStartTimes,
             imageTransfers,
@@ -33790,6 +34315,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                       sceneBuf,
                       el,
                       hdrImageBuffers,
+                      hdrImageTransferCache,
                       width,
                       height,
                       log2,
@@ -33853,11 +34379,11 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 i2
               );
               if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-                const previewPath = join32(
+                const previewPath = join33(
                   debugDumpDir,
                   `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
                 );
-                writeFileSync11(previewPath, normalCanvas);
+                writeFileSync12(previewPath, normalCanvas);
               }
               hdrEncoder.writeFrame(normalCanvas);
             }
@@ -33877,7 +34403,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                           error: err instanceof Error ? err.message : String(err)
                         });
                       }
-                      frameDirMaxIndexCache.delete(frameDir);
+                      clearMaxFrameIndex(frameDir);
                       hdrFrameDirs.delete(videoId);
                     }
                     cleanedUpVideos.add(videoId);
@@ -33928,7 +34454,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           });
         }
         for (const frameDir of hdrFrameDirs.values()) {
-          frameDirMaxIndexCache.delete(frameDir);
+          clearMaxFrameIndex(frameDir);
         }
         hdrFrameDirs.clear();
       }
@@ -34200,6 +34726,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     updateJobStatus(job, "complete", "Render complete", 100, onProgress);
     const totalElapsed = Date.now() - pipelineStart;
     sampleMemory();
+    const tmpPeakBytes = existsSync31(workDir) ? sampleDirectoryBytes(workDir) : 0;
     const perfSummary = {
       renderId: job.id,
       totalElapsedMs: totalElapsed,
@@ -34214,6 +34741,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       videoCount: composition.videos.length,
       audioCount: composition.audios.length,
       stages: perfStages,
+      videoExtractBreakdown: extractionResult?.phaseBreakdown,
+      tmpPeakBytes,
       hdrDiagnostics: hdrDiagnostics.videoExtractionFailures > 0 || hdrDiagnostics.imageDecodeFailures > 0 ? { ...hdrDiagnostics } : void 0,
       captureAvgMs: totalFrames > 0 ? Math.round((perfStages.captureMs ?? 0) / totalFrames) : void 0,
       peakRssMb: Math.round(peakRssBytes / (1024 * 1024)),
@@ -34222,7 +34751,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync11(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync12(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log2.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -34231,8 +34760,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync30(outputPath)) {
-        const debugOutput = join32(workDir, `output${videoExt}`);
+      if (existsSync31(outputPath)) {
+        const debugOutput = join33(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else if (process.env.KEEP_TEMP === "1") {
@@ -34318,7 +34847,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync30(workDir)) rmSync7(workDir, { recursive: true, force: true });
+          if (existsSync31(workDir)) rmSync7(workDir, { recursive: true, force: true });
         },
         log2
       );
@@ -34329,7 +34858,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     clearInterval(memSamplerInterval);
   }
 }
-var frameDirMaxIndexCache, FRAME_FILENAME_RE, RenderCancelledError;
+var RenderCancelledError, BROWSER_MEDIA_EPSILON;
 var init_renderOrchestrator = __esm({
   "../producer/src/services/renderOrchestrator.ts"() {
     "use strict";
@@ -34339,8 +34868,8 @@ var init_renderOrchestrator = __esm({
     init_htmlCompiler2();
     init_logger();
     init_paths();
-    frameDirMaxIndexCache = /* @__PURE__ */ new Map();
-    FRAME_FILENAME_RE = /^frame_(\d+)\.png$/;
+    init_frameDirCache();
+    init_hdrImageTransferCache();
     RenderCancelledError = class extends Error {
       reason;
       constructor(message = "render_cancelled", reason = "aborted") {
@@ -34349,6 +34878,7 @@ var init_renderOrchestrator = __esm({
         this.reason = reason;
       }
     };
+    BROWSER_MEDIA_EPSILON = 1e-4;
   }
 });
 
@@ -34377,8 +34907,8 @@ var init_config3 = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync31, readFileSync as readFileSync23, statSync as statSync8 } from "fs";
-import { resolve as resolve18, join as join33 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync23, statSync as statSync10 } from "fs";
+import { resolve as resolve18, join as join34 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -34406,7 +34936,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve18(projectDir);
-  if (!existsSync31(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  if (!existsSync32(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -34417,7 +34947,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync31(absoluteEntryPath) && statSync8(absoluteEntryPath).isFile()) {
+    if (existsSync32(absoluteEntryPath) && statSync10(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync23(absoluteEntryPath, "utf-8"),
@@ -34426,7 +34956,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join33(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -34514,15 +35044,15 @@ var init_semaphore = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync18,
-  statSync as statSync9,
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync19,
+  statSync as statSync11,
   mkdtempSync as mkdtempSync2,
-  writeFileSync as writeFileSync12,
+  writeFileSync as writeFileSync13,
   rmSync as rmSync8,
   createReadStream
 } from "fs";
-import { resolve as resolve19, dirname as dirname12, join as join34 } from "path";
+import { resolve as resolve19, dirname as dirname12, join as join35 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -34545,11 +35075,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve19(projectDir);
-    if (!existsSync32(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
+    if (!existsSync33(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync32(resolve19(absProjectDir, entry))) {
+    if (!existsSync33(resolve19(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -34574,8 +35104,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync2(join34(tempRoot, "producer-project-"));
-  writeFileSync12(join34(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync2(join35(tempRoot, "producer-project-"));
+  writeFileSync13(join35(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -34698,7 +35228,7 @@ function createRenderHandlers(options = {}) {
       log2
     );
     const outputDir = dirname12(absoluteOutputPath);
-    if (!existsSync32(outputDir)) mkdirSync18(outputDir, { recursive: true });
+    if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log2.info("render started", {
       requestId,
@@ -34725,7 +35255,7 @@ function createRenderHandlers(options = {}) {
           log2.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync32(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
+      const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -34809,7 +35339,7 @@ function createRenderHandlers(options = {}) {
         log2
       );
       const outputDir = dirname12(absoluteOutputPath);
-      if (!existsSync32(outputDir)) mkdirSync18(outputDir, { recursive: true });
+      if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
       log2.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -34854,7 +35384,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync32(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
+        const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log2.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -34913,11 +35443,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync32(artifact.path)) {
+    if (!existsSync33(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync9(artifact.path);
+    const stats = statSync11(artifact.path);
     return new Response(createReadStream(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -35050,20 +35580,20 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { existsSync as existsSync33, readFileSync as readFileSync24, writeFileSync as writeFileSync13, statSync as statSync10 } from "fs";
-import { resolve as resolve20, join as join35, basename as basename3 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync24, writeFileSync as writeFileSync14, statSync as statSync12 } from "fs";
+import { resolve as resolve20, join as join36, basename as basename3 } from "path";
 function resolveDistDir() {
   const builtPath = resolve20(__dirname, "studio");
-  if (existsSync33(resolve20(builtPath, "index.html"))) return builtPath;
+  if (existsSync34(resolve20(builtPath, "index.html"))) return builtPath;
   const devPath = resolve20(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync33(resolve20(devPath, "index.html"))) return devPath;
+  if (existsSync34(resolve20(devPath, "index.html"))) return devPath;
   return builtPath;
 }
 function resolveRuntimePath() {
   const builtPath = resolve20(__dirname, "hyperframe-runtime.js");
-  if (existsSync33(builtPath)) return builtPath;
+  if (existsSync34(builtPath)) return builtPath;
   const iifePath = resolve20(__dirname, "hyperframe.runtime.iife.js");
-  if (existsSync33(iifePath)) return iifePath;
+  if (existsSync34(iifePath)) return iifePath;
   const devPath = resolve20(
     __dirname,
     "..",
@@ -35073,7 +35603,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync33(devPath)) return devPath;
+  if (existsSync34(devPath)) return devPath;
   return builtPath;
 }
 async function getThumbnailBrowser() {
@@ -35135,7 +35665,7 @@ function createStudioServer(options) {
       return lintHyperframeHtml2(html, opts);
     },
     runtimeUrl: "/api/runtime.js",
-    rendersDir: () => join35(projectDir, "renders"),
+    rendersDir: () => join36(projectDir, "renders"),
     startRender(opts) {
       const state = {
         id: opts.jobId,
@@ -35168,7 +35698,7 @@ function createStudioServer(options) {
           state.status = "complete";
           state.progress = 100;
           const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-          writeFileSync13(
+          writeFileSync14(
             metaPath,
             JSON.stringify({ status: "complete", durationMs: Date.now() - startTime })
           );
@@ -35177,7 +35707,7 @@ function createStudioServer(options) {
           state.error = err instanceof Error ? err.message : String(err);
           try {
             const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-            writeFileSync13(metaPath, JSON.stringify({ status: "failed" }));
+            writeFileSync14(metaPath, JSON.stringify({ status: "failed" }));
           } catch {
           }
         }
@@ -35250,7 +35780,7 @@ function createStudioServer(options) {
   });
   app.get("/api/runtime.js", (c2) => {
     const serve4 = async () => {
-      const runtimeSource = await loadRuntimeSource() ?? (existsSync33(runtimePath) ? readFileSync24(runtimePath, "utf-8") : null);
+      const runtimeSource = await loadRuntimeSource() ?? (existsSync34(runtimePath) ? readFileSync24(runtimePath, "utf-8") : null);
       if (!runtimeSource) return c2.text("runtime not available", 404);
       return c2.body(runtimeSource, 200, {
         "Content-Type": "text/javascript",
@@ -35286,7 +35816,7 @@ function createStudioServer(options) {
   });
   app.get("/assets/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync33(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync34(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync24(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -35294,7 +35824,7 @@ function createStudioServer(options) {
   });
   app.get("/icons/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync33(filePath) || !statSync10(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync34(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync24(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -35302,7 +35832,7 @@ function createStudioServer(options) {
   });
   app.get("*", (c2) => {
     const indexPath = resolve20(studioDir, "index.html");
-    if (!existsSync33(indexPath)) {
+    if (!existsSync34(indexPath)) {
       return c2.text("Studio not found. Rebuild with: pnpm run build", 500);
     }
     return c2.html(readFileSync24(indexPath, "utf-8"));
@@ -35329,20 +35859,20 @@ __export(preview_exports, {
   examples: () => examples
 });
 import { spawn as spawn8 } from "child_process";
-import { existsSync as existsSync34, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync19 } from "fs";
-import { resolve as resolve21, dirname as dirname13, basename as basename4, join as join36 } from "path";
+import { existsSync as existsSync35, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync20 } from "fs";
+import { resolve as resolve21, dirname as dirname13, basename as basename4, join as join37 } 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 = resolve21(dirname13(thisFile), "..", "..", "..", "..");
-  const projectsDir = join36(repoRoot, "packages", "studio", "data", "projects");
+  const projectsDir = join37(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename4(dir);
-  const symlinkPath = join36(projectsDir, pName);
-  mkdirSync19(projectsDir, { recursive: true });
+  const symlinkPath = join37(projectsDir, pName);
+  mkdirSync20(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync34(symlinkPath)) {
+    if (existsSync35(symlinkPath)) {
       try {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
@@ -35354,7 +35884,7 @@ async function runDevMode(dir, projectName) {
       } catch {
       }
     }
-    if (!existsSync34(symlinkPath)) {
+    if (!existsSync35(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -35362,7 +35892,7 @@ async function runDevMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview"));
   const s2 = be();
   s2.start("Starting studio...");
-  const studioPkgDir = join36(repoRoot, "packages", "studio");
+  const studioPkgDir = join37(repoRoot, "packages", "studio");
   const child = spawn8("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -35396,7 +35926,7 @@ async function runDevMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync34(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -35407,7 +35937,7 @@ async function runDevMode(dir, projectName) {
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join36(dir, "package.json"));
+    const req = createRequire(join37(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -35415,20 +35945,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir, projectName) {
-  const req = createRequire(join36(dir, "package.json"));
+  const req = createRequire(join37(dir, "package.json"));
   const studioPkgPath = dirname13(req.resolve("@hyperframes/studio/package.json"));
   const pName = projectName ?? basename4(dir);
-  const projectsDir = join36(studioPkgPath, "data", "projects");
-  const symlinkPath = join36(projectsDir, pName);
-  mkdirSync19(projectsDir, { recursive: true });
+  const projectsDir = join37(studioPkgPath, "data", "projects");
+  const symlinkPath = join37(projectsDir, pName);
+  mkdirSync20(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync34(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync35(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve21(readlinkSync(symlinkPath)) !== resolve21(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
-    if (!existsSync34(symlinkPath)) {
+    if (!existsSync35(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -35467,7 +35997,7 @@ async function runLocalStudioMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync34(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -35607,8 +36137,8 @@ var init_preview2 = __esm({
         const dir = resolve21(rawArg ?? ".");
         const isImplicitCwd = !rawArg || rawArg === "." || rawArg === "./";
         const projectName = isImplicitCwd ? basename4(process.env.PWD ?? dir) : basename4(dir);
-        const indexPath = join36(dir, "index.html");
-        if (existsSync34(indexPath)) {
+        const indexPath = join37(dir, "index.html");
+        if (existsSync35(indexPath)) {
           const project = { dir, name: projectName, indexPath };
           const lintResult = lintProject(project);
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
@@ -35637,15 +36167,15 @@ __export(init_exports, {
   examples: () => examples2
 });
 import {
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync21,
   copyFileSync as copyFileSync3,
   cpSync,
-  writeFileSync as writeFileSync14,
+  writeFileSync as writeFileSync15,
   readFileSync as readFileSync25,
-  readdirSync as readdirSync12
+  readdirSync as readdirSync14
 } from "fs";
-import { resolve as resolve22, basename as basename5, join as join37, dirname as dirname14 } from "path";
+import { resolve as resolve22, basename as basename5, join as join38, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { execFileSync as execFileSync4, spawn as spawn9 } from "child_process";
 function probeVideo(filePath) {
@@ -35717,7 +36247,7 @@ function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname14(fileURLToPath5(import.meta.url));
   const devPath = resolve22(base, ...devSegments);
   const builtPath = resolve22(base, ...builtSegments);
-  return existsSync35(devPath) ? devPath : builtPath;
+  return existsSync36(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -35726,7 +36256,7 @@ function getSharedTemplateDir() {
   return resolveAssetDir(["..", "templates", "_shared"], ["templates", "_shared"]);
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync12(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join37(e2.parentPath ?? e2.path, e2.name));
+  const htmlFiles = readdirSync14(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join38(e2.parentPath ?? e2.path, e2.name));
   for (const file of htmlFiles) {
     let content = readFileSync25(file, "utf-8");
     if (videoFilename) {
@@ -35739,7 +36269,7 @@ function patchVideoSrc(dir, videoFilename, durationSeconds) {
     }
     const dur = durationSeconds ? String(Math.round(durationSeconds * 100) / 100) : "10";
     content = content.replaceAll("__VIDEO_DURATION__", dur);
-    writeFileSync14(file, content, "utf-8");
+    writeFileSync15(file, content, "utf-8");
   }
 }
 async function patchTranscript(dir, transcriptPath) {
@@ -35831,15 +36361,15 @@ async function handleVideoFile(videoPath, destDir, interactive) {
   return { meta, localVideoName };
 }
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
-  mkdirSync20(destDir, { recursive: true });
+  mkdirSync21(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
-  if (existsSync35(templateDir)) {
+  if (existsSync36(templateDir)) {
     cpSync(templateDir, destDir, { recursive: true });
   } else {
     await fetchRemoteTemplate(templateId, destDir);
   }
   patchVideoSrc(destDir, localVideoName, durationSeconds);
-  writeFileSync14(
+  writeFileSync15(
     resolve22(destDir, "meta.json"),
     JSON.stringify(
       {
@@ -35852,14 +36382,14 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync35(resolve22(destDir, "hyperframes.json"))) {
+  if (!existsSync36(resolve22(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 (existsSync35(sharedDir)) {
-    for (const entry of readdirSync12(sharedDir, { withFileTypes: true })) {
-      const src = join37(sharedDir, entry.name);
+  if (existsSync36(sharedDir)) {
+    for (const entry of readdirSync14(sharedDir, { withFileTypes: true })) {
+      const src = join38(sharedDir, entry.name);
       const dest = resolve22(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
@@ -35973,11 +36503,11 @@ var init_init = __esm({
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve22(name2);
-          if (existsSync35(destDir2) && readdirSync12(destDir2).length > 0) {
+          if (existsSync36(destDir2) && readdirSync14(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
-          mkdirSync20(destDir2, { recursive: true });
+          mkdirSync21(destDir2, { recursive: true });
           let localVideoName2;
           let videoDuration2;
           let sourceFilePath2;
@@ -35987,7 +36517,7 @@ var init_init = __esm({
           }
           if (videoFlag) {
             const videoPath = resolve22(videoFlag);
-            if (!existsSync35(videoPath)) {
+            if (!existsSync36(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -36001,7 +36531,7 @@ var init_init = __esm({
           }
           if (audioFlag) {
             const audioPath = resolve22(audioFlag);
-            if (!existsSync35(audioPath)) {
+            if (!existsSync36(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -36047,11 +36577,11 @@ var init_init = __esm({
           }
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve22(destDir2, "transcript.json");
-          if (existsSync35(transcriptFile2)) {
+          if (existsSync36(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f3 of readdirSync12(destDir2).filter((f4) => !f4.startsWith("."))) {
+          for (const f3 of readdirSync14(destDir2).filter((f4) => !f4.startsWith("."))) {
             console.log(`  ${c.accent(f3)}`);
           }
           console.log();
@@ -36099,7 +36629,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve22(name);
-        if (existsSync35(destDir) && readdirSync12(destDir).length > 0) {
+        if (existsSync36(destDir) && readdirSync14(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -36114,24 +36644,24 @@ var init_init = __esm({
         let videoDuration;
         if (videoFlag) {
           const videoPath = resolve22(videoFlag);
-          if (!existsSync35(videoPath)) {
+          if (!existsSync36(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
           }
-          mkdirSync20(destDir, { recursive: true });
+          mkdirSync21(destDir, { recursive: true });
           sourceFilePath = videoPath;
           const result = await handleVideoFile(videoPath, destDir, true);
           localVideoName = result.localVideoName;
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
           const audioPath = resolve22(audioFlag);
-          if (!existsSync35(audioPath)) {
+          if (!existsSync36(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
           }
-          mkdirSync20(destDir, { recursive: true });
+          mkdirSync21(destDir, { recursive: true });
           sourceFilePath = audioPath;
           copyFileSync3(audioPath, resolve22(destDir, basename5(audioPath)));
           R2.info(`Audio copied to ${c.accent(basename5(audioPath))}`);
@@ -36219,10 +36749,10 @@ ${c.dim("Use --example blank for offline use.")}`
         }
         trackInitTemplate(templateId);
         const transcriptFile = resolve22(destDir, "transcript.json");
-        if (existsSync35(transcriptFile)) {
+        if (existsSync36(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
-        const files = readdirSync12(destDir);
+        const files = readdirSync14(destDir);
         Vt2(files.map((f3) => c.accent(f3)).join("\n"), c.success(`Created ${name}/`));
         if (!skipSkills) {
           const installSkills = await Rt({
@@ -36305,7 +36835,7 @@ __export(add_exports, {
   remapTarget: () => remapTarget,
   runAdd: () => runAdd
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import { resolve as resolve23, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
@@ -36331,8 +36861,8 @@ function buildSnippet(item, relativeTarget) {
 async function runAdd(opts) {
   const projectDir = resolve23(opts.projectDir);
   let config = loadProjectConfig(projectDir);
-  const hasConfig = existsSync36(projectConfigPath(projectDir));
-  if (!hasConfig && existsSync36(resolve23(projectDir, "index.html"))) {
+  const hasConfig = existsSync37(projectConfigPath(projectDir));
+  if (!hasConfig && existsSync37(resolve23(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -36431,10 +36961,10 @@ var init_add = __esm({
         const projectDir = resolve23(args.dir ?? process.cwd());
         const json = args.json === true;
         const skipClipboard = args["no-clipboard"] === true;
-        const hasConfigBefore = existsSync36(projectConfigPath(projectDir));
+        const hasConfigBefore = existsSync37(projectConfigPath(projectDir));
         try {
           const result = await runAdd({ name: args.name, projectDir, skipClipboard });
-          const wroteConfig = !hasConfigBefore && existsSync36(projectConfigPath(projectDir));
+          const wroteConfig = !hasConfigBefore && existsSync37(projectConfigPath(projectDir));
           if (json) {
             console.log(JSON.stringify(result));
             return;
@@ -36644,17 +37174,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync37, statSync as statSync11 } from "fs";
+import { existsSync as existsSync38, statSync as statSync13 } from "fs";
 import { resolve as resolve25, basename as basename6 } from "path";
 function resolveProject(dirArg) {
   const dir = resolve25(dirArg ?? ".");
   const name = basename6(dir);
   const indexPath = resolve25(dir, "index.html");
-  if (!existsSync37(dir) || !statSync11(dir).isDirectory()) {
+  if (!existsSync38(dir) || !statSync13(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync37(indexPath)) {
+  if (!existsSync38(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -36677,7 +37207,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync38, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync26 } from "fs";
 import { resolve as resolve26, dirname as dirname15 } from "path";
 function commandDir() {
   return dirname15(new URL(import.meta.url).pathname);
@@ -36692,7 +37222,7 @@ function resolveRuntimePath2() {
     resolve26(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
-    if (existsSync38(p)) return p;
+    if (existsSync39(p)) return p;
   }
   return null;
 }
@@ -36706,7 +37236,7 @@ function resolvePlayerPath() {
     resolve26(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
-    if (existsSync38(p)) return p;
+    if (existsSync39(p)) return p;
   }
   return null;
 }
@@ -36808,7 +37338,7 @@ var init_play = __esm({
           const reqPath = ctx.req.path.replace("/composition/", "");
           const filePath = resolve26(project.dir, reqPath);
           if (!filePath.startsWith(project.dir)) return ctx.text("Forbidden", 403);
-          if (!existsSync38(filePath)) return ctx.text("Not found", 404);
+          if (!existsSync39(filePath)) return ctx.text("Not found", 404);
           const content = readFileSync26(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
@@ -36884,23 +37414,23 @@ var init_play = __esm({
 });
 
 // src/utils/publishProject.ts
-import { basename as basename7, join as join38, relative as relative4 } from "path";
-import { readdirSync as readdirSync13, readFileSync as readFileSync27, statSync as statSync12 } from "fs";
+import { basename as basename7, join as join39, relative as relative4 } from "path";
+import { readdirSync as readdirSync15, readFileSync as readFileSync27, statSync as statSync14 } from "fs";
 import AdmZip from "adm-zip";
 function shouldIgnoreSegment(segment) {
   return segment.startsWith(".") || IGNORED_DIRS.has(segment) || IGNORED_FILES.has(segment);
 }
 function collectProjectFiles(rootDir, currentDir, paths) {
-  for (const entry of readdirSync13(currentDir, { withFileTypes: true })) {
+  for (const entry of readdirSync15(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
-    const absolutePath = join38(currentDir, entry.name);
+    const absolutePath = join39(currentDir, entry.name);
     const relativePath = relative4(rootDir, absolutePath).replaceAll("\\", "/");
     if (!relativePath) continue;
     if (entry.isDirectory()) {
       collectProjectFiles(rootDir, absolutePath, paths);
       continue;
     }
-    if (!statSync12(absolutePath).isFile()) continue;
+    if (!statSync14(absolutePath).isFile()) continue;
     paths.push(relativePath);
   }
 }
@@ -36912,7 +37442,7 @@ function createPublishArchive(projectDir) {
   }
   const archive = new AdmZip();
   for (const filePath of filePaths) {
-    archive.addFile(filePath, readFileSync27(join38(projectDir, filePath)));
+    archive.addFile(filePath, readFileSync27(join39(projectDir, filePath)));
   }
   return {
     buffer: archive.toBuffer(),
@@ -36968,8 +37498,8 @@ __export(publish_exports, {
   examples: () => examples6
 });
 import { basename as basename8, resolve as resolve27 } from "path";
-import { existsSync as existsSync39 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync40 } from "fs";
+import { join as join40 } from "path";
 var examples6, publish_default;
 var init_publish = __esm({
   "src/commands/publish.ts"() {
@@ -37004,8 +37534,8 @@ var init_publish = __esm({
         const dir = resolve27(rawArg ?? ".");
         const isImplicitCwd = !rawArg || rawArg === "." || rawArg === "./";
         const projectName = isImplicitCwd ? basename8(process.env["PWD"] ?? dir) : basename8(dir);
-        const indexPath = join39(dir, "index.html");
-        if (existsSync39(indexPath)) {
+        const indexPath = join40(dir, "index.html");
+        if (existsSync40(indexPath)) {
           const lintResult = lintProject({ dir, name: projectName, indexPath });
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
             console.log();
@@ -37176,9 +37706,9 @@ __export(render_exports, {
   default: () => render_default,
   examples: () => examples7
 });
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync28, statSync as statSync13, writeFileSync as writeFileSync15, rmSync as rmSync9 } from "fs";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync28, statSync as statSync15, writeFileSync as writeFileSync16, rmSync as rmSync9 } from "fs";
 import { cpus as cpus3, freemem as freemem3, tmpdir as tmpdir4 } from "os";
-import { resolve as resolve28, dirname as dirname16, join as join40, basename as basename9 } from "path";
+import { resolve as resolve28, dirname as dirname16, join as join41, basename as basename9 } 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));
@@ -37191,7 +37721,7 @@ function resolveDockerfilePath() {
   const devPath = resolve28(__dirname, "..", "src", "docker", "Dockerfile.render");
   for (const p of [builtPath, devPath]) {
     try {
-      statSync13(p);
+      statSync15(p);
       return p;
     } catch {
       continue;
@@ -37215,9 +37745,9 @@ function ensureDockerImage(version, quiet) {
   }
   if (!quiet) console.log(c.dim(`  Building Docker image: ${tag}...`));
   const dockerfilePath = resolveDockerfilePath();
-  const tmpDir = join40(tmpdir4(), `hyperframes-docker-${Date.now()}`);
-  mkdirSync21(tmpDir, { recursive: true });
-  writeFileSync15(join40(tmpDir, "Dockerfile"), readFileSync28(dockerfilePath));
+  const tmpDir = join41(tmpdir4(), `hyperframes-docker-${Date.now()}`);
+  mkdirSync22(tmpDir, { recursive: true });
+  writeFileSync16(join41(tmpDir, "Dockerfile"), readFileSync28(dockerfilePath));
   try {
     execFileSync5(
       "docker",
@@ -37364,6 +37894,8 @@ function trackRenderMetrics(job, elapsedMs, options, docker) {
   const perf = job.perfSummary;
   const compositionDurationMs = perf ? Math.round(perf.compositionDurationSeconds * 1e3) : void 0;
   const speedRatio = compositionDurationMs && compositionDurationMs > 0 && elapsedMs > 0 ? Math.round(compositionDurationMs / elapsedMs * 100) / 100 : void 0;
+  const stages = perf?.stages ?? {};
+  const extract = perf?.videoExtractBreakdown;
   trackRenderComplete({
     durationMs: elapsedMs,
     fps: options.fps,
@@ -37378,6 +37910,23 @@ function trackRenderMetrics(job, elapsedMs, options, docker) {
     speedRatio,
     captureAvgMs: perf?.captureAvgMs,
     capturePeakMs: perf?.capturePeakMs,
+    tmpPeakBytes: perf?.tmpPeakBytes,
+    stageCompileMs: stages.compileMs,
+    stageVideoExtractMs: stages.videoExtractMs,
+    stageAudioProcessMs: stages.audioProcessMs,
+    stageCaptureMs: stages.captureMs,
+    stageEncodeMs: stages.encodeMs,
+    stageAssembleMs: stages.assembleMs,
+    extractResolveMs: extract?.resolveMs,
+    extractHdrProbeMs: extract?.hdrProbeMs,
+    extractHdrPreflightMs: extract?.hdrPreflightMs,
+    extractHdrPreflightCount: extract?.hdrPreflightCount,
+    extractVfrProbeMs: extract?.vfrProbeMs,
+    extractVfrPreflightMs: extract?.vfrPreflightMs,
+    extractVfrPreflightCount: extract?.vfrPreflightCount,
+    extractPhase3Ms: extract?.extractMs,
+    extractCacheHits: extract?.cacheHits,
+    extractCacheMisses: extract?.cacheMisses,
     ...getMemorySnapshot()
   });
 }
@@ -37385,7 +37934,7 @@ function printRenderComplete(outputPath, elapsedMs, quiet) {
   if (quiet) return;
   let fileSize = "unknown";
   try {
-    fileSize = formatBytes(statSync13(outputPath).size);
+    fileSize = formatBytes(statSync15(outputPath).size);
   } catch {
   }
   const duration = formatDuration(elapsedMs);
@@ -37546,8 +38095,8 @@ 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 ? resolve28(args.output) : join40(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
-        mkdirSync21(dirname16(outputPath), { recursive: true });
+        const outputPath = args.output ? resolve28(args.output) : join41(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        mkdirSync22(dirname16(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
         const quiet = args.quiet ?? false;
@@ -37894,16 +38443,16 @@ __export(info_exports, {
   default: () => info_default,
   examples: () => examples9
 });
-import { readFileSync as readFileSync29, readdirSync as readdirSync14, statSync as statSync14 } from "fs";
-import { join as join41 } from "path";
+import { readFileSync as readFileSync29, readdirSync as readdirSync16, statSync as statSync16 } from "fs";
+import { join as join42 } from "path";
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
-    const path2 = join41(dir, entry.name);
+  for (const entry of readdirSync16(dir, { withFileTypes: true })) {
+    const path2 = join42(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
     } else {
-      total += statSync14(path2).size;
+      total += statSync16(path2).size;
     }
   }
   return total;
@@ -37987,7 +38536,7 @@ __export(compositions_exports, {
   default: () => compositions_default,
   examples: () => examples10
 });
-import { existsSync as existsSync40, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync30 } from "fs";
 import { resolve as resolve29, dirname as dirname17 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
@@ -38001,7 +38550,7 @@ function parseCompositions(html, baseDir) {
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
       const subPath = resolve29(baseDir, compositionSrc);
-      if (existsSync40(subPath)) {
+      if (existsSync41(subPath)) {
         const subHtml = readFileSync30(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
@@ -38134,8 +38683,8 @@ __export(benchmark_exports, {
   default: () => benchmark_default,
   examples: () => examples11
 });
-import { existsSync as existsSync41, statSync as statSync15 } from "fs";
-import { resolve as resolve30, join as join42 } from "path";
+import { existsSync as existsSync42, statSync as statSync17 } from "fs";
+import { resolve as resolve30, join as join43 } from "path";
 var examples11, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -38210,7 +38759,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 = join42(
+            const outputPath = join43(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i2}.mp4`
             );
@@ -38224,8 +38773,8 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync41(outputPath)) {
-                const stat3 = statSync15(outputPath);
+              if (existsSync42(outputPath)) {
+                const stat3 = statSync17(outputPath);
                 fileSize = stat3.size;
               }
               runs.push({ elapsedMs, fileSize });
@@ -38440,8 +38989,8 @@ __export(transcribe_exports2, {
   default: () => transcribe_default,
   examples: () => examples13
 });
-import { existsSync as existsSync42, writeFileSync as writeFileSync16 } from "fs";
-import { resolve as resolve31, join as join43, extname as extname8 } from "path";
+import { existsSync as existsSync43, writeFileSync as writeFileSync17 } from "fs";
+import { resolve as resolve31, join as join44, extname as extname8 } from "path";
 async function importTranscript(inputPath, dir, json) {
   const { loadTranscript: loadTranscript2, patchCaptionHtml: patchCaptionHtml2 } = await Promise.resolve().then(() => (init_normalize(), normalize_exports));
   const { words, format } = loadTranscript2(inputPath);
@@ -38449,8 +38998,8 @@ async function importTranscript(inputPath, dir, json) {
     console.error(c.error("No words found in transcript."));
     process.exit(1);
   }
-  const outPath = join43(dir, "transcript.json");
-  writeFileSync16(outPath, JSON.stringify(words, null, 2));
+  const outPath = join44(dir, "transcript.json");
+  writeFileSync17(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
     console.log(
@@ -38485,7 +39034,7 @@ async function transcribeAudio(inputPath, dir, opts) {
         );
       }
     }
-    writeFileSync16(result.transcriptPath, JSON.stringify(words, null, 2));
+    writeFileSync17(result.transcriptPath, JSON.stringify(words, null, 2));
     patchCaptionHtml2(dir, words);
     if (opts.json) {
       console.log(
@@ -38566,7 +39115,7 @@ var init_transcribe2 = __esm({
       },
       async run({ args }) {
         const inputPath = resolve31(args.input);
-        if (!existsSync42(inputPath)) {
+        if (!existsSync43(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
@@ -38587,9 +39136,9 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync22 } from "fs";
+import { existsSync as existsSync44, mkdirSync as mkdirSync23 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function inferLangFromVoiceId(voiceId) {
   const first = voiceId.charAt(0).toLowerCase();
   return VOICE_PREFIX_LANG[first] ?? "en-us";
@@ -38598,29 +39147,29 @@ function isSupportedLang(value) {
   return SUPPORTED_LANGS.includes(value);
 }
 async function ensureModel2(model = DEFAULT_MODEL2, options) {
-  const modelPath = join44(MODELS_DIR2, `${model}.onnx`);
-  if (existsSync43(modelPath)) return modelPath;
+  const modelPath = join45(MODELS_DIR2, `${model}.onnx`);
+  if (existsSync44(modelPath)) return modelPath;
   const url = MODEL_URLS[model];
   if (!url) {
     throw new Error(
       `Unknown TTS model: ${model}. Available: ${Object.keys(MODEL_URLS).join(", ")}`
     );
   }
-  mkdirSync22(MODELS_DIR2, { recursive: true });
+  mkdirSync23(MODELS_DIR2, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath);
-  if (!existsSync43(modelPath)) {
+  if (!existsSync44(modelPath)) {
     throw new Error(`Model download failed: ${model}`);
   }
   return modelPath;
 }
 async function ensureVoices(options) {
-  const voicesPath = join44(VOICES_DIR, "voices-v1.0.bin");
-  if (existsSync43(voicesPath)) return voicesPath;
-  mkdirSync22(VOICES_DIR, { recursive: true });
+  const voicesPath = join45(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync44(voicesPath)) return voicesPath;
+  mkdirSync23(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
-  if (!existsSync43(voicesPath)) {
+  if (!existsSync44(voicesPath)) {
     throw new Error("Voice data download failed");
   }
   return voicesPath;
@@ -38630,9 +39179,9 @@ var init_manager3 = __esm({
   "src/tts/manager.ts"() {
     "use strict";
     init_download();
-    CACHE_DIR3 = join44(homedir8(), ".cache", "hyperframes", "tts");
-    MODELS_DIR2 = join44(CACHE_DIR3, "models");
-    VOICES_DIR = join44(CACHE_DIR3, "voices");
+    CACHE_DIR3 = join45(homedir8(), ".cache", "hyperframes", "tts");
+    MODELS_DIR2 = join45(CACHE_DIR3, "models");
+    VOICES_DIR = join45(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"
@@ -38693,8 +39242,8 @@ __export(synthesize_exports, {
   synthesize: () => synthesize
 });
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync44, writeFileSync as writeFileSync17, mkdirSync as mkdirSync23, readdirSync as readdirSync15, unlinkSync as unlinkSync6 } from "fs";
-import { join as join45, dirname as dirname18, basename as basename10 } from "path";
+import { existsSync as existsSync45, writeFileSync as writeFileSync18, mkdirSync as mkdirSync24, readdirSync as readdirSync17, unlinkSync as unlinkSync6 } from "fs";
+import { join as join46, dirname as dirname18, basename as basename10 } from "path";
 import { homedir as homedir9 } from "os";
 function findPython() {
   for (const name of ["python3", "python"]) {
@@ -38730,15 +39279,15 @@ function hasPythonPackage(python, pkg) {
   }
 }
 function ensureSynthScript() {
-  if (!existsSync44(SCRIPT_PATH)) {
-    mkdirSync23(SCRIPT_DIR, { recursive: true });
-    writeFileSync17(SCRIPT_PATH, SYNTH_SCRIPT);
+  if (!existsSync45(SCRIPT_PATH)) {
+    mkdirSync24(SCRIPT_DIR, { recursive: true });
+    writeFileSync18(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename10(SCRIPT_PATH);
     try {
-      for (const entry of readdirSync15(SCRIPT_DIR)) {
+      for (const entry of readdirSync17(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync6(join45(SCRIPT_DIR, entry));
+            unlinkSync6(join46(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -38772,7 +39321,7 @@ async function synthesize(text, outputPath, options) {
     ensureVoices({ onProgress: options?.onProgress })
   ]);
   const scriptPath = ensureSynthScript();
-  mkdirSync23(dirname18(outputPath), { recursive: true });
+  mkdirSync24(dirname18(outputPath), { recursive: true });
   options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
   try {
     const stdout2 = execFileSync6(
@@ -38784,7 +39333,7 @@ async function synthesize(text, outputPath, options) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    if (!existsSync44(outputPath)) {
+    if (!existsSync45(outputPath)) {
       throw new Error("Synthesis completed but no output file was created");
     }
     const lines = stdout2.trim().split("\n");
@@ -38797,7 +39346,7 @@ async function synthesize(text, outputPath, options) {
       langApplied: result.langApplied
     };
   } catch (err) {
-    if (err instanceof SyntaxError && existsSync44(outputPath)) {
+    if (err instanceof SyntaxError && existsSync45(outputPath)) {
       throw new Error(
         "Speech was generated but metadata could not be read. Check the output file manually."
       );
@@ -38848,8 +39397,8 @@ print(json.dumps({
     "langApplied": bool(lang and supports_lang),
 }))
 `;
-    SCRIPT_DIR = join45(homedir9(), ".cache", "hyperframes", "tts");
-    SCRIPT_PATH = join45(SCRIPT_DIR, "synth-v2.py");
+    SCRIPT_DIR = join46(homedir9(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join46(SCRIPT_DIR, "synth-v2.py");
   }
 });
 
@@ -38859,7 +39408,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples14
 });
-import { existsSync as existsSync45, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync31 } from "fs";
 import { resolve as resolve32, extname as extname9 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v) => ({ ...v, defaultLang: inferLangFromVoiceId(v.id) }));
@@ -38969,7 +39518,7 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve32(args.input);
-        if (existsSync45(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
+        if (existsSync46(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync31(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
@@ -39062,15 +39611,15 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples15
 });
-import { readFileSync as readFileSync32, existsSync as existsSync46 } from "fs";
-import { resolve as resolve33, dirname as dirname19, join as join46 } from "path";
+import { readFileSync as readFileSync32, existsSync as existsSync47 } from "fs";
+import { resolve as resolve33, dirname as dirname19, join as join47 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath6(import.meta.url);
   const dir = dirname19(thisFile);
   const devPath = resolve33(dir, "..", "docs");
   const builtPath = resolve33(dir, "docs");
-  return existsSync46(devPath) ? devPath : builtPath;
+  return existsSync47(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -39167,8 +39716,8 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join46(docsDir(), entry.file);
-        if (!existsSync46(filePath)) {
+        const filePath = join47(docsDir(), entry.file);
+        if (!existsSync47(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
@@ -39598,8 +40147,8 @@ var validate_exports = {};
 __export(validate_exports, {
   default: () => validate_default
 });
-import { existsSync as existsSync47, readFileSync as readFileSync33 } from "fs";
-import { resolve as resolve34, join as join47, dirname as dirname20 } from "path";
+import { existsSync as existsSync48, readFileSync as readFileSync33 } from "fs";
+import { resolve as resolve34, join as join48, dirname as dirname20 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -39654,7 +40203,7 @@ async function validateInBrowser(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync47(runtimePath)) {
+  if (existsSync48(runtimePath)) {
     const runtimeSource = readFileSync33(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -39670,8 +40219,8 @@ async function validateInBrowser(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = join47(projectDir, decodeURIComponent(url));
-    if (existsSync47(filePath)) {
+    const filePath = join48(projectDir, decodeURIComponent(url));
+    if (existsSync48(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync33(filePath));
       return;
@@ -39864,13 +40413,13 @@ __export(snapshot_exports, {
   examples: () => examples19
 });
 import { spawn as spawn11 } from "child_process";
-import { existsSync as existsSync48, mkdtempSync as mkdtempSync3, readFileSync as readFileSync34, mkdirSync as mkdirSync24, rmSync as rmSync10 } from "fs";
+import { existsSync as existsSync49, mkdtempSync as mkdtempSync3, readFileSync as readFileSync34, mkdirSync as mkdirSync25, rmSync as rmSync10 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { resolve as resolve35, join as join48, dirname as dirname21, relative as relative5, isAbsolute as isAbsolute6 } from "path";
+import { resolve as resolve35, join as join49, dirname as dirname21, relative as relative5, isAbsolute as isAbsolute6 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds) {
-  const tmp = mkdtempSync3(join48(tmpdir5(), "hf-snapshot-frame-"));
-  const outPath = join48(tmp, "frame.png");
+  const tmp = mkdtempSync3(join49(tmpdir5(), "hf-snapshot-frame-"));
+  const outPath = join49(tmp, "frame.png");
   try {
     const result = await new Promise(
       (resolvePromise) => {
@@ -39908,7 +40457,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds) {
         });
       }
     );
-    if (result.code !== 0 || result.timedOut || !existsSync48(outPath)) return null;
+    if (result.code !== 0 || result.timedOut || !existsSync49(outPath)) return null;
     return readFileSync34(outPath);
   } finally {
     try {
@@ -39931,7 +40480,7 @@ async function captureSnapshots(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync48(runtimePath)) {
+  if (existsSync49(runtimePath)) {
     const runtimeSource = readFileSync34(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -39954,7 +40503,7 @@ async function captureSnapshots(projectDir, opts) {
       res.end();
       return;
     }
-    if (existsSync48(filePath)) {
+    if (existsSync49(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync34(filePath));
       return;
@@ -40029,8 +40578,8 @@ 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 = join48(projectDir, "snapshots");
-      mkdirSync24(snapshotDir, { recursive: true });
+      const snapshotDir = join49(projectDir, "snapshots");
+      mkdirSync25(snapshotDir, { recursive: true });
       let injectVideoFramesBatch2 = null;
       let syncVideoFrameVisibility2 = null;
       try {
@@ -40090,7 +40639,7 @@ async function captureSnapshots(projectDir, opts) {
               const decodedPath = decodeURIComponent(url.pathname).replace(/^\//, "");
               const candidate = resolve35(projectDir, decodedPath);
               const rel = relative5(projectDir, candidate);
-              if (!rel.startsWith("..") && !isAbsolute6(rel) && existsSync48(candidate)) {
+              if (!rel.startsWith("..") && !isAbsolute6(rel) && existsSync49(candidate)) {
                 filePath = candidate;
               }
             } catch {
@@ -40116,7 +40665,7 @@ async function captureSnapshots(projectDir, opts) {
         }
         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 = join48(snapshotDir, filename);
+        const framePath = join49(snapshotDir, filename);
         await page.screenshot({ path: framePath, type: "png" });
         savedPaths.push(`snapshots/${filename}`);
       }
@@ -40201,14 +40750,14 @@ ${c.error("\u2717")} Snapshot failed: ${msg}`);
 });
 
 // src/capture/assetDownloader.ts
-import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync25 } from "fs";
-import { join as join49, extname as extname10 } from "path";
+import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync26 } from "fs";
+import { join as join50, extname as extname10 } from "path";
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
-  const assetsDir = join49(outputDir, "assets");
-  mkdirSync25(assetsDir, { recursive: true });
+  const assetsDir = join50(outputDir, "assets");
+  mkdirSync26(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync25(join49(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync26(join50(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;
@@ -40216,7 +40765,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
     const name = label2 ? slugify(label2) + ".svg" : svg.isLogo ? `logo-${i2}.svg` : `icon-${i2}.svg`;
     const localPath = `assets/svgs/${name}`;
     try {
-      writeFileSync18(join49(outputDir, localPath), svg.outerHTML, "utf-8");
+      writeFileSync19(join50(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
@@ -40229,7 +40778,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
       if (buffer) {
-        writeFileSync18(join49(outputDir, localPath), buffer);
+        writeFileSync19(join50(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -40286,7 +40835,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
         const slug = isMeaningful ? slugify(rawName) : `${prefix}-${imgIdx}`;
         const name = `${slug}${ext}`;
         const localPath = `assets/${name}`;
-        writeFileSync18(join49(outputDir, localPath), buffer);
+        writeFileSync19(join50(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -40299,7 +40848,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/og-image${ext}`;
       const buffer = await fetchBuffer(tokens.ogImage);
       if (buffer && buffer.length > 5e3) {
-        writeFileSync18(join49(outputDir, localPath), buffer);
+        writeFileSync19(join50(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -40322,8 +40871,8 @@ function normalizeUrl(u) {
   }
 }
 async function downloadAndRewriteFonts(css, outputDir) {
-  const assetsDir = join49(outputDir, "assets", "fonts");
-  mkdirSync25(assetsDir, { recursive: true });
+  const assetsDir = join50(outputDir, "assets", "fonts");
+  mkdirSync26(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
   let match;
@@ -40358,11 +40907,11 @@ async function downloadAndRewriteFonts(css, outputDir) {
     try {
       const urlObj = new URL(fontUrl);
       const filename = urlObj.pathname.split("/").pop() || `font-${count}.woff2`;
-      const localPath = join49(assetsDir, filename);
+      const localPath = join50(assetsDir, filename);
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
-        writeFileSync18(localPath, buffer);
+        writeFileSync19(localPath, buffer);
         rewritten = rewritten.split(fontUrl).join(relativePath);
         familyCounts.set(family, familyCount + 1);
         count++;
@@ -41155,8 +41704,8 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync26, writeFileSync as writeFileSync19, readdirSync as readdirSync16, readFileSync as readFileSync35, statSync as statSync16 } from "fs";
-import { join as join50 } from "path";
+import { mkdirSync as mkdirSync27, writeFileSync as writeFileSync20, readdirSync as readdirSync18, readFileSync as readFileSync35, statSync as statSync18 } from "fs";
+import { join as join51 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -41189,7 +41738,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
             const hash2 = buf.toString("base64").slice(0, 100);
             if (savedHashes.has(hash2)) continue;
             savedHashes.add(hash2);
-            writeFileSync19(join50(lottieDir, `animation-${savedCount}.lottie`), buf);
+            writeFileSync20(join51(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -41207,7 +41756,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync19(join50(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync20(join51(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -41217,22 +41766,22 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
-  const previewDir = join50(lottieDir, "previews");
-  mkdirSync26(previewDir, { recursive: true });
-  for (const file of readdirSync16(lottieDir)) {
+  const previewDir = join51(lottieDir, "previews");
+  mkdirSync27(previewDir, { recursive: true });
+  for (const file of readdirSync18(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync35(join50(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync35(join51(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 = statSync16(join50(lottieDir, file)).size;
+      const fileSize = statSync18(join51(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(readFileSync35(join50(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync35(join51(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -41262,7 +41811,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
         await previewPage.waitForFunction(() => window.__READY === true, { timeout: 5e3 }).catch(() => {
         });
         await previewPage.screenshot({
-          path: join50(previewDir, previewName),
+          path: join51(previewDir, previewName),
           type: "png",
           omitBackground: true
         });
@@ -41285,8 +41834,8 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
     }
   }
   if (manifest.length > 0) {
-    writeFileSync19(
-      join50(outputDir, "extracted", "lottie-manifest.json"),
+    writeFileSync20(
+      join51(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -41348,15 +41897,15 @@ async function captureVideoManifest(page, outputDir, progress) {
     return true;
   });
   if (uniqueVideos.length > 0) {
-    const videoManifestDir = join50(outputDir, "assets", "videos");
-    mkdirSync26(videoManifestDir, { recursive: true });
-    const previewDir = join50(videoManifestDir, "previews");
-    mkdirSync26(previewDir, { recursive: true });
+    const videoManifestDir = join51(outputDir, "assets", "videos");
+    mkdirSync27(videoManifestDir, { recursive: true });
+    const previewDir = join51(videoManifestDir, "previews");
+    mkdirSync27(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 = join50(previewDir, previewName);
+      const previewPath = join51(previewDir, previewName);
       try {
         await page.evaluate(`window.scrollTo(0, ${Math.max(0, v.top - 100)})`);
         await new Promise((r2) => setTimeout(r2, 300));
@@ -41394,8 +41943,8 @@ async function captureVideoManifest(page, outputDir, progress) {
       });
     }
     if (videoManifest.length > 0) {
-      writeFileSync19(
-        join50(outputDir, "extracted", "video-manifest.json"),
+      writeFileSync20(
+        join51(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
       );
@@ -48349,7 +48898,7 @@ var require_node_domexception = __commonJS({
 });
 
 // ../../node_modules/.bun/fetch-blob@3.2.0/node_modules/fetch-blob/from.js
-import { statSync as statSync17, createReadStream as createReadStream2, promises as fs2 } from "fs";
+import { statSync as statSync19, createReadStream as createReadStream2, promises as fs2 } from "fs";
 import { basename as basename11 } from "path";
 var import_node_domexception, stat, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
 var init_from = __esm({
@@ -48359,10 +48908,10 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat } = fs2);
-    blobFromSync = (path2, type) => fromBlob(statSync17(path2), path2, type);
+    blobFromSync = (path2, type) => fromBlob(statSync19(path2), path2, type);
     blobFrom = (path2, type) => stat(path2).then((stat3) => fromBlob(stat3, path2, type));
     fileFrom = (path2, type) => stat(path2).then((stat3) => fromFile(stat3, path2, type));
-    fileFromSync = (path2, type) => fromFile(statSync17(path2), path2, type);
+    fileFromSync = (path2, type) => fromFile(statSync19(path2), path2, type);
     fromBlob = (stat3, path2, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path2,
       size: stat3.size,
@@ -62153,7 +62702,7 @@ var require_websocket = __commonJS({
     var http4 = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash3 } = __require("crypto");
+    var { randomBytes, createHash: createHash4 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -62813,7 +63362,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash3("sha1").update(key2 + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key2 + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -63180,7 +63729,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http4 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash3 } = __require("crypto");
+    var { createHash: createHash4 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -63481,7 +64030,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash3("sha1").update(key2 + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key2 + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -81850,8 +82399,8 @@ ${underline2}`);
 });
 
 // src/capture/contentExtractor.ts
-import { readdirSync as readdirSync17, statSync as statSync18, readFileSync as readFileSync36 } from "fs";
-import { join as join51 } from "path";
+import { readdirSync as readdirSync19, statSync as statSync20, readFileSync as readFileSync36 } from "fs";
+import { join as join52 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
   try {
@@ -81971,7 +82520,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 = readdirSync17(join51(outputDir, "assets")).filter(
+    const imageFiles = readdirSync19(join52(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";
@@ -81980,8 +82529,8 @@ 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 = join51(outputDir, "assets", file);
-          const stat3 = statSync18(filePath);
+          const filePath = join52(outputDir, "assets", file);
+          const stat3 = statSync20(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
           const buffer = readFileSync36(filePath);
           const base64 = buffer.toString("base64");
@@ -82029,12 +82578,12 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join51(outputDir, "assets");
+  const assetsPath = join52(outputDir, "assets");
   try {
-    for (const file of readdirSync17(assetsPath)) {
+    for (const file of readdirSync19(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join51(assetsPath, file);
-      const stat3 = statSync18(filePath);
+      const filePath = join52(assetsPath, file);
+      const stat3 = statSync20(filePath);
       if (!stat3.isFile()) continue;
       const sizeKb = Math.round(stat3.size / 1024);
       const catalogMatch = catalogedAssets.find(
@@ -82062,8 +82611,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join51(assetsPath, "svgs");
-    for (const file of readdirSync17(svgsPath)) {
+    const svgsPath = join52(assetsPath, "svgs");
+    for (const file of readdirSync19(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
         (s2) => s2.label && file.includes(
@@ -82077,8 +82626,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join51(assetsPath, "fonts");
-    for (const file of readdirSync17(fontsPath)) {
+    const fontsPath = join52(assetsPath, "fonts");
+    for (const file of readdirSync19(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
   } catch {
@@ -82096,13 +82645,13 @@ var agentPromptGenerator_exports = {};
 __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
-import { writeFileSync as writeFileSync20 } from "fs";
-import { join as join52 } from "path";
+import { writeFileSync as writeFileSync21 } from "fs";
+import { join as join53 } from "path";
 function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, detectedLibraries) {
   const prompt = buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries);
-  writeFileSync20(join52(outputDir, "AGENTS.md"), prompt, "utf-8");
-  writeFileSync20(join52(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync20(join52(outputDir, ".cursorrules"), prompt, "utf-8");
+  writeFileSync21(join53(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync21(join53(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync21(join53(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -82169,8 +82718,8 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync49, writeFileSync as writeFileSync21, readFileSync as readFileSync37 } from "fs";
-import { join as join53, resolve as resolve36 } from "path";
+import { existsSync as existsSync50, writeFileSync as writeFileSync22, readFileSync as readFileSync37 } from "fs";
+import { join as join54, resolve as resolve36 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve36(startDir);
@@ -82196,10 +82745,10 @@ function loadEnvFile(startDir) {
   }
 }
 async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
-  const metaPath = join53(outputDir, "meta.json");
-  if (!existsSync49(metaPath)) {
+  const metaPath = join54(outputDir, "meta.json");
+  if (!existsSync50(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
-    writeFileSync21(
+    writeFileSync22(
       metaPath,
       JSON.stringify({ id: hostname + "-video", name: tokens.title || hostname }, null, 2),
       "utf-8"
@@ -82234,11 +82783,11 @@ var screenshotCapture_exports = {};
 __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
-import { writeFileSync as writeFileSync22, mkdirSync as mkdirSync27 } from "fs";
-import { join as join54 } from "path";
+import { writeFileSync as writeFileSync23, mkdirSync as mkdirSync28 } from "fs";
+import { join as join55 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
-  const screenshotsDir = join54(outputDir, "screenshots");
-  mkdirSync27(screenshotsDir, { recursive: true });
+  const screenshotsDir = join55(outputDir, "screenshots");
+  mkdirSync28(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
   try {
@@ -82271,9 +82820,9 @@ 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 = join54(screenshotsDir, filename);
+      const filePath = join55(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
-      writeFileSync22(filePath, buffer);
+      writeFileSync23(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
     }
     await page.evaluate(`window.scrollTo(0, 0)`);
@@ -82584,8 +83133,8 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync23, existsSync as existsSync50 } from "fs";
-import { join as join55 } from "path";
+import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync24, existsSync as existsSync51 } from "fs";
+import { join as join56 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -82602,9 +83151,9 @@ async function captureWebsite(opts, onProgress) {
     onProgress?.(stage, detail);
   };
   loadEnvFile(outputDir);
-  mkdirSync28(join55(outputDir, "extracted"), { recursive: true });
-  mkdirSync28(join55(outputDir, "screenshots"), { recursive: true });
-  mkdirSync28(join55(outputDir, "assets"), { recursive: true });
+  mkdirSync29(join56(outputDir, "extracted"), { recursive: true });
+  mkdirSync29(join56(outputDir, "screenshots"), { recursive: true });
+  mkdirSync29(join56(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -82760,8 +83309,8 @@ async function captureWebsite(opts, onProgress) {
     } catch {
     }
     if (discoveredLotties.length > 0) {
-      const lottieDir = join55(outputDir, "assets", "lottie");
-      mkdirSync28(lottieDir, { recursive: true });
+      const lottieDir = join56(outputDir, "assets", "lottie");
+      mkdirSync29(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
         await renderLottiePreviews(chromeBrowser, lottieDir, outputDir);
@@ -82779,8 +83328,8 @@ async function captureWebsite(opts, onProgress) {
           return true;
         });
         capturedShaders = unique;
-        writeFileSync23(
-          join55(outputDir, "extracted", "shaders.json"),
+        writeFileSync24(
+          join56(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -82790,8 +83339,8 @@ async function captureWebsite(opts, onProgress) {
     }
     progress("tokens", "Extracting design tokens...");
     const tokens = await extractTokens(page1);
-    writeFileSync23(
-      join55(outputDir, "extracted", "tokens.json"),
+    writeFileSync24(
+      join56(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokens, null, 2),
       "utf-8"
     );
@@ -82864,8 +83413,8 @@ async function captureWebsite(opts, onProgress) {
         scrollTriggeredElements: (animationCatalog.scrollTargets || []).length,
         representativeAnimations: representativeAnims
       };
-      writeFileSync23(
-        join55(outputDir, "extracted", "animations.json"),
+      writeFileSync24(
+        join56(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -82876,18 +83425,18 @@ async function captureWebsite(opts, onProgress) {
       assets = await downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks);
     }
     if (visibleTextContent) {
-      writeFileSync23(join55(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync24(join56(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     if (catalogedAssets.length > 0) {
-      writeFileSync23(
-        join55(outputDir, "extracted", "assets-catalog.json"),
+      writeFileSync24(
+        join56(outputDir, "extracted", "assets-catalog.json"),
         JSON.stringify(catalogedAssets, null, 2),
         "utf-8"
       );
     }
     if (detectedLibraries.length > 0) {
-      writeFileSync23(
-        join55(outputDir, "extracted", "detected-libraries.json"),
+      writeFileSync24(
+        join56(outputDir, "extracted", "detected-libraries.json"),
         JSON.stringify(detectedLibraries, null, 2),
         "utf-8"
       );
@@ -82897,8 +83446,8 @@ async function captureWebsite(opts, onProgress) {
     try {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
-        writeFileSync23(
-          join55(outputDir, "extracted", "asset-descriptions.md"),
+        writeFileSync24(
+          join56(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"
         );
@@ -82914,7 +83463,7 @@ async function captureWebsite(opts, onProgress) {
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync50(join55(outputDir, "extracted", "shaders.json")),
+      existsSync51(join56(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
       warnings,
@@ -83093,11 +83642,11 @@ var init_capture2 = __esm({
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           try {
-            const { mkdirSync: mkdirSync30, writeFileSync: writeFileSync24 } = await import("fs");
-            mkdirSync30(outputDir, { recursive: true });
+            const { mkdirSync: mkdirSync31, writeFileSync: writeFileSync25 } = await import("fs");
+            mkdirSync31(outputDir, { recursive: true });
             const isTimeout = /timeout|timed out/i.test(errMsg);
             const reason = isTimeout ? "Page navigation timed out \u2014 the site may be blocking headless browsers or requires authentication." : `Capture failed: ${errMsg}`;
-            writeFileSync24(
+            writeFileSync25(
               `${outputDir}/BLOCKED.md`,
               `# Capture Failed
 
@@ -83261,9 +83810,9 @@ __export(autoUpdate_exports, {
   scheduleBackgroundInstall: () => scheduleBackgroundInstall
 });
 import { spawn as spawn12 } from "child_process";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync29, openSync } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync30, openSync } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 import { compareVersions as compareVersions2 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -83278,15 +83827,15 @@ function majorOf(version) {
 }
 function log(line) {
   try {
-    mkdirSync29(CONFIG_DIR2, { recursive: true, mode: 448 });
+    mkdirSync30(CONFIG_DIR2, { recursive: true, mode: 448 });
     appendFileSync2(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `, { mode: 384 });
   } catch {
   }
 }
 function launchDetachedInstall(installCommand, version) {
-  mkdirSync29(CONFIG_DIR2, { recursive: true, mode: 448 });
-  const configFile = join56(CONFIG_DIR2, "config.json");
+  mkdirSync30(CONFIG_DIR2, { recursive: true, mode: 448 });
+  const configFile = join57(CONFIG_DIR2, "config.json");
   const nodeScript = `
     const { exec } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -83405,8 +83954,8 @@ var init_autoUpdate = __esm({
     init_config();
     init_env();
     init_installerDetection();
-    CONFIG_DIR2 = join56(homedir10(), ".hyperframes");
-    LOG_FILE = join56(CONFIG_DIR2, "auto-update.log");
+    CONFIG_DIR2 = join57(homedir10(), ".hyperframes");
+    LOG_FILE = join57(CONFIG_DIR2, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });