hyperframes 0.4.38 → 0.5.0-alpha.10

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.38" : "0.0.0-dev";
+    VERSION = true ? "0.5.0-alpha.10" : "0.0.0-dev";
   }
 });
 
@@ -5486,7 +5486,7 @@ var init_captions = __esm({
           const hasHardKill = /\.set\s*\([^,]+,\s*\{[^}]*(?:visibility\s*:\s*["']hidden["']|opacity\s*:\s*0)/.test(
             content
           );
-          const hasCaptionLoop = /forEach|\.forEach\s*\(/.test(content) && /createElement|caption|group|cg-/.test(content);
+          const hasCaptionLoop = /forEach|\.forEach\s*\(/.test(content) && /karaoke|caption[-_]?(?:group|word|line|block)|cg-/.test(content);
           if (hasCaptionLoop && hasExitTween && !hasHardKill) {
             findings.push({
               code: "caption_exit_missing_hard_kill",
@@ -6182,6 +6182,18 @@ function rewriteAssetPaths(elements, compSrcPath, getAttr2, setAttr) {
     }
   }
 }
+function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle) {
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return;
+  for (const el of elements) {
+    const style = getStyle(el);
+    if (!style) continue;
+    const rewritten = rewriteCssAssetUrls(style, compSrcPath);
+    if (rewritten !== style) {
+      setStyle(el, rewritten);
+    }
+  }
+}
 function rewriteCssAssetUrls(cssText, compSrcPath) {
   if (!cssText) return cssText;
   return cssText.replace(CSS_URL_RE, (full, quote, rawUrl) => {
@@ -11636,7 +11648,7 @@ function registerProjectRoutes(api, adapter2) {
     const project = await adapter2.resolveProject(c2.req.param("id"));
     if (!project) return c2.json({ error: "not found" }, 404);
     const files = walkDir(project.dir);
-    return c2.json({ id: project.id, files });
+    return c2.json({ id: project.id, dir: project.dir, title: project.title, files });
   });
 }
 var init_projects = __esm({
@@ -24751,6 +24763,14 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref) {
       el.setAttribute(attr, value);
     }
   );
+  rewriteInlineStyleAssetUrls(
+    contentDoc.querySelectorAll("[style]"),
+    compPath,
+    (el) => el.getAttribute("style"),
+    (el, value) => {
+      el.setAttribute("style", value);
+    }
+  );
   for (const styleEl of contentDoc.querySelectorAll("style")) {
     styleEl.textContent = rewriteCssAssetUrls(styleEl.textContent || "", compPath);
   }
@@ -25145,7 +25165,7 @@ var init_render = __esm({
 });
 
 // ../core/src/studio-api/routes/thumbnail.ts
-import { existsSync as existsSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, statSync as statSync4 } from "fs";
 import { join as join17 } from "path";
 function registerThumbnailRoutes(api, adapter2) {
   api.get("/projects/:id/thumbnail/*", async (c2) => {
@@ -25163,13 +25183,16 @@ function registerThumbnailRoutes(api, adapter2) {
     const vpWidth = parseInt(url.searchParams.get("w") || "0") || 0;
     const vpHeight = parseInt(url.searchParams.get("h") || "0") || 0;
     const selector = url.searchParams.get("selector") || void 0;
-    const format = url.searchParams.get("format") === "png" ? "png" : "jpeg";
-    const contentType = format === "png" ? "image/png" : "image/jpeg";
+    const rawSelectorIndex = Number.parseInt(url.searchParams.get("selectorIndex") || "0", 10);
+    const selectorIndex = Number.isFinite(rawSelectorIndex) && rawSelectorIndex > 0 ? rawSelectorIndex : void 0;
+    const urlVersion = url.searchParams.get("v") || "";
     let compW = vpWidth || 1920;
     let compH = vpHeight || 1080;
+    let sourceMtime = 0;
     if (!vpWidth) {
       const htmlFile = join17(project.dir, compPath);
       if (existsSync14(htmlFile)) {
+        sourceMtime = Math.round(statSync4(htmlFile).mtimeMs);
         const html = readFileSync15(htmlFile, "utf-8");
         const wMatch = html.match(/data-width=["'](\d+)["']/);
         const hMatch = html.match(/data-height=["'](\d+)["']/);
@@ -25179,12 +25202,13 @@ function registerThumbnailRoutes(api, adapter2) {
     }
     const previewUrl = compPath === "index.html" ? `http://${c2.req.header("host")}/api/projects/${project.id}/preview` : `http://${c2.req.header("host")}/api/projects/${project.id}/preview/comp/${compPath}`;
     const cacheDir = join17(project.dir, ".thumbnails");
-    const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}` : "";
-    const cacheKey = `${THUMBNAIL_CACHE_VERSION}_${format}_${compPath.replace(/\//g, "_")}_${seekTime.toFixed(2)}${selectorKey}.${format === "png" ? "png" : "jpg"}`;
+    const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}_${selectorIndex ?? 0}` : "";
+    const urlVersionKey = urlVersion ? `_${urlVersion.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 32)}` : "";
+    const cacheKey = `${THUMBNAIL_CACHE_VERSION}${urlVersionKey}_${compPath.replace(/\//g, "_")}_${compW}x${compH}_${sourceMtime}_${seekTime.toFixed(2)}${selectorKey}.jpg`;
     const cachePath2 = join17(cacheDir, cacheKey);
     if (existsSync14(cachePath2)) {
       return new Response(new Uint8Array(readFileSync15(cachePath2)), {
-        headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=60" }
+        headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
       });
     }
     try {
@@ -25196,7 +25220,7 @@ function registerThumbnailRoutes(api, adapter2) {
         height: compH,
         previewUrl,
         selector,
-        format
+        selectorIndex
       });
       if (!buffer) {
         return c2.json({ error: "Thumbnail generation returned null" }, 500);
@@ -25204,7 +25228,7 @@ function registerThumbnailRoutes(api, adapter2) {
       if (!existsSync14(cacheDir)) mkdirSync8(cacheDir, { recursive: true });
       writeFileSync9(cachePath2, buffer);
       return new Response(new Uint8Array(buffer), {
-        headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=60" }
+        headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -25216,7 +25240,7 @@ var THUMBNAIL_CACHE_VERSION;
 var init_thumbnail = __esm({
   "../core/src/studio-api/routes/thumbnail.ts"() {
     "use strict";
-    THUMBNAIL_CACHE_VERSION = "v2";
+    THUMBNAIL_CACHE_VERSION = "v3";
   }
 });
 
@@ -25264,6 +25288,218 @@ var init_waveform2 = __esm({
   }
 });
 
+// ../core/src/studio-api/routes/fonts.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync16, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { homedir as homedir4, platform as platform3 } from "os";
+import { join as join19 } from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function fontDirectories() {
+  const home = homedir4();
+  if (platform3() === "darwin") {
+    return [
+      join19(home, "Library", "Fonts"),
+      "/Library/Fonts",
+      "/System/Library/Fonts",
+      "/System/Library/Fonts/Supplemental"
+    ];
+  }
+  if (platform3() === "win32") {
+    return [join19(process.env.WINDIR || "C:\\Windows", "Fonts")];
+  }
+  return [
+    join19(home, ".fonts"),
+    join19(home, ".local", "share", "fonts"),
+    "/usr/local/share/fonts",
+    "/usr/share/fonts"
+  ];
+}
+function toFamilyName(fileName) {
+  const withoutExt = fileName.replace(FONT_EXT_RE, "");
+  if (!withoutExt || withoutExt.startsWith(".")) return null;
+  const spaced = withoutExt.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/\s+/g, " ").trim();
+  const words = spaced.split(" ").filter(Boolean);
+  while (words.length > 1 && STYLE_SUFFIXES.has((words.at(-1) ?? "").toLowerCase())) {
+    words.pop();
+  }
+  const family = words.join(" ").trim();
+  return family.length >= 2 ? family : null;
+}
+function collectMacSystemProfilerFonts() {
+  if (platform3() !== "darwin") return [];
+  let parsed;
+  try {
+    const raw = execFileSync4("system_profiler", ["SPFontsDataType", "-json"], {
+      encoding: "utf8",
+      maxBuffer: 12 * 1024 * 1024,
+      timeout: 5e3
+    });
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.SPFontsDataType)) return [];
+  const fonts = [];
+  for (const fontEntry of parsed.SPFontsDataType) {
+    if (!isRecord(fontEntry)) continue;
+    const typefaces = fontEntry.typefaces;
+    if (!Array.isArray(typefaces)) continue;
+    for (const typeface of typefaces) {
+      if (!isRecord(typeface)) continue;
+      const family = typeface.family;
+      const fullName = typeface.fullname;
+      const name = typeface._name;
+      if (typeof family === "string" && family.trim()) {
+        fonts.push(family.trim());
+      } else if (typeof fullName === "string" && fullName.trim()) {
+        fonts.push(fullName.trim());
+      } else if (typeof name === "string" && name.trim()) {
+        fonts.push(name.trim());
+      }
+    }
+  }
+  return fonts;
+}
+function collectFontsFromDir(dir, depth = 0) {
+  if (!existsSync16(dir) || depth > 2) return [];
+  const fonts = [];
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const fullPath = join19(dir, entry.name);
+    if (entry.isDirectory()) {
+      fonts.push(...collectFontsFromDir(fullPath, depth + 1));
+      continue;
+    }
+    if (!entry.isFile() || !FONT_EXT_RE.test(entry.name)) continue;
+    try {
+      if (!statSync5(fullPath).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const family = toFamilyName(entry.name);
+    if (family) fonts.push(family);
+  }
+  return fonts;
+}
+function listInstalledFontFamilies() {
+  if (cachedFonts) return cachedFonts;
+  const families = /* @__PURE__ */ new Set();
+  for (const family of collectMacSystemProfilerFonts()) {
+    families.add(family);
+    if (families.size >= MAX_FONT_RESULTS) break;
+  }
+  for (const dir of fontDirectories()) {
+    for (const family of collectFontsFromDir(dir)) {
+      families.add(family);
+      if (families.size >= MAX_FONT_RESULTS) break;
+    }
+    if (families.size >= MAX_FONT_RESULTS) break;
+  }
+  cachedFonts = Array.from(families).sort((a, b) => a.localeCompare(b));
+  return cachedFonts;
+}
+function parseGoogleFontMetadata(value) {
+  if (!isRecord(value) || !Array.isArray(value.familyMetadataList)) return [];
+  const families = [];
+  for (const entry of value.familyMetadataList) {
+    if (!isRecord(entry) || typeof entry.family !== "string") continue;
+    families.push(entry.family);
+  }
+  return families;
+}
+function stripGoogleJsonGuard(raw) {
+  const prefix = ")]}'";
+  if (!raw.startsWith(prefix)) return raw;
+  let index = prefix.length;
+  while (index < raw.length && (raw[index] === " " || raw[index] === "\n" || raw[index] === "\r" || raw[index] === "	" || raw[index] === "\f")) {
+    index += 1;
+  }
+  return raw.slice(index);
+}
+async function listGoogleFontFamilies() {
+  if (cachedGoogleFonts) return cachedGoogleFonts;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), GOOGLE_FONTS_FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(GOOGLE_FONTS_METADATA_URL, { signal: controller.signal });
+    if (!response.ok) {
+      cachedGoogleFonts = GOOGLE_FONT_FALLBACKS;
+      return cachedGoogleFonts;
+    }
+    const raw = await response.text();
+    const jsonText = stripGoogleJsonGuard(raw);
+    const families = parseGoogleFontMetadata(JSON.parse(jsonText));
+    cachedGoogleFonts = families.length > 0 ? families : GOOGLE_FONT_FALLBACKS;
+  } catch {
+    cachedGoogleFonts = GOOGLE_FONT_FALLBACKS;
+  } finally {
+    clearTimeout(timer);
+  }
+  return cachedGoogleFonts;
+}
+function registerFontRoutes(api) {
+  api.get("/fonts", (c2) => c2.json({ fonts: listInstalledFontFamilies() }));
+  api.get("/fonts/google", async (c2) => c2.json({ fonts: await listGoogleFontFamilies() }));
+}
+var FONT_EXT_RE, MAX_FONT_RESULTS, GOOGLE_FONTS_METADATA_URL, GOOGLE_FONTS_FETCH_TIMEOUT_MS, cachedFonts, cachedGoogleFonts, STYLE_SUFFIXES, GOOGLE_FONT_FALLBACKS;
+var init_fonts = __esm({
+  "../core/src/studio-api/routes/fonts.ts"() {
+    "use strict";
+    FONT_EXT_RE = /\.(otf|ttf|ttc|woff2?)$/i;
+    MAX_FONT_RESULTS = 2e3;
+    GOOGLE_FONTS_METADATA_URL = "https://fonts.google.com/metadata/fonts";
+    GOOGLE_FONTS_FETCH_TIMEOUT_MS = 3e3;
+    cachedFonts = null;
+    cachedGoogleFonts = null;
+    STYLE_SUFFIXES = /* @__PURE__ */ new Set([
+      "black",
+      "bold",
+      "book",
+      "condensed",
+      "demi",
+      "demibold",
+      "display",
+      "extra",
+      "extrabold",
+      "hairline",
+      "heavy",
+      "italic",
+      "light",
+      "medium",
+      "normal",
+      "regular",
+      "roman",
+      "semibold",
+      "thin",
+      "ultra",
+      "ultralight"
+    ]);
+    GOOGLE_FONT_FALLBACKS = [
+      "Inter",
+      "Roboto",
+      "Open Sans",
+      "Montserrat",
+      "Poppins",
+      "Lato",
+      "Oswald",
+      "Raleway",
+      "Nunito",
+      "Playfair Display",
+      "Merriweather",
+      "Source Sans 3",
+      "Source Serif 4",
+      "Source Code Pro",
+      "DM Sans",
+      "Space Grotesk",
+      "Space Mono",
+      "Bebas Neue",
+      "Outfit",
+      "JetBrains Mono"
+    ];
+  }
+});
+
 // ../core/src/studio-api/createStudioApi.ts
 import { Hono } from "hono";
 function createStudioApi(adapter2) {
@@ -25275,6 +25511,7 @@ function createStudioApi(adapter2) {
   registerRenderRoutes(api, adapter2);
   registerThumbnailRoutes(api, adapter2);
   registerWaveformRoutes(api, adapter2);
+  registerFontRoutes(api);
   return api;
 }
 var init_createStudioApi = __esm({
@@ -25287,6 +25524,7 @@ var init_createStudioApi = __esm({
     init_render();
     init_thumbnail();
     init_waveform2();
+    init_fonts();
   }
 });
 
@@ -25321,9 +25559,9 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync16, rmSync as rmSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join19 } from "path";
+import { existsSync as existsSync17, rmSync as rmSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join20 } from "path";
 import { Browser, detectBrowserPlatform, getInstalledBrowsers, install } from "@puppeteer/browsers";
 function setBrowserPath(path2) {
   _browserPathOverride = path2;
@@ -25343,17 +25581,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync16(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync17(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync16(envPath)) {
+  if (envPath && existsSync17(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync16(CACHE_DIR2)) {
+  if (!existsSync17(CACHE_DIR2)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR2 });
@@ -25365,7 +25603,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync16(p)) {
+    if (existsSync17(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -25385,21 +25623,21 @@ async function findBrowser() {
 async function ensureBrowser(options) {
   const existing = await findBrowser();
   if (existing) return existing;
-  const platform5 = detectBrowserPlatform();
-  if (!platform5) {
+  const platform6 = detectBrowserPlatform();
+  if (!platform6) {
     throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`);
   }
   const installed = await install({
     cacheDir: CACHE_DIR2,
     browser: Browser.CHROMEHEADLESSSHELL,
     buildId: CHROME_VERSION,
-    platform: platform5,
+    platform: platform6,
     downloadProgressCallback: options?.onProgress
   });
   return { executablePath: installed.executablePath, source: "download" };
 }
 function clearBrowser() {
-  if (!existsSync16(CACHE_DIR2)) {
+  if (!existsSync17(CACHE_DIR2)) {
     return false;
   }
   rmSync4(CACHE_DIR2, { recursive: true, force: true });
@@ -25410,7 +25648,7 @@ var init_manager2 = __esm({
   "src/browser/manager.ts"() {
     "use strict";
     CHROME_VERSION = "131.0.6778.85";
-    CACHE_DIR2 = join19(homedir4(), ".cache", "hyperframes", "chrome");
+    CACHE_DIR2 = join20(homedir5(), ".cache", "hyperframes", "chrome");
     SYSTEM_CHROME_PATHS = process.platform === "darwin" ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"] : [
       "/usr/bin/google-chrome",
       "/usr/bin/google-chrome-stable",
@@ -25537,9 +25775,9 @@ var init_config2 = __esm({
 });
 
 // ../engine/src/services/browserManager.ts
-import { existsSync as existsSync17, readdirSync as readdirSync6 } from "fs";
-import { join as join20 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync18, readdirSync as readdirSync7 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir6 } from "os";
 async function getPuppeteer() {
   if (_puppeteer) return _puppeteer;
   try {
@@ -25559,19 +25797,19 @@ function resolveHeadlessShellPath(config) {
   if (process.env.PRODUCER_HEADLESS_SHELL_PATH) {
     return process.env.PRODUCER_HEADLESS_SHELL_PATH;
   }
-  const baseDir = join20(homedir5(), ".cache", "puppeteer", "chrome-headless-shell");
-  if (!existsSync17(baseDir)) return void 0;
+  const baseDir = join21(homedir6(), ".cache", "puppeteer", "chrome-headless-shell");
+  if (!existsSync18(baseDir)) return void 0;
   try {
-    const versions = readdirSync6(baseDir).sort().reverse();
+    const versions = readdirSync7(baseDir).sort().reverse();
     for (const version of versions) {
       const candidates = [
-        join20(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
-        join20(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
-        join20(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
-        join20(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
+        join21(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
+        join21(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
+        join21(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
+        join21(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
       ];
       for (const binary of candidates) {
-        if (existsSync17(binary)) return binary;
+        if (existsSync18(binary)) return binary;
       }
     }
   } catch {
@@ -26034,10 +26272,10 @@ var init_screenshotService = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
+import { join as join22 } from "path";
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync18(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  if (!existsSync19(outputDir)) mkdirSync10(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -26241,9 +26479,9 @@ async function initializeSession(session) {
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
   try {
-    const diagnosticsDir = join21(session.outputDir, "diagnostics");
-    if (!existsSync18(diagnosticsDir)) mkdirSync10(diagnosticsDir, { recursive: true });
-    const base = join21(diagnosticsDir, `frame-error-${frameIndex}`);
+    const diagnosticsDir = join22(session.outputDir, "diagnostics");
+    if (!existsSync19(diagnosticsDir)) mkdirSync10(diagnosticsDir, { recursive: true });
+    const base = join22(diagnosticsDir, `frame-error-${frameIndex}`);
     await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
     const html = await session.page.content();
     writeFileSync11(`${base}.html`, html, "utf-8");
@@ -26341,7 +26579,7 @@ async function captureFrame(session, frameIndex, time) {
   );
   const ext = options.format === "png" ? "png" : "jpg";
   const frameName = `frame_${String(frameIndex).padStart(6, "0")}.${ext}`;
-  const framePath = join21(outputDir, frameName);
+  const framePath = join22(outputDir, frameName);
   writeFileSync11(framePath, buffer);
   return { frameIndex, time: quantizedTime, path: framePath, captureTimeMs };
 }
@@ -26362,7 +26600,7 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync18(outputDir)) {
+  if (!existsSync19(outputDir)) {
     mkdirSync10(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
@@ -26600,8 +26838,8 @@ var init_runFfmpeg = __esm({
 
 // ../engine/src/services/chunkEncoder.ts
 import { spawn as spawn5 } from "child_process";
-import { copyFileSync, existsSync as existsSync19, mkdirSync as mkdirSync11, readdirSync as readdirSync7, statSync as statSync4, writeFileSync as writeFileSync12 } from "fs";
-import { join as join22, dirname as dirname7 } from "path";
+import { copyFileSync, existsSync as existsSync20, mkdirSync as mkdirSync11, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync12 } from "fs";
+import { join as join23, dirname as dirname7 } from "path";
 function getEncoderPreset(quality, format = "mp4", hdr) {
   const base = ENCODER_PRESETS[quality];
   if (format === "webm") {
@@ -26752,8 +26990,8 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config) {
   const startTime = Date.now();
   const outputDir = dirname7(outputPath);
-  if (!existsSync19(outputDir)) mkdirSync11(outputDir, { recursive: true });
-  const files = readdirSync7(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i));
+  if (!existsSync20(outputDir)) mkdirSync11(outputDir, { recursive: true });
+  const files = readdirSync8(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
     return {
@@ -26769,7 +27007,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
-  const inputPath = join22(framesDir, framePattern);
+  const inputPath = join23(framesDir, framePattern);
   const inputArgs = ["-framerate", String(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   return new Promise((resolve39) => {
@@ -26818,7 +27056,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync19(outputPath) ? statSync4(outputPath).size : 0;
+      const fileSize = existsSync20(outputPath) ? statSync6(outputPath).size : 0;
       resolve39({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
@@ -26837,7 +27075,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
 }
 async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, options, chunkSizeFrames, signal) {
   const start = Date.now();
-  const files = readdirSync7(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i)).sort();
+  const files = readdirSync8(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i)).sort();
   if (files.length === 0) {
     return {
       success: false,
@@ -26850,8 +27088,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   }
   const chunkSize = Math.max(30, Math.floor(chunkSizeFrames));
   const chunkCount = Math.ceil(files.length / chunkSize);
-  const chunkDir = join22(dirname7(outputPath), "chunk-encode");
-  if (!existsSync19(chunkDir)) mkdirSync11(chunkDir, { recursive: true });
+  const chunkDir = join23(dirname7(outputPath), "chunk-encode");
+  if (!existsSync20(chunkDir)) mkdirSync11(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i2 = 0; i2 < chunkCount; i2++) {
     if (signal?.aborted) {
@@ -26867,8 +27105,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     const startNumber = i2 * chunkSize;
     const framesInChunk = Math.min(chunkSize, files.length - startNumber);
     const ext = outputPath.endsWith(".webm") ? ".webm" : outputPath.endsWith(".mov") ? ".mov" : ".mp4";
-    const chunkPath = join22(chunkDir, `chunk_${String(i2).padStart(4, "0")}${ext}`);
-    const inputPath = join22(framesDir, framePattern);
+    const chunkPath = join23(chunkDir, `chunk_${String(i2).padStart(4, "0")}${ext}`);
+    const inputPath = join23(framesDir, framePattern);
     const inputArgs = [
       "-framerate",
       String(options.fps),
@@ -26908,7 +27146,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     }
     chunkPaths.push(chunkPath);
   }
-  const concatListPath = join22(chunkDir, "concat-list.txt");
+  const concatListPath = join23(chunkDir, "concat-list.txt");
   const concatInput = chunkPaths.map((path2) => `file '${path2.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync12(concatListPath, concatInput, "utf-8");
   const concatArgs = [
@@ -26947,7 +27185,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync19(outputPath) ? statSync4(outputPath).size : 0;
+  const fileSize = existsSync20(outputPath) ? statSync6(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -26958,7 +27196,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config) {
   const outputDir = dirname7(outputPath);
-  if (!existsSync19(outputDir)) mkdirSync11(outputDir, { recursive: true });
+  if (!existsSync20(outputDir)) mkdirSync11(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
@@ -27029,7 +27267,7 @@ var init_chunkEncoder = __esm({
 
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, statSync as statSync5 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, statSync as statSync7 } from "fs";
 import { dirname as dirname8 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
@@ -27212,7 +27450,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
   const outputDir = dirname8(outputPath);
-  if (!existsSync20(outputDir)) mkdirSync12(outputDir, { recursive: true });
+  if (!existsSync21(outputDir)) mkdirSync12(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
@@ -27294,7 +27532,7 @@ Process error: ${err.message}`;
           error: formatFfmpegError(exitCode, stderr)
         };
       }
-      const fileSize = existsSync20(outputPath) ? statSync5(outputPath).size : 0;
+      const fileSize = existsSync21(outputPath) ? statSync7(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -27586,9 +27824,9 @@ var init_ffprobe = __esm({
 });
 
 // ../engine/src/utils/urlDownloader.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync21, mkdirSync as mkdirSync13 } from "fs";
+import { createWriteStream as createWriteStream2, existsSync as existsSync22, mkdirSync as mkdirSync13 } from "fs";
 import { createHash } from "crypto";
-import { join as join23, extname as extname5 } from "path";
+import { join as join24, extname as extname5 } from "path";
 import { Readable } from "stream";
 import { finished } from "stream/promises";
 function getFilenameFromUrl(url) {
@@ -27599,19 +27837,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync21(cachedPath)) {
+  if (cachedPath && existsSync22(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync21(destDir)) {
+  if (!existsSync22(destDir)) {
     mkdirSync13(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join23(destDir, filename);
-  if (existsSync21(localPath)) {
+  const localPath = join24(destDir, filename);
+  if (existsSync22(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -27703,12 +27941,12 @@ var init_htmlTemplate = __esm({
 
 // ../engine/src/services/extractionCache.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync14, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
-import { existsSync as existsSync22 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync14, readdirSync as readdirSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync23 } from "fs";
+import { join as join25 } from "path";
 function readKeyStat(videoPath) {
   try {
-    const stat3 = statSync6(videoPath);
+    const stat3 = statSync8(videoPath);
     return { mtimeMs: Math.floor(stat3.mtimeMs), size: stat3.size };
   } catch {
     return null;
@@ -27734,23 +27972,23 @@ function cacheEntryDirName(keyHash) {
 }
 function lookupCacheEntry(rootDir, input) {
   const keyHash = computeCacheKey(input);
-  const dir = join24(rootDir, cacheEntryDirName(keyHash));
-  const complete = existsSync22(join24(dir, COMPLETE_SENTINEL));
+  const dir = join25(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync23(join25(dir, COMPLETE_SENTINEL));
   return { entry: { dir, keyHash }, hit: complete };
 }
 function ensureCacheEntryDir(entry) {
   mkdirSync14(entry.dir, { recursive: true });
 }
 function markCacheEntryComplete(entry) {
-  writeFileSync13(join24(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
+  writeFileSync13(join25(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();
+  const files = readdirSync9(entry.dir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(suffix)).sort();
   files.forEach((file, idx) => {
-    framePaths.set(idx, join24(entry.dir, file));
+    framePaths.set(idx, join25(entry.dir, file));
   });
   return {
     videoId: options.videoId,
@@ -27776,8 +28014,8 @@ var init_extractionCache = __esm({
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn8 } from "child_process";
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readdirSync as readdirSync9, rmSync as rmSync5 } from "fs";
-import { isAbsolute as isAbsolute2, join as join25 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync15, readdirSync as readdirSync10, rmSync as rmSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join26 } from "path";
 function parseVideoElements(html) {
   const videos = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -27847,12 +28085,12 @@ function parseImageElements(html) {
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const { fps, outputDir, quality = 95 } = options;
-  const videoOutputDir = outputDirOverride ?? join25(outputDir, videoId);
-  if (!existsSync23(videoOutputDir)) mkdirSync15(videoOutputDir, { recursive: true });
+  const videoOutputDir = outputDirOverride ?? join26(outputDir, videoId);
+  if (!existsSync24(videoOutputDir)) mkdirSync15(videoOutputDir, { recursive: true });
   const metadata = await extractMediaMetadata(videoPath);
   const format = resolveFrameFormat(metadata, options.format);
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
-  const outputPattern = join25(videoOutputDir, framePattern);
+  const outputPattern = join26(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -27903,9 +28141,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
         return;
       }
       const framePaths = /* @__PURE__ */ new Map();
-      const files = readdirSync9(videoOutputDir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(`.${format}`)).sort();
+      const files = readdirSync10(videoOutputDir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(`.${format}`)).sort();
       files.forEach((file, index) => {
-        framePaths.set(index, join25(videoOutputDir, file));
+        framePaths.set(index, join26(videoOutputDir, file));
       });
       resolve39({
         videoId,
@@ -28032,15 +28270,15 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     try {
       let videoPath = video.src;
       if (!isAbsolute2(videoPath) && !isHttpUrl(videoPath)) {
-        const fromCompiled = compiledDir ? join25(compiledDir, videoPath) : null;
-        videoPath = fromCompiled && existsSync23(fromCompiled) ? fromCompiled : join25(baseDir, videoPath);
+        const fromCompiled = compiledDir ? join26(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync24(fromCompiled) ? fromCompiled : join26(baseDir, videoPath);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join25(options.outputDir, "_downloads");
+        const downloadDir = join26(options.outputDir, "_downloads");
         mkdirSync15(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(videoPath, downloadDir);
       }
-      if (!existsSync23(videoPath)) {
+      if (!existsSync24(videoPath)) {
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }
@@ -28073,7 +28311,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   const hdrSkippedIndices = /* @__PURE__ */ new Set();
   if (hdrInfo.hasHdr && hdrInfo.dominantTransfer) {
     const targetTransfer = hdrInfo.dominantTransfer;
-    const convertDir = join25(options.outputDir, "_hdr_normalized");
+    const convertDir = join26(options.outputDir, "_hdr_normalized");
     mkdirSync15(convertDir, { recursive: true });
     for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
       if (signal?.aborted) break;
@@ -28095,7 +28333,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
           const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
           segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
         }
-        const convertedPath = join25(convertDir, `${entry.video.id}_hdr.mp4`);
+        const convertedPath = join26(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
           await convertSdrToHdr(
             entry.videoPath,
@@ -28130,7 +28368,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
   }
   const vfrPreflightStart = Date.now();
-  const vfrNormDir = join25(options.outputDir, "_vfr_normalized");
+  const vfrNormDir = join26(options.outputDir, "_vfr_normalized");
   for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i2];
@@ -28145,7 +28383,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
     mkdirSync15(vfrNormDir, { recursive: true });
-    const normalizedPath = join25(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    const normalizedPath = join26(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
         entry.videoPath,
@@ -28401,7 +28639,7 @@ var init_videoFrameExtractor = __esm({
       cleanup() {
         for (const video of this.videos.values()) {
           if (video.extracted.ownedByLookup) continue;
-          if (existsSync23(video.extracted.outputDir)) {
+          if (existsSync24(video.extracted.outputDir)) {
             rmSync5(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -28737,8 +28975,8 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync16, rmSync as rmSync6 } from "fs";
-import { isAbsolute as isAbsolute3, join as join26, dirname as dirname9 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync16, rmSync as rmSync6 } from "fs";
+import { isAbsolute as isAbsolute3, join as join27, dirname as dirname9 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -28789,7 +29027,7 @@ function parseAudioElements(html) {
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname9(outputPath);
-  if (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
+  if (!existsSync25(outputDir)) mkdirSync16(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));
@@ -28816,7 +29054,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 = dirname9(outputPath);
-  if (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
+  if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -28852,7 +29090,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 = dirname9(outputPath);
-  if (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
+  if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -28895,7 +29133,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     };
   }
   const outputDir = dirname9(outputPath);
-  if (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
+  if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i2) => {
@@ -28956,7 +29194,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync24(workDir)) mkdirSync16(workDir, { recursive: true });
+  if (!existsSync25(workDir)) mkdirSync16(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -28966,8 +29204,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!isAbsolute3(srcPath) && !isHttpUrl(srcPath)) {
-          const fromCompiled = compiledDir ? join26(compiledDir, srcPath) : null;
-          srcPath = fromCompiled && existsSync24(fromCompiled) ? fromCompiled : join26(baseDir, srcPath);
+          const fromCompiled = compiledDir ? join27(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync25(fromCompiled) ? fromCompiled : join27(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -28979,7 +29217,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync24(srcPath)) {
+        if (!existsSync25(srcPath)) {
           errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
@@ -28990,7 +29228,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join26(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join27(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -29007,7 +29245,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join26(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join27(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -29061,9 +29299,9 @@ var init_audioMixer = __esm({
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus2, freemem, totalmem as totalmem2 } from "os";
-import { existsSync as existsSync25, mkdirSync as mkdirSync17, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync17, readdirSync as readdirSync11 } from "fs";
 import { copyFile, rename } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
   const effectiveMaxWorkers = (() => {
     const concurrency = config?.concurrency ?? DEFAULT_CONFIG2.concurrency;
@@ -29113,7 +29351,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i2,
       startFrame,
       endFrame,
-      outputDir: join27(workDir, `worker-${i2}`)
+      outputDir: join28(workDir, `worker-${i2}`)
     });
   }
   return tasks;
@@ -29121,7 +29359,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 (!existsSync25(task.outputDir)) mkdirSync17(task.outputDir, { recursive: true });
+  if (!existsSync26(task.outputDir)) mkdirSync17(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -29211,17 +29449,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync25(outputDir)) mkdirSync17(outputDir, { recursive: true });
+  if (!existsSync26(outputDir)) mkdirSync17(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync25(task.outputDir)) {
+    if (!existsSync26(task.outputDir)) {
       continue;
     }
-    const files = readdirSync10(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
+    const files = readdirSync11(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join27(task.outputDir, file);
-      const targetPath = join27(outputDir, file);
+      const sourcePath = join28(task.outputDir, file);
+      const targetPath = join28(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -29258,8 +29496,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 readFileSync18, existsSync as existsSync26, statSync as statSync7 } from "fs";
-import { join as join28, extname as extname6 } from "path";
+import { readFileSync as readFileSync18, existsSync as existsSync27, statSync as statSync9 } from "fs";
+import { join as join29, extname as extname6 } from "path";
 function stripEmbeddedRuntimeScripts(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -29328,12 +29566,12 @@ function createFileServer(options) {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join28(compiledDir, relativePath) : null;
+    const compiledPath = compiledDir ? join29(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync26(compiledPath) && statSync7(compiledPath).isFile()
+      compiledPath && existsSync27(compiledPath) && statSync9(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join28(projectDir, relativePath);
-    if (!existsSync26(filePath) || !statSync7(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join29(projectDir, relativePath);
+    if (!existsSync27(filePath) || !statSync9(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname6(filePath).toLowerCase();
@@ -30638,9 +30876,9 @@ var init_shaderTransitions = __esm({
 });
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync27, readdirSync as readdirSync11 } from "fs";
-import { join as join29 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync28, readdirSync as readdirSync12 } from "fs";
+import { join as join30 } from "path";
+import { homedir as homedir7 } from "os";
 function linearToPQ(L2) {
   const Lp = Math.max(0, L2 * SDR_NITS / PQ_MAX_NITS);
   const Lm1 = Math.pow(Lp, PQ_M12);
@@ -30755,12 +30993,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join29(homedir6(), ".cache", "puppeteer", "chrome");
-  if (!existsSync27(baseDir)) return void 0;
-  const versions = readdirSync11(baseDir).sort().reverse();
+  const baseDir = join30(homedir7(), ".cache", "puppeteer", "chrome");
+  if (!existsSync28(baseDir)) return void 0;
+  const versions = readdirSync12(baseDir).sort().reverse();
   for (const version of versions) {
     const candidates = [
-      join29(
+      join30(
         baseDir,
         version,
         "chrome-mac-arm64",
@@ -30769,7 +31007,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join29(
+      join30(
         baseDir,
         version,
         "chrome-mac-x64",
@@ -30778,11 +31016,11 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join29(baseDir, version, "chrome-linux64", "chrome"),
-      join29(baseDir, version, "chrome-win64", "chrome.exe")
+      join30(baseDir, version, "chrome-linux64", "chrome"),
+      join30(baseDir, version, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
-      if (existsSync27(binary)) return binary;
+      if (existsSync28(binary)) return binary;
     }
   }
   return void 0;
@@ -31309,8 +31547,8 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync19, existsSync as existsSync28 } from "fs";
-import { join as join30, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync29 } from "fs";
+import { join as join31, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
 import { transformSync } from "esbuild";
 function parseHTMLContent2(html) {
   const trimmed = html.trimStart().toLowerCase();
@@ -31378,7 +31616,7 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute4(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync28(filePath)) return null;
+  if (!existsSync29(filePath)) return null;
   try {
     return readFileSync19(filePath, "utf-8");
   } catch {
@@ -31386,7 +31624,7 @@ function safeReadFile(filePath) {
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync28(filePath)) return null;
+  if (!existsSync29(filePath)) return null;
   try {
     return readFileSync19(filePath);
   } catch {
@@ -31585,8 +31823,8 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join30(projectDir, "index.html");
-  if (!existsSync28(indexPath)) throw new Error("index.html not found in project directory");
+  const indexPath = join31(projectDir, "index.html");
+  if (!existsSync29(indexPath)) throw new Error("index.html not found in project directory");
   const rawHtml = readFileSync19(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
@@ -31741,6 +31979,15 @@ async function bundleToSingleHtml(projectDir, options) {
         el.setAttribute(attr, val);
       }
     );
+    const styledEls = innerRoot ? innerRoot.querySelectorAll("[style]") : contentDoc.querySelectorAll("[style]");
+    rewriteInlineStyleAssetUrls(
+      styledEls,
+      src,
+      (el) => el.getAttribute("style"),
+      (el, val) => {
+        el.setAttribute("style", val);
+      }
+    );
     if (innerRoot) {
       const innerW = innerRoot.getAttribute("data-width");
       const innerH = innerRoot.getAttribute("data-height");
@@ -31904,7 +32151,7 @@ var init_compiler = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync29, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync20 } from "fs";
 import { dirname as dirname10, resolve as resolve13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -31917,7 +32164,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync29(candidate)) {
+    if (existsSync30(candidate)) {
       return candidate;
     }
   }
@@ -31928,7 +32175,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync29(manifestPath)) {
+  if (!existsSync30(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
@@ -31942,7 +32189,7 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve13(dirname10(manifestPath), runtimeFileName);
-  if (!existsSync29(runtimePath)) {
+  if (!existsSync30(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync20(runtimePath, "utf8");
@@ -31984,16 +32231,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 readFileSync21, existsSync as existsSync30, realpathSync, statSync as statSync8 } from "fs";
-import { join as join31, extname as extname7, resolve as resolve14, sep as sep3 } from "path";
+import { readFileSync as readFileSync21, existsSync as existsSync31, realpathSync, statSync as statSync10 } from "fs";
+import { join as join32, 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 && existsSync30(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
-  const normalizedParent = resolveSymlinks && existsSync30(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
+  const normalizedChild = resolveSymlinks && existsSync31(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync31(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -32082,14 +32329,14 @@ function createFileServer2(options) {
     const relativePath = requestPath.replace(/^\//, "");
     let filePath = null;
     if (compiledDir) {
-      const candidate = join31(compiledDir, relativePath);
-      if (existsSync30(candidate) && isPathInside(candidate, compiledDir) && statSync8(candidate).isFile()) {
+      const candidate = join32(compiledDir, relativePath);
+      if (existsSync31(candidate) && isPathInside(candidate, compiledDir) && statSync10(candidate).isFile()) {
         filePath = candidate;
       }
     }
     if (!filePath) {
-      const candidate = join31(projectDir, relativePath);
-      if (existsSync30(candidate) && isPathInside(candidate, projectDir) && statSync8(candidate).isFile()) {
+      const candidate = join32(projectDir, relativePath);
+      if (existsSync31(candidate) && isPathInside(candidate, projectDir) && statSync10(candidate).isFile()) {
         filePath = candidate;
       }
     }
@@ -32463,7 +32710,7 @@ var init_ffprobe2 = __esm({
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve15, basename as basename2, join as join32, relative as relative2, isAbsolute as isAbsolute5 } from "path";
+import { resolve as resolve15, basename as basename2, join as join33, relative as relative2, isAbsolute as isAbsolute5 } from "path";
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve15(childPath);
   const absParent = resolve15(parentPath);
@@ -32484,7 +32731,7 @@ function toExternalAssetKey(absPath) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = resolve15(projectDir);
   const projectName = basename2(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join32(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join33(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve15(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -32557,9 +32804,9 @@ var init_fontData_generated = __esm({
 });
 
 // ../producer/src/services/deterministicFonts.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join33 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join34 } from "path";
 function normalizeFamilyName(family) {
   return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
 }
@@ -32670,14 +32917,14 @@ function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function fontCacheDir(slug) {
-  const dir = join33(GOOGLE_FONTS_CACHE_DIR, slug);
-  if (!existsSync31(dir)) {
+  const dir = join34(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync32(dir)) {
     mkdirSync18(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join33(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join34(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -32703,7 +32950,7 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match[3] || "";
     if (!woff2Url) continue;
     const cachePath2 = cachedWoff2Path(slug, weight, style);
-    if (!existsSync31(cachePath2)) {
+    if (!existsSync32(cachePath2)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
@@ -32889,14 +33136,14 @@ var init_deterministicFonts = __esm({
       poppins: "poppins",
       "segoe ui": "roboto"
     };
-    GOOGLE_FONTS_CACHE_DIR = join33(homedir7(), ".cache", "hyperframes", "fonts");
+    GOOGLE_FONTS_CACHE_DIR = join34(homedir8(), ".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 readFileSync23, existsSync as existsSync32, mkdirSync as mkdirSync19 } from "fs";
-import { join as join34, dirname as dirname11, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync23, existsSync as existsSync33, mkdirSync as mkdirSync19 } from "fs";
+import { join as join35, dirname as dirname11, resolve as resolve16 } from "path";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
   for (const element of elements) {
@@ -32957,16 +33204,16 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync32(downloadDir)) mkdirSync19(downloadDir, { recursive: true });
+    if (!existsSync33(downloadDir)) mkdirSync19(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join34(baseDir, filePath);
+    filePath = join35(baseDir, filePath);
   }
-  if (!existsSync32(filePath)) {
+  if (!existsSync33(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   let metadata;
@@ -33044,7 +33291,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync32(filePath)) {
+    if (!existsSync33(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync23(filePath, "utf-8");
@@ -33233,7 +33480,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve16(projectDir, srcPath);
-      if (existsSync32(filePath)) {
+      if (existsSync33(filePath)) {
         compHtml = readFileSync23(filePath, "utf-8");
       }
     }
@@ -33435,7 +33682,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync32(absPath)) return null;
+    if (!existsSync33(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -33786,20 +34033,20 @@ var init_hdrImageTransferCache = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync33,
+  existsSync as existsSync34,
   mkdirSync as mkdirSync20,
   rmSync as rmSync7,
   readFileSync as readFileSync24,
   openSync,
   readSync,
   closeSync,
-  readdirSync as readdirSync12,
-  statSync as statSync9,
+  readdirSync as readdirSync13,
+  statSync as statSync11,
   writeFileSync as writeFileSync15,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join35, dirname as dirname12, resolve as resolve17 } from "path";
+import { join as join36, dirname as dirname12, resolve as resolve17 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -33820,14 +34067,14 @@ function sampleDirectoryBytes(dir) {
     if (!current) continue;
     let entries2 = [];
     try {
-      entries2 = readdirSync12(current);
+      entries2 = readdirSync13(current);
     } catch {
       continue;
     }
     for (const name of entries2) {
-      const full = join35(current, name);
+      const full = join36(current, name);
       try {
-        const st2 = statSync9(full);
+        const st2 = statSync11(full);
         if (st2.isDirectory()) {
           stack.push(full);
         } else if (st2.isFile()) {
@@ -33988,16 +34235,16 @@ function installDebugLogger(logPath, log2 = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join35(workDir, "compiled");
+  const compileDir = join36(workDir, "compiled");
   mkdirSync20(compileDir, { recursive: true });
-  writeFileSync15(join35(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync15(join36(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join35(compileDir, srcPath);
+    const outPath = join36(compileDir, srcPath);
     mkdirSync20(dirname12(outPath), { recursive: true });
     writeFileSync15(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve17(join35(compileDir, relativePath));
+    const outPath = resolve17(join36(compileDir, relativePath));
     if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
@@ -34028,7 +34275,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       renderModeHints: compiled.renderModeHints,
       hasShaderTransitions: compiled.hasShaderTransitions
     };
-    writeFileSync15(join35(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync15(join36(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(cfg, compiled, log2 = defaultLogger) {
@@ -34154,8 +34401,8 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join35(framesDir, `frame_${String(frameIndex).padStart(6, "0")}.${frameExt}`);
-    const missing = !existsSync33(framePath);
+    const framePath = join36(framesDir, `frame_${String(frameIndex).padStart(6, "0")}.${frameExt}`);
+    const missing = !existsSync34(framePath);
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -34177,7 +34424,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt) {
       workerId,
       startFrame: range.startFrame,
       endFrame: range.endFrame,
-      outputDir: join35(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`)
+      outputDir: join36(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`)
     }));
     batches.push(batch);
   }
@@ -34201,8 +34448,8 @@ function shouldFallbackToScreenshotAfterCalibrationError(error) {
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join35(framesDir, `frame_${String(frameIndex).padStart(6, "0")}.${frameExt}`);
-    if (existsSync33(framePath)) captured++;
+    const framePath = join36(framesDir, `frame_${String(frameIndex).padStart(6, "0")}.${frameExt}`);
+    if (existsSync34(framePath)) captured++;
   }
   return captured;
 }
@@ -34239,7 +34486,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       frameCount,
       reason: attempt === 0 ? "initial" : "retry"
     });
-    const attemptWorkDir = join35(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join36(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(missingRanges, currentWorkers, attemptWorkDir, attempt) : [distributeFrames(options.totalFrames, currentWorkers, attemptWorkDir)];
     try {
       for (const tasks of batches) {
@@ -34656,7 +34903,7 @@ 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 = join35(debugDumpDir, dumpName);
+          const dumpPath = join36(debugDumpDir, dumpName);
           writeFileSync15(dumpPath, domPng);
           log2.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
@@ -34730,8 +34977,8 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
   const moduleDir = dirname12(fileURLToPath3(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve17(process.env.PRODUCER_RENDERS_DIR, "..") : resolve17(moduleDir, "../..");
-  const debugDir = join35(producerRoot, ".debug");
-  const workDir = job.config.debug ? join35(debugDir, job.id) : join35(dirname12(outputPath), `work-${job.id}`);
+  const debugDir = join36(producerRoot, ".debug");
+  const workDir = job.config.debug ? join36(debugDir, job.id) : join36(dirname12(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log2 = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -34744,7 +34991,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join35(workDir, "perf-summary.json");
+  const perfOutputPath = join36(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -34778,22 +35025,22 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync33(workDir)) mkdirSync20(workDir, { recursive: true });
+    if (!existsSync34(workDir)) mkdirSync20(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join35(workDir, "render.log");
+      const logPath = join36(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log2);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join35(projectDir, entryFile);
-    if (!existsSync33(htmlPath)) {
+    let htmlPath = join36(projectDir, entryFile);
+    if (!existsSync34(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync24(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join35(workDir, "standalone-entry.html");
-      const projectIndexPath = join35(projectDir, "index.html");
-      if (!existsSync33(projectIndexPath)) {
+      const wrapperPath = join36(workDir, "standalone-entry.html");
+      const projectIndexPath = join36(projectDir, "index.html");
+      if (!existsSync34(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -34816,7 +35063,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, join35(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join36(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     applyRenderModeHints(cfg, compiled, log2);
@@ -34848,7 +35095,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join35(workDir, "compiled"),
+        compiledDir: join36(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
@@ -34862,7 +35109,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join35(workDir, "probe"),
+        join36(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -34894,7 +35141,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join35(workDir, "downloads")
+            join36(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -35048,7 +35295,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 = join35(workDir, "compiled");
+    const compiledDir = join36(workDir, "compiled");
     let extractionResult = null;
     const nativeHdrVideoIds = /* @__PURE__ */ new Set();
     const videoTransfers = /* @__PURE__ */ new Map();
@@ -35057,10 +35304,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.videos.map(async (v) => {
           let videoPath = v.src;
           if (!videoPath.startsWith("/")) {
-            const fromCompiled = existsSync33(join35(compiledDir, videoPath)) ? join35(compiledDir, videoPath) : join35(projectDir, videoPath);
+            const fromCompiled = existsSync34(join36(compiledDir, videoPath)) ? join36(compiledDir, videoPath) : join36(projectDir, videoPath);
             videoPath = fromCompiled;
           }
-          if (!existsSync33(videoPath)) return;
+          if (!existsSync34(videoPath)) return;
           const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
@@ -35078,10 +35325,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.images.map(async (img) => {
           let imgPath = img.src;
           if (!imgPath.startsWith("/")) {
-            const fromCompiled = existsSync33(join35(compiledDir, imgPath)) ? join35(compiledDir, imgPath) : join35(projectDir, imgPath);
+            const fromCompiled = existsSync34(join36(compiledDir, imgPath)) ? join36(compiledDir, imgPath) : join36(projectDir, imgPath);
             imgPath = fromCompiled;
           }
-          if (!existsSync33(imgPath)) return null;
+          if (!existsSync34(imgPath)) return null;
           const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
@@ -35097,7 +35344,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join35(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join36(workDir, "video-frames") },
         abortSignal,
         { extractCacheDir: cfg.extractCacheDir },
         compiledDir
@@ -35180,13 +35427,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join35(workDir, "audio.aac");
+    const audioOutputPath = join36(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join35(workDir, "audio-work"),
+        join36(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -35204,14 +35451,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join35(workDir, "compiled"),
+        compiledDir: join36(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join35(workDir, "captured-frames");
-    if (!existsSync33(framesDir)) mkdirSync20(framesDir, { recursive: true });
+    const framesDir = join36(workDir, "captured-frames");
+    if (!existsSync34(framesDir)) mkdirSync20(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -35226,7 +35473,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     let captureCalibration;
     let switchedToScreenshotAfterCalibration = false;
     if (job.config.workers === void 0 && totalFrames >= 60) {
-      const calibrationDir = join35(workDir, "capture-calibration");
+      const calibrationDir = join36(workDir, "capture-calibration");
       const calibrationCfg = createCaptureCalibrationConfig(cfg);
       const videoInjector = createVideoFrameInjector(frameLookup);
       let calibrationSession = null;
@@ -35325,7 +35572,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       "png-sequence": ""
     };
     const videoExt = FORMAT_EXT2[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join35(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join36(workDir, `video-only${videoExt}`);
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
@@ -35349,8 +35596,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         if (!hdrVideoIds.includes(v.id)) continue;
         let srcPath = v.src;
         if (!srcPath.startsWith("/")) {
-          const fromCompiled = join35(compiledDir, srcPath);
-          srcPath = existsSync33(fromCompiled) ? fromCompiled : join35(projectDir, srcPath);
+          const fromCompiled = join36(compiledDir, srcPath);
+          srcPath = existsSync34(fromCompiled) ? fromCompiled : join36(projectDir, srcPath);
         }
         hdrVideoSrcPaths.set(v.id, srcPath);
       }
@@ -35480,11 +35727,11 @@ 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 = join35(framesDir, `hdr_${videoId}`);
+          const frameDir = join36(framesDir, `hdr_${videoId}`);
           mkdirSync20(frameDir, { recursive: true });
           const duration = video.end - video.start;
           const dims = hdrExtractionDims.get(videoId) ?? { width, height };
-          const rawPath = join35(frameDir, "frames.rgb48le");
+          const rawPath = join36(frameDir, "frames.rgb48le");
           const ffmpegArgs = [
             "-ss",
             String(video.mediaStart),
@@ -35516,7 +35763,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             );
           }
           const frameSize = dims.width * dims.height * 6;
-          const frameCount = Math.floor(statSync9(rawPath).size / frameSize);
+          const frameCount = Math.floor(statSync11(rawPath).size / frameSize);
           if (frameCount < 1) {
             hdrDiagnostics.videoExtractionFailures += 1;
             throw new Error(
@@ -35586,8 +35833,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
           const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-          const debugDumpDir = debugDumpEnabled ? join35(framesDir, "debug-composite") : null;
-          if (debugDumpDir && !existsSync33(debugDumpDir)) {
+          const debugDumpDir = debugDumpEnabled ? join36(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync34(debugDumpDir)) {
             mkdirSync20(debugDumpDir, { recursive: true });
           }
           if (!effectiveHdr) {
@@ -35771,7 +36018,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
               );
               addHdrTiming(hdrPerf, "normalCompositeMs", timingStart);
               if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-                const previewPath = join35(
+                const previewPath = join36(
                   debugDumpDir,
                   `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
                 );
@@ -36049,19 +36296,19 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           if (isPngSequence) {
             const stage5Start = Date.now();
             updateJobStatus(job, "encoding", "Writing PNG sequence", 75, onProgress);
-            if (!existsSync33(outputPath)) mkdirSync20(outputPath, { recursive: true });
-            const captured = readdirSync12(framesDir).filter((name) => name.endsWith(".png")).sort();
+            if (!existsSync34(outputPath)) mkdirSync20(outputPath, { recursive: true });
+            const captured = readdirSync13(framesDir).filter((name) => name.endsWith(".png")).sort();
             if (captured.length === 0) {
               throw new Error(
                 `[Render] png-sequence output requested but no PNGs were captured to ${framesDir}`
               );
             }
             captured.forEach((name, i2) => {
-              const dst = join35(outputPath, `frame_${String(i2 + 1).padStart(6, "0")}.png`);
-              copyFileSync2(join35(framesDir, name), dst);
+              const dst = join36(outputPath, `frame_${String(i2 + 1).padStart(6, "0")}.png`);
+              copyFileSync2(join36(framesDir, name), dst);
             });
-            if (hasAudio && existsSync33(audioOutputPath)) {
-              copyFileSync2(audioOutputPath, join35(outputPath, "audio.aac"));
+            if (hasAudio && existsSync34(audioOutputPath)) {
+              copyFileSync2(audioOutputPath, join36(outputPath, "audio.aac"));
               log2.info(
                 `[Render] png-sequence: audio.aac sidecar written to ${outputPath}/audio.aac`
               );
@@ -36153,7 +36400,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     updateJobStatus(job, "complete", "Render complete", 100, onProgress);
     const totalElapsed = Date.now() - pipelineStart;
     sampleMemory();
-    const tmpPeakBytes = existsSync33(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync34(workDir) ? sampleDirectoryBytes(workDir) : 0;
     const perfSummary = {
       renderId: job.id,
       totalElapsedMs: totalElapsed,
@@ -36195,8 +36442,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && existsSync33(outputPath)) {
-        const debugOutput = join35(workDir, `output${videoExt}`);
+      if (!isPngSequence && existsSync34(outputPath)) {
+        const debugOutput = join36(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else if (process.env.KEEP_TEMP === "1") {
@@ -36282,7 +36529,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync33(workDir)) rmSync7(workDir, { recursive: true, force: true });
+          if (existsSync34(workDir)) rmSync7(workDir, { recursive: true, force: true });
         },
         log2
       );
@@ -36344,8 +36591,8 @@ var init_config3 = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync34, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
-import { resolve as resolve18, join as join36 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync25, statSync as statSync12 } from "fs";
+import { resolve as resolve18, join as join37 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -36373,7 +36620,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve18(projectDir);
-  if (!existsSync34(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
+  if (!existsSync35(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -36384,7 +36631,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync34(absoluteEntryPath) && statSync10(absoluteEntryPath).isFile()) {
+    if (existsSync35(absoluteEntryPath) && statSync12(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync25(absoluteEntryPath, "utf-8"),
@@ -36393,7 +36640,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join36(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join37(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -36481,15 +36728,15 @@ var init_semaphore = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync35,
+  existsSync as existsSync36,
   mkdirSync as mkdirSync21,
-  statSync as statSync11,
+  statSync as statSync13,
   mkdtempSync as mkdtempSync2,
   writeFileSync as writeFileSync16,
   rmSync as rmSync8,
   createReadStream
 } from "fs";
-import { resolve as resolve19, dirname as dirname13, join as join37 } from "path";
+import { resolve as resolve19, dirname as dirname13, join as join38 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -36512,11 +36759,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve19(projectDir);
-    if (!existsSync35(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+    if (!existsSync36(absProjectDir) || !statSync13(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync35(resolve19(absProjectDir, entry))) {
+    if (!existsSync36(resolve19(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -36541,8 +36788,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync2(join37(tempRoot, "producer-project-"));
-  writeFileSync16(join37(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync2(join38(tempRoot, "producer-project-"));
+  writeFileSync16(join38(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -36665,7 +36912,7 @@ function createRenderHandlers(options = {}) {
       log2
     );
     const outputDir = dirname13(absoluteOutputPath);
-    if (!existsSync35(outputDir)) mkdirSync21(outputDir, { recursive: true });
+    if (!existsSync36(outputDir)) mkdirSync21(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log2.info("render started", {
       requestId,
@@ -36692,7 +36939,7 @@ function createRenderHandlers(options = {}) {
           log2.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync35(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+      const fileSize = existsSync36(absoluteOutputPath) ? statSync13(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -36776,7 +37023,7 @@ function createRenderHandlers(options = {}) {
         log2
       );
       const outputDir = dirname13(absoluteOutputPath);
-      if (!existsSync35(outputDir)) mkdirSync21(outputDir, { recursive: true });
+      if (!existsSync36(outputDir)) mkdirSync21(outputDir, { recursive: true });
       log2.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -36821,7 +37068,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync35(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+        const fileSize = existsSync36(absoluteOutputPath) ? statSync13(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log2.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -36880,11 +37127,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync35(artifact.path)) {
+    if (!existsSync36(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync11(artifact.path);
+    const stats = statSync13(artifact.path);
     return new Response(createReadStream(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -37018,20 +37265,20 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { existsSync as existsSync36, readFileSync as readFileSync26, writeFileSync as writeFileSync17, statSync as statSync12 } from "fs";
-import { resolve as resolve20, join as join38, basename as basename3 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync17, statSync as statSync14 } from "fs";
+import { resolve as resolve20, join as join39, basename as basename3 } from "path";
 function resolveDistDir() {
   return resolveStudioBundle().dir;
 }
 function resolveStudioBundle() {
   const builtPath = resolve20(__dirname, "studio");
   const builtIndex = resolve20(builtPath, "index.html");
-  if (existsSync36(builtIndex)) {
+  if (existsSync37(builtIndex)) {
     return { dir: builtPath, indexPath: builtIndex, available: true, checkedPaths: [builtIndex] };
   }
   const devPath = resolve20(__dirname, "..", "..", "..", "studio", "dist");
   const devIndex = resolve20(devPath, "index.html");
-  if (existsSync36(devIndex)) {
+  if (existsSync37(devIndex)) {
     return {
       dir: devPath,
       indexPath: devIndex,
@@ -37048,9 +37295,9 @@ function resolveStudioBundle() {
 }
 function resolveRuntimePath() {
   const builtPath = resolve20(__dirname, "hyperframe-runtime.js");
-  if (existsSync36(builtPath)) return builtPath;
+  if (existsSync37(builtPath)) return builtPath;
   const iifePath = resolve20(__dirname, "hyperframe.runtime.iife.js");
-  if (existsSync36(iifePath)) return iifePath;
+  if (existsSync37(iifePath)) return iifePath;
   const devPath = resolve20(
     __dirname,
     "..",
@@ -37060,7 +37307,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync36(devPath)) return devPath;
+  if (existsSync37(devPath)) return devPath;
   return builtPath;
 }
 async function getThumbnailBrowser() {
@@ -37122,7 +37369,7 @@ function createStudioServer(options) {
       return lintHyperframeHtml2(html, opts);
     },
     runtimeUrl: "/api/runtime.js",
-    rendersDir: () => join38(projectDir, "renders"),
+    rendersDir: () => join39(projectDir, "renders"),
     startRender(opts) {
       const state = {
         id: opts.jobId,
@@ -37194,34 +37441,40 @@ function createStudioServer(options) {
         await new Promise((r2) => setTimeout(r2, 200));
         let clip;
         if (opts.selector) {
-          clip = await page.evaluate((selector) => {
-            const el = document.querySelector(selector);
-            if (!(el instanceof HTMLElement)) return void 0;
-            const rect = el.getBoundingClientRect();
-            if (rect.width < 4 || rect.height < 4) return void 0;
-            const pad = 8;
-            const x4 = Math.max(0, rect.left - pad);
-            const y2 = Math.max(0, rect.top - pad);
-            const maxWidth = window.innerWidth - x4;
-            const maxHeight = window.innerHeight - y2;
-            return {
-              x: x4,
-              y: y2,
-              width: Math.max(1, Math.min(rect.width + pad * 2, maxWidth)),
-              height: Math.max(1, Math.min(rect.height + pad * 2, maxHeight))
-            };
-          }, opts.selector);
+          clip = await page.evaluate(
+            (selector, selectorIndex) => {
+              const matches2 = Array.from(document.querySelectorAll(selector)).filter(
+                (el2) => el2 instanceof HTMLElement
+              );
+              const safeIndex = Math.max(
+                0,
+                Math.min(matches2.length - 1, Math.floor(selectorIndex ?? 0))
+              );
+              const el = matches2[safeIndex] ?? null;
+              if (!(el instanceof HTMLElement)) return void 0;
+              const rect = el.getBoundingClientRect();
+              if (rect.width < 4 || rect.height < 4) return void 0;
+              const pad = 8;
+              const x4 = Math.max(0, rect.left - pad);
+              const y2 = Math.max(0, rect.top - pad);
+              const maxWidth = window.innerWidth - x4;
+              const maxHeight = window.innerHeight - y2;
+              return {
+                x: x4,
+                y: y2,
+                width: Math.max(1, Math.min(rect.width + pad * 2, maxWidth)),
+                height: Math.max(1, Math.min(rect.height + pad * 2, maxHeight))
+              };
+            },
+            opts.selector,
+            opts.selectorIndex
+          );
         }
-        const screenshot = await page.screenshot(
-          opts.format === "png" ? {
-            type: "png",
-            ...clip ? { clip } : {}
-          } : {
-            type: "jpeg",
-            quality: 80,
-            ...clip ? { clip } : {}
-          }
-        );
+        const screenshot = await page.screenshot({
+          type: "jpeg",
+          quality: 80,
+          ...clip ? { clip } : {}
+        });
         return screenshot;
       } catch {
         return null;
@@ -37242,7 +37495,7 @@ function createStudioServer(options) {
   });
   app.get("/api/runtime.js", (c2) => {
     const serve4 = async () => {
-      const runtimeSource = await loadRuntimeSource() ?? (existsSync36(runtimePath) ? readFileSync26(runtimePath, "utf-8") : null);
+      const runtimeSource = await loadRuntimeSource() ?? (existsSync37(runtimePath) ? readFileSync26(runtimePath, "utf-8") : null);
       if (!runtimeSource) return c2.text("runtime not available", 404);
       return c2.body(runtimeSource, 200, {
         "Content-Type": "text/javascript",
@@ -37278,7 +37531,7 @@ function createStudioServer(options) {
   });
   app.get("/assets/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync36(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync37(filePath) || !statSync14(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync26(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -37286,7 +37539,7 @@ function createStudioServer(options) {
   });
   app.get("/icons/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync36(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync37(filePath) || !statSync14(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync26(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -37294,7 +37547,7 @@ function createStudioServer(options) {
   });
   app.get("*", (c2) => {
     const indexPath = resolve20(studioDir, "index.html");
-    if (!existsSync36(indexPath)) {
+    if (!existsSync37(indexPath)) {
       return c2.html(
         `<!doctype html>
 <html>
@@ -37374,20 +37627,20 @@ __export(preview_exports, {
   examples: () => examples
 });
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync37, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync22 } from "fs";
-import { resolve as resolve21, dirname as dirname14, basename as basename4, join as join39 } from "path";
+import { existsSync as existsSync38, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync22 } from "fs";
+import { resolve as resolve21, dirname as dirname14, basename as basename4, join as join40 } 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(dirname14(thisFile), "..", "..", "..", "..");
-  const projectsDir = join39(repoRoot, "packages", "studio", "data", "projects");
+  const projectsDir = join40(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename4(dir);
-  const symlinkPath = join39(projectsDir, pName);
+  const symlinkPath = join40(projectsDir, pName);
   mkdirSync22(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync37(symlinkPath)) {
+    if (existsSync38(symlinkPath)) {
       try {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
@@ -37399,7 +37652,7 @@ async function runDevMode(dir, projectName) {
       } catch {
       }
     }
-    if (!existsSync37(symlinkPath)) {
+    if (!existsSync38(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -37407,7 +37660,7 @@ async function runDevMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview"));
   const s2 = be();
   s2.start("Starting studio...");
-  const studioPkgDir = join39(repoRoot, "packages", "studio");
+  const studioPkgDir = join40(repoRoot, "packages", "studio");
   const child = spawn9("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -37441,7 +37694,7 @@ async function runDevMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync37(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync38(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -37452,7 +37705,7 @@ async function runDevMode(dir, projectName) {
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join39(dir, "package.json"));
+    const req = createRequire(join40(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -37460,20 +37713,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir, projectName) {
-  const req = createRequire(join39(dir, "package.json"));
+  const req = createRequire(join40(dir, "package.json"));
   const studioPkgPath = dirname14(req.resolve("@hyperframes/studio/package.json"));
   const pName = projectName ?? basename4(dir);
-  const projectsDir = join39(studioPkgPath, "data", "projects");
-  const symlinkPath = join39(projectsDir, pName);
+  const projectsDir = join40(studioPkgPath, "data", "projects");
+  const symlinkPath = join40(projectsDir, pName);
   mkdirSync22(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync37(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync38(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve21(readlinkSync(symlinkPath)) !== resolve21(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
-    if (!existsSync37(symlinkPath)) {
+    if (!existsSync38(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -37512,7 +37765,7 @@ async function runLocalStudioMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync37(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync38(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -37688,8 +37941,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 = join39(dir, "index.html");
-        if (existsSync37(indexPath)) {
+        const indexPath = join40(dir, "index.html");
+        if (existsSync38(indexPath)) {
           const project = { dir, name: projectName, indexPath };
           const lintResult = lintProject(project);
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
@@ -37718,20 +37971,20 @@ __export(init_exports, {
   examples: () => examples2
 });
 import {
-  existsSync as existsSync38,
+  existsSync as existsSync39,
   mkdirSync as mkdirSync23,
   copyFileSync as copyFileSync3,
   cpSync,
   writeFileSync as writeFileSync18,
   readFileSync as readFileSync27,
-  readdirSync as readdirSync13
+  readdirSync as readdirSync14
 } from "fs";
-import { resolve as resolve22, basename as basename5, join as join40, dirname as dirname15 } from "path";
+import { resolve as resolve22, basename as basename5, join as join41, dirname as dirname15 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { execFileSync as execFileSync4, spawn as spawn10 } from "child_process";
+import { execFileSync as execFileSync5, spawn as spawn10 } from "child_process";
 function probeVideo(filePath) {
   try {
-    const raw = execFileSync4(
+    const raw = execFileSync5(
       "ffprobe",
       ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath],
       { encoding: "utf-8", timeout: 15e3 }
@@ -37798,7 +38051,7 @@ function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname15(fileURLToPath5(import.meta.url));
   const devPath = resolve22(base, ...devSegments);
   const builtPath = resolve22(base, ...builtSegments);
-  return existsSync38(devPath) ? devPath : builtPath;
+  return existsSync39(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -37807,7 +38060,7 @@ function getSharedTemplateDir() {
   return resolveAssetDir(["..", "templates", "_shared"], ["templates", "_shared"]);
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync13(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join40(e2.parentPath ?? e2.path, e2.name));
+  const htmlFiles = readdirSync14(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join41(e2.parentPath ?? e2.path, e2.name));
   for (const file of htmlFiles) {
     let content = readFileSync27(file, "utf-8");
     if (videoFilename) {
@@ -37914,7 +38167,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
   mkdirSync23(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
-  if (existsSync38(templateDir)) {
+  if (existsSync39(templateDir)) {
     cpSync(templateDir, destDir, { recursive: true });
   } else {
     await fetchRemoteTemplate(templateId, destDir);
@@ -37933,14 +38186,14 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync38(resolve22(destDir, "hyperframes.json"))) {
+  if (!existsSync39(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 (existsSync38(sharedDir)) {
-    for (const entry of readdirSync13(sharedDir, { withFileTypes: true })) {
-      const src = join40(sharedDir, entry.name);
+  if (existsSync39(sharedDir)) {
+    for (const entry of readdirSync14(sharedDir, { withFileTypes: true })) {
+      const src = join41(sharedDir, entry.name);
       const dest = resolve22(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
@@ -38054,7 +38307,7 @@ var init_init = __esm({
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve22(name2);
-          if (existsSync38(destDir2) && readdirSync13(destDir2).length > 0) {
+          if (existsSync39(destDir2) && readdirSync14(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
@@ -38068,7 +38321,7 @@ var init_init = __esm({
           }
           if (videoFlag) {
             const videoPath = resolve22(videoFlag);
-            if (!existsSync38(videoPath)) {
+            if (!existsSync39(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -38082,7 +38335,7 @@ var init_init = __esm({
           }
           if (audioFlag) {
             const audioPath = resolve22(audioFlag);
-            if (!existsSync38(audioPath)) {
+            if (!existsSync39(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -38128,11 +38381,11 @@ var init_init = __esm({
           }
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve22(destDir2, "transcript.json");
-          if (existsSync38(transcriptFile2)) {
+          if (existsSync39(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f3 of readdirSync13(destDir2).filter((f4) => !f4.startsWith("."))) {
+          for (const f3 of readdirSync14(destDir2).filter((f4) => !f4.startsWith("."))) {
             console.log(`  ${c.accent(f3)}`);
           }
           console.log();
@@ -38180,7 +38433,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve22(name);
-        if (existsSync38(destDir) && readdirSync13(destDir).length > 0) {
+        if (existsSync39(destDir) && readdirSync14(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -38195,7 +38448,7 @@ var init_init = __esm({
         let videoDuration;
         if (videoFlag) {
           const videoPath = resolve22(videoFlag);
-          if (!existsSync38(videoPath)) {
+          if (!existsSync39(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -38207,7 +38460,7 @@ var init_init = __esm({
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
           const audioPath = resolve22(audioFlag);
-          if (!existsSync38(audioPath)) {
+          if (!existsSync39(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -38300,10 +38553,10 @@ ${c.dim("Use --example blank for offline use.")}`
         }
         trackInitTemplate(templateId);
         const transcriptFile = resolve22(destDir, "transcript.json");
-        if (existsSync38(transcriptFile)) {
+        if (existsSync39(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
-        const files = readdirSync13(destDir);
+        const files = readdirSync14(destDir);
         Vt2(files.map((f3) => c.accent(f3)).join("\n"), c.success(`Created ${name}/`));
         if (!skipSkills) {
           const installSkills = await Rt({
@@ -38332,9 +38585,9 @@ ${c.dim("Use --example blank for offline use.")}`
 
 // src/utils/clipboard.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { platform as platform3 } from "os";
+import { platform as platform4 } from "os";
 function detectProvider() {
-  const os = platform3();
+  const os = platform4();
   if (os === "darwin") {
     return { cmd: "pbcopy", args: [] };
   }
@@ -38386,7 +38639,7 @@ __export(add_exports, {
   remapTarget: () => remapTarget,
   runAdd: () => runAdd
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { resolve as resolve23, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
@@ -38412,8 +38665,8 @@ function buildSnippet(item, relativeTarget) {
 async function runAdd(opts) {
   const projectDir = resolve23(opts.projectDir);
   let config = loadProjectConfig(projectDir);
-  const hasConfig = existsSync39(projectConfigPath(projectDir));
-  if (!hasConfig && existsSync39(resolve23(projectDir, "index.html"))) {
+  const hasConfig = existsSync40(projectConfigPath(projectDir));
+  if (!hasConfig && existsSync40(resolve23(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -38512,10 +38765,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 = existsSync39(projectConfigPath(projectDir));
+        const hasConfigBefore = existsSync40(projectConfigPath(projectDir));
         try {
           const result = await runAdd({ name: args.name, projectDir, skipClipboard });
-          const wroteConfig = !hasConfigBefore && existsSync39(projectConfigPath(projectDir));
+          const wroteConfig = !hasConfigBefore && existsSync40(projectConfigPath(projectDir));
           if (json) {
             console.log(JSON.stringify(result));
             return;
@@ -38725,17 +38978,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync40, statSync as statSync13 } from "fs";
+import { existsSync as existsSync41, statSync as statSync15 } 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 (!existsSync40(dir) || !statSync13(dir).isDirectory()) {
+  if (!existsSync41(dir) || !statSync15(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync40(indexPath)) {
+  if (!existsSync41(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -38758,7 +39011,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync41, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync28 } from "fs";
 import { resolve as resolve26, dirname as dirname16 } from "path";
 function commandDir() {
   return dirname16(new URL(import.meta.url).pathname);
@@ -38773,7 +39026,7 @@ function resolveRuntimePath2() {
     resolve26(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
-    if (existsSync41(p)) return p;
+    if (existsSync42(p)) return p;
   }
   return null;
 }
@@ -38787,7 +39040,7 @@ function resolvePlayerPath() {
     resolve26(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
-    if (existsSync41(p)) return p;
+    if (existsSync42(p)) return p;
   }
   return null;
 }
@@ -38889,7 +39142,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 (!existsSync41(filePath)) return ctx.text("Not found", 404);
+          if (!existsSync42(filePath)) return ctx.text("Not found", 404);
           const content = readFileSync28(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
@@ -38965,14 +39218,14 @@ var init_play = __esm({
 });
 
 // src/utils/publishProject.ts
-import { basename as basename7, join as join41, relative as relative4 } from "path";
-import { readdirSync as readdirSync14, readFileSync as readFileSync29, statSync as statSync14 } from "fs";
+import { basename as basename7, join as join42, relative as relative4 } from "path";
+import { readdirSync as readdirSync15, readFileSync as readFileSync29, statSync as statSync16 } from "fs";
 import AdmZip from "adm-zip";
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function dataRecord(payload) {
-  if (!isRecord(payload) || !isRecord(payload["data"])) return null;
+  if (!isRecord2(payload) || !isRecord2(payload["data"])) return null;
   return payload["data"];
 }
 function stringField(record, key2) {
@@ -39015,7 +39268,7 @@ function parseStagedUploadResponse(payload, archiveByteLength) {
 function getUploadHeaders(data, uploadUrl, contentType, archiveByteLength) {
   const headers = {};
   const uploadHeaders = data["upload_headers"];
-  if (isRecord(uploadHeaders)) {
+  if (isRecord2(uploadHeaders)) {
     for (const [key2, value] of Object.entries(uploadHeaders)) {
       if (typeof value === "string" && key2.trim()) {
         headers[key2] = value;
@@ -39041,7 +39294,7 @@ async function readErrorMessage(response, fallback) {
   const contentType = response.headers.get("content-type") || "";
   if (contentType.includes("application/json")) {
     const payload = await readJson(response);
-    if (isRecord(payload) && typeof payload["message"] === "string") {
+    if (isRecord2(payload) && typeof payload["message"] === "string") {
       return payload["message"];
     }
   }
@@ -39055,16 +39308,16 @@ function shouldIgnoreSegment(segment) {
   return segment.startsWith(".") || IGNORED_DIRS.has(segment) || IGNORED_FILES.has(segment);
 }
 function collectProjectFiles(rootDir, currentDir, paths) {
-  for (const entry of readdirSync14(currentDir, { withFileTypes: true })) {
+  for (const entry of readdirSync15(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
-    const absolutePath = join41(currentDir, entry.name);
+    const absolutePath = join42(currentDir, entry.name);
     const relativePath = relative4(rootDir, absolutePath).replaceAll("\\", "/");
     if (!relativePath) continue;
     if (entry.isDirectory()) {
       collectProjectFiles(rootDir, absolutePath, paths);
       continue;
     }
-    if (!statSync14(absolutePath).isFile()) continue;
+    if (!statSync16(absolutePath).isFile()) continue;
     paths.push(relativePath);
   }
 }
@@ -39076,7 +39329,7 @@ function createPublishArchive(projectDir) {
   }
   const archive = new AdmZip();
   for (const filePath of filePaths) {
-    archive.addFile(filePath, readFileSync29(join41(projectDir, filePath)));
+    archive.addFile(filePath, readFileSync29(join42(projectDir, filePath)));
   }
   return {
     buffer: archive.toBuffer(),
@@ -39192,8 +39445,8 @@ __export(publish_exports, {
   examples: () => examples6
 });
 import { basename as basename8, resolve as resolve27 } from "path";
-import { existsSync as existsSync42 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync43 } from "fs";
+import { join as join43 } from "path";
 var examples6, publish_default;
 var init_publish = __esm({
   "src/commands/publish.ts"() {
@@ -39228,8 +39481,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 = join42(dir, "index.html");
-        if (existsSync42(indexPath)) {
+        const indexPath = join43(dir, "index.html");
+        if (existsSync43(indexPath)) {
           const lintResult = lintProject({ dir, name: projectName, indexPath });
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
             console.log();
@@ -39400,10 +39653,10 @@ __export(render_exports, {
   default: () => render_default,
   examples: () => examples7
 });
-import { mkdirSync as mkdirSync24, readFileSync as readFileSync30, statSync as statSync15, writeFileSync as writeFileSync19, rmSync as rmSync9 } from "fs";
+import { mkdirSync as mkdirSync24, readFileSync as readFileSync30, statSync as statSync17, writeFileSync as writeFileSync19, rmSync as rmSync9 } from "fs";
 import { cpus as cpus3, freemem as freemem3, tmpdir as tmpdir4 } from "os";
-import { resolve as resolve28, dirname as dirname17, join as join43, basename as basename9 } from "path";
-import { execFileSync as execFileSync5, spawn as spawn11 } from "child_process";
+import { resolve as resolve28, dirname as dirname17, join as join44, basename as basename9 } from "path";
+import { execFileSync as execFileSync6, spawn as spawn11 } from "child_process";
 function dockerImageTag(version) {
   return `${DOCKER_IMAGE_PREFIX}:${version}`;
 }
@@ -39412,7 +39665,7 @@ function resolveDockerfilePath() {
   const devPath = resolve28(__dirname, "..", "src", "docker", "Dockerfile.render");
   for (const p of [builtPath, devPath]) {
     try {
-      statSync15(p);
+      statSync17(p);
       return p;
     } catch {
       continue;
@@ -39422,7 +39675,7 @@ function resolveDockerfilePath() {
 }
 function dockerImageExists(tag) {
   try {
-    execFileSync5("docker", ["image", "inspect", tag], { stdio: "pipe", timeout: 1e4 });
+    execFileSync6("docker", ["image", "inspect", tag], { stdio: "pipe", timeout: 1e4 });
     return true;
   } catch {
     return false;
@@ -39436,11 +39689,11 @@ function ensureDockerImage(version, quiet) {
   }
   if (!quiet) console.log(c.dim(`  Building Docker image: ${tag}...`));
   const dockerfilePath = resolveDockerfilePath();
-  const tmpDir = join43(tmpdir4(), `hyperframes-docker-${Date.now()}`);
+  const tmpDir = join44(tmpdir4(), `hyperframes-docker-${Date.now()}`);
   mkdirSync24(tmpDir, { recursive: true });
-  writeFileSync19(join43(tmpDir, "Dockerfile"), readFileSync30(dockerfilePath));
+  writeFileSync19(join44(tmpDir, "Dockerfile"), readFileSync30(dockerfilePath));
   try {
-    execFileSync5(
+    execFileSync6(
       "docker",
       [
         "build",
@@ -39625,7 +39878,7 @@ function printRenderComplete(outputPath, elapsedMs, quiet) {
   if (quiet) return;
   let fileSize = "unknown";
   try {
-    fileSize = formatBytes(statSync15(outputPath).size);
+    fileSize = formatBytes(statSync17(outputPath).size);
   } catch {
   }
   const duration = formatDuration(elapsedMs);
@@ -39791,7 +40044,7 @@ var init_render2 = __esm({
         const now = /* @__PURE__ */ new Date();
         const datePart = now.toISOString().slice(0, 10);
         const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
-        const outputPath = args.output ? resolve28(args.output) : join43(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        const outputPath = args.output ? resolve28(args.output) : join44(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
         mkdirSync24(dirname17(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
@@ -40270,8 +40523,8 @@ __export(layout_exports, {
   examples: () => examples9
 });
 import { createServer } from "http";
-import { existsSync as existsSync43, readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname18, isAbsolute as isAbsolute6, join as join44, relative as relative5, resolve as resolve29 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync31 } from "fs";
+import { dirname as dirname18, isAbsolute as isAbsolute6, join as join45, relative as relative5, resolve as resolve29 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -40341,7 +40594,7 @@ async function bundleProjectHtml(projectDir) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync43(runtimePath)) {
+  if (existsSync44(runtimePath)) {
     const runtimeSource = readFileSync31(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -40366,7 +40619,7 @@ async function serveProject(projectDir, html) {
       res.end();
       return;
     }
-    if (existsSync43(filePath)) {
+    if (existsSync44(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync31(filePath));
       return;
@@ -40470,11 +40723,11 @@ async function runLayoutAudit(projectDir, opts) {
 }
 function loadLayoutAuditScript() {
   const candidates = [
-    join44(__dirname2, "layout-audit.browser.js"),
-    join44(__dirname2, "commands", "layout-audit.browser.js")
+    join45(__dirname2, "layout-audit.browser.js"),
+    join45(__dirname2, "commands", "layout-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync43(candidate)) return readFileSync31(candidate, "utf-8");
+    if (existsSync44(candidate)) return readFileSync31(candidate, "utf-8");
   }
   throw new Error("Missing layout audit browser script");
 }
@@ -40694,16 +40947,16 @@ __export(info_exports, {
   default: () => info_default,
   examples: () => examples11
 });
-import { readFileSync as readFileSync32, readdirSync as readdirSync15, statSync as statSync16 } from "fs";
-import { join as join45 } from "path";
+import { readFileSync as readFileSync32, readdirSync as readdirSync16, statSync as statSync18 } from "fs";
+import { join as join46 } from "path";
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync15(dir, { withFileTypes: true })) {
-    const path2 = join45(dir, entry.name);
+  for (const entry of readdirSync16(dir, { withFileTypes: true })) {
+    const path2 = join46(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
     } else {
-      total += statSync16(path2).size;
+      total += statSync18(path2).size;
     }
   }
   return total;
@@ -40787,7 +41040,7 @@ __export(compositions_exports, {
   default: () => compositions_default,
   examples: () => examples12
 });
-import { existsSync as existsSync44, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync33 } from "fs";
 import { resolve as resolve30, dirname as dirname19 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
@@ -40801,7 +41054,7 @@ function parseCompositions(html, baseDir) {
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
       const subPath = resolve30(baseDir, compositionSrc);
-      if (existsSync44(subPath)) {
+      if (existsSync45(subPath)) {
         const subHtml = readFileSync33(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
@@ -40934,8 +41187,8 @@ __export(benchmark_exports, {
   default: () => benchmark_default,
   examples: () => examples13
 });
-import { existsSync as existsSync45, statSync as statSync17 } from "fs";
-import { resolve as resolve31, join as join46 } from "path";
+import { existsSync as existsSync46, statSync as statSync19 } from "fs";
+import { resolve as resolve31, join as join47 } from "path";
 var examples13, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -41010,7 +41263,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 = join46(
+            const outputPath = join47(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i2}.mp4`
             );
@@ -41024,8 +41277,8 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync45(outputPath)) {
-                const stat3 = statSync17(outputPath);
+              if (existsSync46(outputPath)) {
+                const stat3 = statSync19(outputPath);
                 fileSize = stat3.size;
               }
               runs.push({ elapsedMs, fileSize });
@@ -41240,8 +41493,8 @@ __export(transcribe_exports2, {
   default: () => transcribe_default,
   examples: () => examples15
 });
-import { existsSync as existsSync46, writeFileSync as writeFileSync20 } from "fs";
-import { resolve as resolve32, join as join47, extname as extname8 } from "path";
+import { existsSync as existsSync47, writeFileSync as writeFileSync20 } from "fs";
+import { resolve as resolve32, join as join48, 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);
@@ -41249,7 +41502,7 @@ async function importTranscript(inputPath, dir, json) {
     console.error(c.error("No words found in transcript."));
     process.exit(1);
   }
-  const outPath = join47(dir, "transcript.json");
+  const outPath = join48(dir, "transcript.json");
   writeFileSync20(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
@@ -41366,7 +41619,7 @@ var init_transcribe2 = __esm({
       },
       async run({ args }) {
         const inputPath = resolve32(args.input);
-        if (!existsSync46(inputPath)) {
+        if (!existsSync47(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
@@ -41387,9 +41640,9 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync47, mkdirSync as mkdirSync25 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join48 } from "path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync25 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join49 } from "path";
 function inferLangFromVoiceId(voiceId) {
   const first = voiceId.charAt(0).toLowerCase();
   return VOICE_PREFIX_LANG[first] ?? "en-us";
@@ -41398,8 +41651,8 @@ function isSupportedLang(value) {
   return SUPPORTED_LANGS.includes(value);
 }
 async function ensureModel2(model = DEFAULT_MODEL2, options) {
-  const modelPath = join48(MODELS_DIR2, `${model}.onnx`);
-  if (existsSync47(modelPath)) return modelPath;
+  const modelPath = join49(MODELS_DIR2, `${model}.onnx`);
+  if (existsSync48(modelPath)) return modelPath;
   const url = MODEL_URLS[model];
   if (!url) {
     throw new Error(
@@ -41409,18 +41662,18 @@ async function ensureModel2(model = DEFAULT_MODEL2, options) {
   mkdirSync25(MODELS_DIR2, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath);
-  if (!existsSync47(modelPath)) {
+  if (!existsSync48(modelPath)) {
     throw new Error(`Model download failed: ${model}`);
   }
   return modelPath;
 }
 async function ensureVoices(options) {
-  const voicesPath = join48(VOICES_DIR, "voices-v1.0.bin");
-  if (existsSync47(voicesPath)) return voicesPath;
+  const voicesPath = join49(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync48(voicesPath)) return voicesPath;
   mkdirSync25(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
-  if (!existsSync47(voicesPath)) {
+  if (!existsSync48(voicesPath)) {
     throw new Error("Voice data download failed");
   }
   return voicesPath;
@@ -41430,9 +41683,9 @@ var init_manager3 = __esm({
   "src/tts/manager.ts"() {
     "use strict";
     init_download();
-    CACHE_DIR3 = join48(homedir8(), ".cache", "hyperframes", "tts");
-    MODELS_DIR2 = join48(CACHE_DIR3, "models");
-    VOICES_DIR = join48(CACHE_DIR3, "voices");
+    CACHE_DIR3 = join49(homedir9(), ".cache", "hyperframes", "tts");
+    MODELS_DIR2 = join49(CACHE_DIR3, "models");
+    VOICES_DIR = join49(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"
@@ -41492,22 +41745,22 @@ var synthesize_exports = {};
 __export(synthesize_exports, {
   synthesize: () => synthesize
 });
-import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync48, writeFileSync as writeFileSync21, mkdirSync as mkdirSync26, readdirSync as readdirSync16, unlinkSync as unlinkSync6 } from "fs";
-import { join as join49, dirname as dirname20, basename as basename10 } from "path";
-import { homedir as homedir9 } from "os";
+import { execFileSync as execFileSync7 } from "child_process";
+import { existsSync as existsSync49, writeFileSync as writeFileSync21, mkdirSync as mkdirSync26, readdirSync as readdirSync17, unlinkSync as unlinkSync6 } from "fs";
+import { join as join50, dirname as dirname20, basename as basename10 } from "path";
+import { homedir as homedir10 } from "os";
 function findPython() {
   for (const name of ["python3", "python"]) {
     try {
       const cmd = process.platform === "win32" ? "where" : "which";
-      const output = execFileSync6(cmd, [name], {
+      const output = execFileSync7(cmd, [name], {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 5e3
       });
       const first = output.split(/\r?\n/).map((s2) => s2.trim()).find(Boolean);
       if (!first) continue;
-      const version = execFileSync6(first, ["--version"], {
+      const version = execFileSync7(first, ["--version"], {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 5e3
@@ -41520,7 +41773,7 @@ function findPython() {
 }
 function hasPythonPackage(python, pkg) {
   try {
-    execFileSync6(python, ["-c", `import ${pkg}`], {
+    execFileSync7(python, ["-c", `import ${pkg}`], {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     });
@@ -41530,15 +41783,15 @@ function hasPythonPackage(python, pkg) {
   }
 }
 function ensureSynthScript() {
-  if (!existsSync48(SCRIPT_PATH)) {
+  if (!existsSync49(SCRIPT_PATH)) {
     mkdirSync26(SCRIPT_DIR, { recursive: true });
     writeFileSync21(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename10(SCRIPT_PATH);
     try {
-      for (const entry of readdirSync16(SCRIPT_DIR)) {
+      for (const entry of readdirSync17(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync6(join49(SCRIPT_DIR, entry));
+            unlinkSync6(join50(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -41575,7 +41828,7 @@ async function synthesize(text, outputPath, options) {
   mkdirSync26(dirname20(outputPath), { recursive: true });
   options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
   try {
-    const stdout2 = execFileSync6(
+    const stdout2 = execFileSync7(
       python,
       [scriptPath, modelPath, voicesPath, text, voice, String(speed), outputPath, lang],
       {
@@ -41584,7 +41837,7 @@ async function synthesize(text, outputPath, options) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    if (!existsSync48(outputPath)) {
+    if (!existsSync49(outputPath)) {
       throw new Error("Synthesis completed but no output file was created");
     }
     const lines = stdout2.trim().split("\n");
@@ -41597,7 +41850,7 @@ async function synthesize(text, outputPath, options) {
       langApplied: result.langApplied
     };
   } catch (err) {
-    if (err instanceof SyntaxError && existsSync48(outputPath)) {
+    if (err instanceof SyntaxError && existsSync49(outputPath)) {
       throw new Error(
         "Speech was generated but metadata could not be read. Check the output file manually."
       );
@@ -41648,8 +41901,8 @@ print(json.dumps({
     "langApplied": bool(lang and supports_lang),
 }))
 `;
-    SCRIPT_DIR = join49(homedir9(), ".cache", "hyperframes", "tts");
-    SCRIPT_PATH = join49(SCRIPT_DIR, "synth-v2.py");
+    SCRIPT_DIR = join50(homedir10(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join50(SCRIPT_DIR, "synth-v2.py");
   }
 });
 
@@ -41659,7 +41912,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples16
 });
-import { existsSync as existsSync49, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync50, readFileSync as readFileSync34 } from "fs";
 import { resolve as resolve33, extname as extname9 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v) => ({ ...v, defaultLang: inferLangFromVoiceId(v.id) }));
@@ -41769,7 +42022,7 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve33(args.input);
-        if (existsSync49(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
+        if (existsSync50(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync34(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
@@ -41862,15 +42115,15 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples17
 });
-import { readFileSync as readFileSync35, existsSync as existsSync50 } from "fs";
-import { resolve as resolve34, dirname as dirname21, join as join50 } from "path";
+import { readFileSync as readFileSync35, existsSync as existsSync51 } from "fs";
+import { resolve as resolve34, dirname as dirname21, join as join51 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath7(import.meta.url);
   const dir = dirname21(thisFile);
   const devPath = resolve34(dir, "..", "docs");
   const builtPath = resolve34(dir, "docs");
-  return existsSync50(devPath) ? devPath : builtPath;
+  return existsSync51(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -41967,8 +42220,8 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join50(docsDir(), entry.file);
-        if (!existsSync50(filePath)) {
+        const filePath = join51(docsDir(), entry.file);
+        if (!existsSync51(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
@@ -41987,7 +42240,7 @@ __export(doctor_exports, {
   examples: () => examples18
 });
 import { execSync as execSync3 } from "child_process";
-import { freemem as freemem4, platform as platform4 } from "os";
+import { freemem as freemem4, platform as platform5 } from "os";
 function checkFFmpeg() {
   const path2 = findFFmpeg();
   if (path2) {
@@ -42152,7 +42405,7 @@ var init_doctor = __esm({
           { name: "Memory", run: checkMemory },
           { name: "Disk", run: checkDisk }
         ];
-        if (platform4() === "linux") {
+        if (platform5() === "linux") {
           checks.push({ name: "/dev/shm", run: checkShm });
         }
         checks.push(
@@ -42384,20 +42637,11 @@ Run ${c.accent("hyperframes telemetry --help")} for usage.`
 // src/commands/validate.ts
 var validate_exports = {};
 __export(validate_exports, {
-  default: () => validate_default,
-  shouldIgnoreRequestFailure: () => shouldIgnoreRequestFailure
+  default: () => validate_default
 });
-import { existsSync as existsSync51, readFileSync as readFileSync36 } from "fs";
-import { resolve as resolve35, join as join51, dirname as dirname22 } from "path";
+import { existsSync as existsSync52, readFileSync as readFileSync36 } from "fs";
+import { resolve as resolve35, join as join52, dirname as dirname22 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
-function shouldIgnoreRequestFailure(url, errorText) {
-  if (errorText !== "net::ERR_ABORTED") return false;
-  try {
-    return MEDIA_EXTENSIONS.test(new URL(url).pathname);
-  } catch {
-    return false;
-  }
-}
 async function getCompositionDuration3(page) {
   return page.evaluate(() => {
     if (window.__hf?.duration && window.__hf.duration > 0) return window.__hf.duration;
@@ -42440,11 +42684,11 @@ async function runContrastAudit(page) {
 }
 function loadContrastAuditScript() {
   const candidates = [
-    join51(__dirname3, "contrast-audit.browser.js"),
-    join51(__dirname3, "commands", "contrast-audit.browser.js")
+    join52(__dirname3, "contrast-audit.browser.js"),
+    join52(__dirname3, "commands", "contrast-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync51(candidate)) return readFileSync36(candidate, "utf-8");
+    if (existsSync52(candidate)) return readFileSync36(candidate, "utf-8");
   }
   throw new Error("Missing contrast audit browser script");
 }
@@ -42461,7 +42705,7 @@ async function validateInBrowser(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync51(runtimePath)) {
+  if (existsSync52(runtimePath)) {
     const runtimeSource = readFileSync36(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -42477,8 +42721,8 @@ async function validateInBrowser(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = join51(projectDir, decodeURIComponent(url));
-    if (existsSync51(filePath)) {
+    const filePath = join52(projectDir, decodeURIComponent(url));
+    if (existsSync52(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync36(filePath));
       return;
@@ -42522,12 +42766,10 @@ async function validateInBrowser(projectDir, opts) {
     page.on("requestfailed", (req) => {
       const url = req.url();
       if (url.includes("favicon") || url.startsWith("data:")) return;
-      const failureText = req.failure()?.errorText;
-      if (shouldIgnoreRequestFailure(url, failureText)) return;
       const path2 = decodeURIComponent(new URL(url).pathname).replace(/^\//, "");
       errors.push({
         level: "error",
-        text: `Failed to load ${path2}: ${failureText ?? "net::ERR_FAILED"}`,
+        text: `Failed to load ${path2}: ${req.failure()?.errorText ?? "net::ERR_FAILED"}`,
         url
       });
     });
@@ -42560,7 +42802,7 @@ function printContrastFailures(failures) {
     );
   }
 }
-var __filename2, __dirname3, CONTRAST_SAMPLES, SEEK_SETTLE_MS2, MEDIA_EXTENSIONS, validate_default;
+var __filename2, __dirname3, CONTRAST_SAMPLES, SEEK_SETTLE_MS2, validate_default;
 var init_validate = __esm({
   "src/commands/validate.ts"() {
     "use strict";
@@ -42572,7 +42814,6 @@ var init_validate = __esm({
     __dirname3 = dirname22(__filename2);
     CONTRAST_SAMPLES = 5;
     SEEK_SETTLE_MS2 = 150;
-    MEDIA_EXTENSIONS = /\.(aac|flac|m4a|mov|mp3|mp4|oga|ogg|wav|webm)$/i;
     validate_default = defineCommand({
       meta: {
         name: "validate",
@@ -42673,12 +42914,12 @@ __export(snapshot_exports, {
   examples: () => examples21
 });
 import { spawn as spawn12 } from "child_process";
-import { existsSync as existsSync52, mkdtempSync as mkdtempSync3, readFileSync as readFileSync37, mkdirSync as mkdirSync27, rmSync as rmSync10 } from "fs";
+import { existsSync as existsSync53, mkdtempSync as mkdtempSync3, readFileSync as readFileSync37, mkdirSync as mkdirSync27, rmSync as rmSync10 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { resolve as resolve36, join as join52, relative as relative6, isAbsolute as isAbsolute7 } from "path";
+import { resolve as resolve36, join as join53, relative as relative6, isAbsolute as isAbsolute7 } from "path";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
-  const tmp = mkdtempSync3(join52(tmpdir5(), "hf-snapshot-frame-"));
-  const outPath = join52(tmp, "frame.png");
+  const tmp = mkdtempSync3(join53(tmpdir5(), "hf-snapshot-frame-"));
+  const outPath = join53(tmp, "frame.png");
   try {
     const result = await new Promise(
       (resolvePromise) => {
@@ -42718,7 +42959,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
         });
       }
     );
-    if (result.code !== 0 || result.timedOut || !existsSync52(outPath)) return null;
+    if (result.code !== 0 || result.timedOut || !existsSync53(outPath)) return null;
     return readFileSync37(outPath);
   } finally {
     try {
@@ -42756,7 +42997,7 @@ async function captureSnapshots(projectDir, opts) {
       res.end();
       return;
     }
-    if (existsSync52(filePath)) {
+    if (existsSync53(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync37(filePath));
       return;
@@ -42831,7 +43072,7 @@ async function captureSnapshots(projectDir, opts) {
         return [];
       }
       const positions = opts.at?.length ? opts.at : numFrames === 1 ? [duration / 2] : Array.from({ length: numFrames }, (_2, i2) => i2 / (numFrames - 1) * duration);
-      const snapshotDir = join52(projectDir, "snapshots");
+      const snapshotDir = join53(projectDir, "snapshots");
       mkdirSync27(snapshotDir, { recursive: true });
       let injectVideoFramesBatch2 = null;
       let syncVideoFrameVisibility2 = null;
@@ -42906,7 +43147,7 @@ async function captureSnapshots(projectDir, opts) {
               const decodedPath = decodeURIComponent(url.pathname).replace(/^\//, "");
               const candidate = resolve36(projectDir, decodedPath);
               const rel = relative6(projectDir, candidate);
-              if (!rel.startsWith("..") && !isAbsolute7(rel) && existsSync52(candidate)) {
+              if (!rel.startsWith("..") && !isAbsolute7(rel) && existsSync53(candidate)) {
                 filePath = candidate;
               }
             } catch {
@@ -42936,7 +43177,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 = join52(snapshotDir, filename);
+        const framePath = join53(snapshotDir, filename);
         await page.screenshot({ path: framePath, type: "png" });
         savedPaths.push(`snapshots/${filename}`);
       }
@@ -43020,13 +43261,13 @@ ${c.error("\u2717")} Snapshot failed: ${msg}`);
 
 // src/capture/assetDownloader.ts
 import { writeFileSync as writeFileSync22, mkdirSync as mkdirSync28 } from "fs";
-import { join as join53, extname as extname10 } from "path";
+import { join as join54, extname as extname10 } from "path";
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
-  const assetsDir = join53(outputDir, "assets");
+  const assetsDir = join54(outputDir, "assets");
   mkdirSync28(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync28(join53(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync28(join54(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;
@@ -43034,7 +43275,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 {
-      writeFileSync22(join53(outputDir, localPath), svg.outerHTML, "utf-8");
+      writeFileSync22(join54(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
@@ -43047,7 +43288,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
       if (buffer) {
-        writeFileSync22(join53(outputDir, localPath), buffer);
+        writeFileSync22(join54(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -43104,7 +43345,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
         const slug = isMeaningful ? slugify(rawName) : `${prefix}-${imgIdx}`;
         const name = `${slug}${ext}`;
         const localPath = `assets/${name}`;
-        writeFileSync22(join53(outputDir, localPath), buffer);
+        writeFileSync22(join54(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -43117,7 +43358,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) {
-        writeFileSync22(join53(outputDir, localPath), buffer);
+        writeFileSync22(join54(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -43140,7 +43381,7 @@ function normalizeUrl(u) {
   }
 }
 async function downloadAndRewriteFonts(css, outputDir) {
-  const assetsDir = join53(outputDir, "assets", "fonts");
+  const assetsDir = join54(outputDir, "assets", "fonts");
   mkdirSync28(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
@@ -43176,7 +43417,7 @@ async function downloadAndRewriteFonts(css, outputDir) {
     try {
       const urlObj = new URL(fontUrl);
       const filename = urlObj.pathname.split("/").pop() || `font-${count}.woff2`;
-      const localPath = join53(assetsDir, filename);
+      const localPath = join54(assetsDir, filename);
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
@@ -43973,8 +44214,8 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync23, readdirSync as readdirSync17, readFileSync as readFileSync38, statSync as statSync18 } from "fs";
-import { join as join54 } from "path";
+import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync23, readdirSync as readdirSync18, readFileSync as readFileSync38, statSync as statSync20 } from "fs";
+import { join as join55 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -44007,7 +44248,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
             const hash2 = buf.toString("base64").slice(0, 100);
             if (savedHashes.has(hash2)) continue;
             savedHashes.add(hash2);
-            writeFileSync23(join54(lottieDir, `animation-${savedCount}.lottie`), buf);
+            writeFileSync23(join55(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -44025,7 +44266,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync23(join54(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync23(join55(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -44035,22 +44276,22 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
-  const previewDir = join54(lottieDir, "previews");
+  const previewDir = join55(lottieDir, "previews");
   mkdirSync29(previewDir, { recursive: true });
-  for (const file of readdirSync17(lottieDir)) {
+  for (const file of readdirSync18(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync38(join54(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync38(join55(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 = statSync18(join54(lottieDir, file)).size;
+      const fileSize = statSync20(join55(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(readFileSync38(join54(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync38(join55(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -44080,7 +44321,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
         await previewPage.waitForFunction(() => window.__READY === true, { timeout: 5e3 }).catch(() => {
         });
         await previewPage.screenshot({
-          path: join54(previewDir, previewName),
+          path: join55(previewDir, previewName),
           type: "png",
           omitBackground: true
         });
@@ -44104,7 +44345,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   }
   if (manifest.length > 0) {
     writeFileSync23(
-      join54(outputDir, "extracted", "lottie-manifest.json"),
+      join55(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -44166,15 +44407,15 @@ async function captureVideoManifest(page, outputDir, progress) {
     return true;
   });
   if (uniqueVideos.length > 0) {
-    const videoManifestDir = join54(outputDir, "assets", "videos");
+    const videoManifestDir = join55(outputDir, "assets", "videos");
     mkdirSync29(videoManifestDir, { recursive: true });
-    const previewDir = join54(videoManifestDir, "previews");
+    const previewDir = join55(videoManifestDir, "previews");
     mkdirSync29(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 = join54(previewDir, previewName);
+      const previewPath = join55(previewDir, previewName);
       try {
         await page.evaluate(`window.scrollTo(0, ${Math.max(0, v.top - 100)})`);
         await new Promise((r2) => setTimeout(r2, 300));
@@ -44213,7 +44454,7 @@ async function captureVideoManifest(page, outputDir, progress) {
     }
     if (videoManifest.length > 0) {
       writeFileSync23(
-        join54(outputDir, "extracted", "video-manifest.json"),
+        join55(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
       );
@@ -51167,7 +51408,7 @@ var require_node_domexception = __commonJS({
 });
 
 // ../../node_modules/.bun/fetch-blob@3.2.0/node_modules/fetch-blob/from.js
-import { statSync as statSync19, createReadStream as createReadStream2, promises as fs2 } from "fs";
+import { statSync as statSync21, 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({
@@ -51177,10 +51418,10 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat } = fs2);
-    blobFromSync = (path2, type) => fromBlob(statSync19(path2), path2, type);
+    blobFromSync = (path2, type) => fromBlob(statSync21(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(statSync19(path2), path2, type);
+    fileFromSync = (path2, type) => fromFile(statSync21(path2), path2, type);
     fromBlob = (stat3, path2, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path2,
       size: stat3.size,
@@ -84668,8 +84909,8 @@ ${underline2}`);
 });
 
 // src/capture/contentExtractor.ts
-import { readdirSync as readdirSync18, statSync as statSync20, readFileSync as readFileSync39 } from "fs";
-import { join as join55 } from "path";
+import { readdirSync as readdirSync19, statSync as statSync22, readFileSync as readFileSync39 } from "fs";
+import { join as join56 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
   try {
@@ -84789,7 +85030,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 = readdirSync18(join55(outputDir, "assets")).filter(
+    const imageFiles = readdirSync19(join56(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";
@@ -84798,8 +85039,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 = join55(outputDir, "assets", file);
-          const stat3 = statSync20(filePath);
+          const filePath = join56(outputDir, "assets", file);
+          const stat3 = statSync22(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
           const buffer = readFileSync39(filePath);
           const base64 = buffer.toString("base64");
@@ -84847,12 +85088,12 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join55(outputDir, "assets");
+  const assetsPath = join56(outputDir, "assets");
   try {
-    for (const file of readdirSync18(assetsPath)) {
+    for (const file of readdirSync19(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join55(assetsPath, file);
-      const stat3 = statSync20(filePath);
+      const filePath = join56(assetsPath, file);
+      const stat3 = statSync22(filePath);
       if (!stat3.isFile()) continue;
       const sizeKb = Math.round(stat3.size / 1024);
       const catalogMatch = catalogedAssets.find(
@@ -84880,8 +85121,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join55(assetsPath, "svgs");
-    for (const file of readdirSync18(svgsPath)) {
+    const svgsPath = join56(assetsPath, "svgs");
+    for (const file of readdirSync19(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
         (s2) => s2.label && file.includes(
@@ -84895,8 +85136,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join55(assetsPath, "fonts");
-    for (const file of readdirSync18(fontsPath)) {
+    const fontsPath = join56(assetsPath, "fonts");
+    for (const file of readdirSync19(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
   } catch {
@@ -84915,12 +85156,12 @@ __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
 import { writeFileSync as writeFileSync24 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, detectedLibraries) {
   const prompt = buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries);
-  writeFileSync24(join56(outputDir, "AGENTS.md"), prompt, "utf-8");
-  writeFileSync24(join56(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync24(join56(outputDir, ".cursorrules"), prompt, "utf-8");
+  writeFileSync24(join57(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync24(join57(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync24(join57(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -84987,8 +85228,8 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync53, writeFileSync as writeFileSync25, readFileSync as readFileSync40 } from "fs";
-import { join as join57, resolve as resolve37 } from "path";
+import { existsSync as existsSync54, writeFileSync as writeFileSync25, readFileSync as readFileSync40 } from "fs";
+import { join as join58, resolve as resolve37 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve37(startDir);
@@ -85014,8 +85255,8 @@ function loadEnvFile(startDir) {
   }
 }
 async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
-  const metaPath = join57(outputDir, "meta.json");
-  if (!existsSync53(metaPath)) {
+  const metaPath = join58(outputDir, "meta.json");
+  if (!existsSync54(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
     writeFileSync25(
       metaPath,
@@ -85053,9 +85294,9 @@ __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
 import { writeFileSync as writeFileSync26, mkdirSync as mkdirSync30 } from "fs";
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
-  const screenshotsDir = join58(outputDir, "screenshots");
+  const screenshotsDir = join59(outputDir, "screenshots");
   mkdirSync30(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
@@ -85089,7 +85330,7 @@ async function captureScrollScreenshots(page, outputDir) {
         finalPositions[i2] / Math.max(1, scrollHeight - viewportHeight) * 100
       );
       const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
-      const filePath = join58(screenshotsDir, filename);
+      const filePath = join59(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
       writeFileSync26(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
@@ -85402,8 +85643,8 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync27, existsSync as existsSync54 } from "fs";
-import { join as join59 } from "path";
+import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync27, existsSync as existsSync55 } from "fs";
+import { join as join60 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -85420,9 +85661,9 @@ async function captureWebsite(opts, onProgress) {
     onProgress?.(stage, detail);
   };
   loadEnvFile(outputDir);
-  mkdirSync31(join59(outputDir, "extracted"), { recursive: true });
-  mkdirSync31(join59(outputDir, "screenshots"), { recursive: true });
-  mkdirSync31(join59(outputDir, "assets"), { recursive: true });
+  mkdirSync31(join60(outputDir, "extracted"), { recursive: true });
+  mkdirSync31(join60(outputDir, "screenshots"), { recursive: true });
+  mkdirSync31(join60(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -85578,7 +85819,7 @@ async function captureWebsite(opts, onProgress) {
     } catch {
     }
     if (discoveredLotties.length > 0) {
-      const lottieDir = join59(outputDir, "assets", "lottie");
+      const lottieDir = join60(outputDir, "assets", "lottie");
       mkdirSync31(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
@@ -85598,7 +85839,7 @@ async function captureWebsite(opts, onProgress) {
         });
         capturedShaders = unique;
         writeFileSync27(
-          join59(outputDir, "extracted", "shaders.json"),
+          join60(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -85609,7 +85850,7 @@ async function captureWebsite(opts, onProgress) {
     progress("tokens", "Extracting design tokens...");
     const tokens = await extractTokens(page1);
     writeFileSync27(
-      join59(outputDir, "extracted", "tokens.json"),
+      join60(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokens, null, 2),
       "utf-8"
     );
@@ -85683,7 +85924,7 @@ async function captureWebsite(opts, onProgress) {
         representativeAnimations: representativeAnims
       };
       writeFileSync27(
-        join59(outputDir, "extracted", "animations.json"),
+        join60(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -85694,18 +85935,18 @@ async function captureWebsite(opts, onProgress) {
       assets = await downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks);
     }
     if (visibleTextContent) {
-      writeFileSync27(join59(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync27(join60(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     if (catalogedAssets.length > 0) {
       writeFileSync27(
-        join59(outputDir, "extracted", "assets-catalog.json"),
+        join60(outputDir, "extracted", "assets-catalog.json"),
         JSON.stringify(catalogedAssets, null, 2),
         "utf-8"
       );
     }
     if (detectedLibraries.length > 0) {
       writeFileSync27(
-        join59(outputDir, "extracted", "detected-libraries.json"),
+        join60(outputDir, "extracted", "detected-libraries.json"),
         JSON.stringify(detectedLibraries, null, 2),
         "utf-8"
       );
@@ -85716,7 +85957,7 @@ async function captureWebsite(opts, onProgress) {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
         writeFileSync27(
-          join59(outputDir, "extracted", "asset-descriptions.md"),
+          join60(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"
         );
@@ -85732,7 +85973,7 @@ async function captureWebsite(opts, onProgress) {
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync54(join59(outputDir, "extracted", "shaders.json")),
+      existsSync55(join60(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
       warnings,
@@ -86080,8 +86321,8 @@ __export(autoUpdate_exports, {
 });
 import { spawn as spawn13 } from "child_process";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync32, openSync as openSync2 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join60 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join61 } from "path";
 import { compareVersions as compareVersions2 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -86104,7 +86345,7 @@ function log(line) {
 }
 function launchDetachedInstall(installCommand, version) {
   mkdirSync32(CONFIG_DIR2, { recursive: true, mode: 448 });
-  const configFile = join60(CONFIG_DIR2, "config.json");
+  const configFile = join61(CONFIG_DIR2, "config.json");
   const nodeScript = `
     const { exec } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -86223,8 +86464,8 @@ var init_autoUpdate = __esm({
     init_config();
     init_env();
     init_installerDetection();
-    CONFIG_DIR2 = join60(homedir10(), ".hyperframes");
-    LOG_FILE = join60(CONFIG_DIR2, "auto-update.log");
+    CONFIG_DIR2 = join61(homedir11(), ".hyperframes");
+    LOG_FILE = join61(CONFIG_DIR2, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });