hyperframes 0.4.24 → 0.5.0-alpha.2

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.24" : "0.0.0-dev";
+    VERSION = true ? "0.5.0-alpha.2" : "0.0.0-dev";
   }
 });
 
@@ -5994,6 +5994,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) => {
@@ -24416,6 +24428,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);
   }
@@ -24810,7 +24830,7 @@ var init_render = __esm({
 });
 
 // ../core/src/studio-api/routes/thumbnail.ts
-import { existsSync as existsSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, statSync as statSync4 } from "fs";
 import { join as join16 } from "path";
 function registerThumbnailRoutes(api, adapter2) {
   api.get("/projects/:id/thumbnail/*", async (c2) => {
@@ -24828,11 +24848,14 @@ 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 urlVersion = url.searchParams.get("v") || "";
     let compW = vpWidth || 1920;
     let compH = vpHeight || 1080;
+    let sourceMtime = 0;
     if (!vpWidth) {
       const htmlFile = join16(project.dir, compPath);
       if (existsSync13(htmlFile)) {
+        sourceMtime = Math.round(statSync4(htmlFile).mtimeMs);
         const html = readFileSync14(htmlFile, "utf-8");
         const wMatch = html.match(/data-width=["'](\d+)["']/);
         const hMatch = html.match(/data-height=["'](\d+)["']/);
@@ -24843,7 +24866,8 @@ 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 = join16(project.dir, ".thumbnails");
     const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}` : "";
-    const cacheKey = `${THUMBNAIL_CACHE_VERSION}_${compPath.replace(/\//g, "_")}_${seekTime.toFixed(2)}${selectorKey}.jpg`;
+    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 = join16(cacheDir, cacheKey);
     if (existsSync13(cachePath2)) {
       return new Response(new Uint8Array(readFileSync14(cachePath2)), {
@@ -24878,7 +24902,219 @@ 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";
+  }
+});
+
+// ../core/src/studio-api/routes/fonts.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync14, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { homedir as homedir4, platform as platform3 } from "os";
+import { join as join17 } from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function fontDirectories() {
+  const home = homedir4();
+  if (platform3() === "darwin") {
+    return [
+      join17(home, "Library", "Fonts"),
+      "/Library/Fonts",
+      "/System/Library/Fonts",
+      "/System/Library/Fonts/Supplemental"
+    ];
+  }
+  if (platform3() === "win32") {
+    return [join17(process.env.WINDIR || "C:\\Windows", "Fonts")];
+  }
+  return [
+    join17(home, ".fonts"),
+    join17(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 (!existsSync14(dir) || depth > 2) return [];
+  const fonts = [];
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const fullPath = join17(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"
+    ];
   }
 });
 
@@ -24892,6 +25128,7 @@ function createStudioApi(adapter2) {
   registerLintRoutes(api, adapter2);
   registerRenderRoutes(api, adapter2);
   registerThumbnailRoutes(api, adapter2);
+  registerFontRoutes(api);
   return api;
 }
 var init_createStudioApi = __esm({
@@ -24903,6 +25140,7 @@ var init_createStudioApi = __esm({
     init_lint2();
     init_render();
     init_thumbnail();
+    init_fonts();
   }
 });
 
@@ -24937,9 +25175,9 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync14, rmSync as rmSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join17 } from "path";
+import { existsSync as existsSync15, rmSync as rmSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join18 } from "path";
 import { Browser, detectBrowserPlatform, getInstalledBrowsers, install } from "@puppeteer/browsers";
 function setBrowserPath(path2) {
   _browserPathOverride = path2;
@@ -24959,17 +25197,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync14(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync15(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync14(envPath)) {
+  if (envPath && existsSync15(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync14(CACHE_DIR2)) {
+  if (!existsSync15(CACHE_DIR2)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR2 });
@@ -24981,7 +25219,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync14(p)) {
+    if (existsSync15(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -25001,21 +25239,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 (!existsSync14(CACHE_DIR2)) {
+  if (!existsSync15(CACHE_DIR2)) {
     return false;
   }
   rmSync4(CACHE_DIR2, { recursive: true, force: true });
@@ -25026,7 +25264,7 @@ var init_manager2 = __esm({
   "src/browser/manager.ts"() {
     "use strict";
     CHROME_VERSION = "131.0.6778.85";
-    CACHE_DIR2 = join17(homedir4(), ".cache", "hyperframes", "chrome");
+    CACHE_DIR2 = join18(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",
@@ -25153,9 +25391,9 @@ var init_config2 = __esm({
 });
 
 // ../engine/src/services/browserManager.ts
-import { existsSync as existsSync15, readdirSync as readdirSync6 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync16, readdirSync as readdirSync7 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir6 } from "os";
 async function getPuppeteer() {
   if (_puppeteer) return _puppeteer;
   try {
@@ -25175,19 +25413,19 @@ function resolveHeadlessShellPath(config) {
   if (process.env.PRODUCER_HEADLESS_SHELL_PATH) {
     return process.env.PRODUCER_HEADLESS_SHELL_PATH;
   }
-  const baseDir = join18(homedir5(), ".cache", "puppeteer", "chrome-headless-shell");
-  if (!existsSync15(baseDir)) return void 0;
+  const baseDir = join19(homedir6(), ".cache", "puppeteer", "chrome-headless-shell");
+  if (!existsSync16(baseDir)) return void 0;
   try {
-    const versions = readdirSync6(baseDir).sort().reverse();
+    const versions = readdirSync7(baseDir).sort().reverse();
     for (const version of versions) {
       const candidates = [
-        join18(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
-        join18(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
-        join18(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
-        join18(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
+        join19(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
+        join19(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
+        join19(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
+        join19(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
       ];
       for (const binary of candidates) {
-        if (existsSync15(binary)) return binary;
+        if (existsSync16(binary)) return binary;
       }
     }
   } catch {
@@ -25650,10 +25888,10 @@ var init_screenshotService = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join20 } from "path";
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync16(outputDir)) mkdirSync8(outputDir, { recursive: true });
+  if (!existsSync17(outputDir)) mkdirSync8(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -25857,9 +26095,9 @@ async function initializeSession(session) {
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
   try {
-    const diagnosticsDir = join19(session.outputDir, "diagnostics");
-    if (!existsSync16(diagnosticsDir)) mkdirSync8(diagnosticsDir, { recursive: true });
-    const base = join19(diagnosticsDir, `frame-error-${frameIndex}`);
+    const diagnosticsDir = join20(session.outputDir, "diagnostics");
+    if (!existsSync17(diagnosticsDir)) mkdirSync8(diagnosticsDir, { recursive: true });
+    const base = join20(diagnosticsDir, `frame-error-${frameIndex}`);
     await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
     const html = await session.page.content();
     writeFileSync8(`${base}.html`, html, "utf-8");
@@ -25957,7 +26195,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 = join19(outputDir, frameName);
+  const framePath = join20(outputDir, frameName);
   writeFileSync8(framePath, buffer);
   return { frameIndex, time: quantizedTime, path: framePath, captureTimeMs };
 }
@@ -25978,7 +26216,7 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync16(outputDir)) {
+  if (!existsSync17(outputDir)) {
     mkdirSync8(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
@@ -26216,8 +26454,8 @@ var init_runFfmpeg = __esm({
 
 // ../engine/src/services/chunkEncoder.ts
 import { spawn as spawn4 } from "child_process";
-import { copyFileSync, existsSync as existsSync17, mkdirSync as mkdirSync9, readdirSync as readdirSync7, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
-import { join as join20, dirname as dirname6 } from "path";
+import { copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync9, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync9 } from "fs";
+import { join as join21, dirname as dirname6 } from "path";
 function getEncoderPreset(quality, format = "mp4", hdr) {
   const base = ENCODER_PRESETS[quality];
   if (format === "webm") {
@@ -26368,8 +26606,8 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config) {
   const startTime = Date.now();
   const outputDir = dirname6(outputPath);
-  if (!existsSync17(outputDir)) mkdirSync9(outputDir, { recursive: true });
-  const files = readdirSync7(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i));
+  if (!existsSync18(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const files = readdirSync8(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
     return {
@@ -26385,7 +26623,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
-  const inputPath = join20(framesDir, framePattern);
+  const inputPath = join21(framesDir, framePattern);
   const inputArgs = ["-framerate", String(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   return new Promise((resolve39) => {
@@ -26434,7 +26672,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync17(outputPath) ? statSync4(outputPath).size : 0;
+      const fileSize = existsSync18(outputPath) ? statSync6(outputPath).size : 0;
       resolve39({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
@@ -26453,7 +26691,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,
@@ -26466,8 +26704,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 = join20(dirname6(outputPath), "chunk-encode");
-  if (!existsSync17(chunkDir)) mkdirSync9(chunkDir, { recursive: true });
+  const chunkDir = join21(dirname6(outputPath), "chunk-encode");
+  if (!existsSync18(chunkDir)) mkdirSync9(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i2 = 0; i2 < chunkCount; i2++) {
     if (signal?.aborted) {
@@ -26483,8 +26721,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 = join20(chunkDir, `chunk_${String(i2).padStart(4, "0")}${ext}`);
-    const inputPath = join20(framesDir, framePattern);
+    const chunkPath = join21(chunkDir, `chunk_${String(i2).padStart(4, "0")}${ext}`);
+    const inputPath = join21(framesDir, framePattern);
     const inputArgs = [
       "-framerate",
       String(options.fps),
@@ -26524,7 +26762,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     }
     chunkPaths.push(chunkPath);
   }
-  const concatListPath = join20(chunkDir, "concat-list.txt");
+  const concatListPath = join21(chunkDir, "concat-list.txt");
   const concatInput = chunkPaths.map((path2) => `file '${path2.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync9(concatListPath, concatInput, "utf-8");
   const concatArgs = [
@@ -26563,7 +26801,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync17(outputPath) ? statSync4(outputPath).size : 0;
+  const fileSize = existsSync18(outputPath) ? statSync6(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -26574,7 +26812,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config) {
   const outputDir = dirname6(outputPath);
-  if (!existsSync17(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  if (!existsSync18(outputDir)) mkdirSync9(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
@@ -26645,7 +26883,7 @@ var init_chunkEncoder = __esm({
 
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, statSync as statSync5 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, statSync as statSync7 } from "fs";
 import { dirname as dirname7 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
@@ -26828,7 +27066,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
   const outputDir = dirname7(outputPath);
-  if (!existsSync18(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  if (!existsSync19(outputDir)) mkdirSync10(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
@@ -26910,7 +27148,7 @@ Process error: ${err.message}`;
           error: formatFfmpegError(exitCode, stderr)
         };
       }
-      const fileSize = existsSync18(outputPath) ? statSync5(outputPath).size : 0;
+      const fileSize = existsSync19(outputPath) ? statSync7(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -27202,9 +27440,9 @@ var init_ffprobe = __esm({
 });
 
 // ../engine/src/utils/urlDownloader.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync19, mkdirSync as mkdirSync11 } from "fs";
+import { createWriteStream as createWriteStream2, existsSync as existsSync20, mkdirSync as mkdirSync11 } from "fs";
 import { createHash } from "crypto";
-import { join as join21, extname as extname5 } from "path";
+import { join as join22, extname as extname5 } from "path";
 import { Readable } from "stream";
 import { finished } from "stream/promises";
 function getFilenameFromUrl(url) {
@@ -27215,19 +27453,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync19(cachedPath)) {
+  if (cachedPath && existsSync20(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync19(destDir)) {
+  if (!existsSync20(destDir)) {
     mkdirSync11(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join21(destDir, filename);
-  if (existsSync19(localPath)) {
+  const localPath = join22(destDir, filename);
+  if (existsSync20(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -27319,12 +27557,12 @@ var init_htmlTemplate = __esm({
 
 // ../engine/src/services/extractionCache.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync12, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync10 } from "fs";
-import { existsSync as existsSync20 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync12, readdirSync as readdirSync9, statSync as statSync8, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync21 } from "fs";
+import { join as join23 } 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;
@@ -27350,23 +27588,23 @@ function cacheEntryDirName(keyHash) {
 }
 function lookupCacheEntry(rootDir, input) {
   const keyHash = computeCacheKey(input);
-  const dir = join22(rootDir, cacheEntryDirName(keyHash));
-  const complete = existsSync20(join22(dir, COMPLETE_SENTINEL));
+  const dir = join23(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync21(join23(dir, COMPLETE_SENTINEL));
   return { entry: { dir, keyHash }, hit: complete };
 }
 function ensureCacheEntryDir(entry) {
   mkdirSync12(entry.dir, { recursive: true });
 }
 function markCacheEntryComplete(entry) {
-  writeFileSync10(join22(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
+  writeFileSync10(join23(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, join22(entry.dir, file));
+    framePaths.set(idx, join23(entry.dir, file));
   });
   return {
     videoId: options.videoId,
@@ -27392,8 +27630,8 @@ var init_extractionCache = __esm({
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readdirSync as readdirSync9, rmSync as rmSync5 } from "fs";
-import { isAbsolute as isAbsolute2, join as join23 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync13, readdirSync as readdirSync10, rmSync as rmSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join24 } from "path";
 function parseVideoElements(html) {
   const videos = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -27463,12 +27701,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 ?? join23(outputDir, videoId);
-  if (!existsSync21(videoOutputDir)) mkdirSync13(videoOutputDir, { recursive: true });
+  const videoOutputDir = outputDirOverride ?? join24(outputDir, videoId);
+  if (!existsSync22(videoOutputDir)) mkdirSync13(videoOutputDir, { recursive: true });
   const metadata = await extractMediaMetadata(videoPath);
   const format = resolveFrameFormat(metadata, options.format);
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
-  const outputPattern = join23(videoOutputDir, framePattern);
+  const outputPattern = join24(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -27519,9 +27757,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, join23(videoOutputDir, file));
+        framePaths.set(index, join24(videoOutputDir, file));
       });
       resolve39({
         videoId,
@@ -27648,15 +27886,15 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     try {
       let videoPath = video.src;
       if (!isAbsolute2(videoPath) && !isHttpUrl(videoPath)) {
-        const fromCompiled = compiledDir ? join23(compiledDir, videoPath) : null;
-        videoPath = fromCompiled && existsSync21(fromCompiled) ? fromCompiled : join23(baseDir, videoPath);
+        const fromCompiled = compiledDir ? join24(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync22(fromCompiled) ? fromCompiled : join24(baseDir, videoPath);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join23(options.outputDir, "_downloads");
+        const downloadDir = join24(options.outputDir, "_downloads");
         mkdirSync13(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(videoPath, downloadDir);
       }
-      if (!existsSync21(videoPath)) {
+      if (!existsSync22(videoPath)) {
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }
@@ -27689,7 +27927,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 = join23(options.outputDir, "_hdr_normalized");
+    const convertDir = join24(options.outputDir, "_hdr_normalized");
     mkdirSync13(convertDir, { recursive: true });
     for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
       if (signal?.aborted) break;
@@ -27711,7 +27949,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 = join23(convertDir, `${entry.video.id}_hdr.mp4`);
+        const convertedPath = join24(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
           await convertSdrToHdr(
             entry.videoPath,
@@ -27746,7 +27984,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
   }
   const vfrPreflightStart = Date.now();
-  const vfrNormDir = join23(options.outputDir, "_vfr_normalized");
+  const vfrNormDir = join24(options.outputDir, "_vfr_normalized");
   for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i2];
@@ -27761,7 +27999,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
     mkdirSync13(vfrNormDir, { recursive: true });
-    const normalizedPath = join23(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    const normalizedPath = join24(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
         entry.videoPath,
@@ -28017,7 +28255,7 @@ var init_videoFrameExtractor = __esm({
       cleanup() {
         for (const video of this.videos.values()) {
           if (video.extracted.ownedByLookup) continue;
-          if (existsSync21(video.extracted.outputDir)) {
+          if (existsSync22(video.extracted.outputDir)) {
             rmSync5(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -28325,8 +28563,8 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, rmSync as rmSync6 } from "fs";
-import { isAbsolute as isAbsolute3, join as join24, dirname as dirname8 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync14, rmSync as rmSync6 } from "fs";
+import { isAbsolute as isAbsolute3, join as join25, dirname as dirname8 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -28377,7 +28615,7 @@ function parseAudioElements(html) {
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = ["-i", videoPath];
   if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
   if (options?.duration !== void 0) args.push("-t", String(options.duration));
@@ -28404,7 +28642,7 @@ async function extractAudioFromVideo(videoPath, outputPath, options, signal, con
 async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -28440,7 +28678,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, sign
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname8(outputPath);
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -28483,7 +28721,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     };
   }
   const outputDir = dirname8(outputPath);
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync14(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i2) => {
@@ -28544,7 +28782,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync22(workDir)) mkdirSync14(workDir, { recursive: true });
+  if (!existsSync23(workDir)) mkdirSync14(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -28554,8 +28792,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!isAbsolute3(srcPath) && !isHttpUrl(srcPath)) {
-          const fromCompiled = compiledDir ? join24(compiledDir, srcPath) : null;
-          srcPath = fromCompiled && existsSync22(fromCompiled) ? fromCompiled : join24(baseDir, srcPath);
+          const fromCompiled = compiledDir ? join25(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync23(fromCompiled) ? fromCompiled : join25(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -28567,7 +28805,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync22(srcPath)) {
+        if (!existsSync23(srcPath)) {
           errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
@@ -28578,7 +28816,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join24(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join25(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -28595,7 +28833,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join24(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join25(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -28649,9 +28887,9 @@ var init_audioMixer = __esm({
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus2, freemem, totalmem as totalmem2 } from "os";
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync15, readdirSync as readdirSync11 } from "fs";
 import { copyFile, rename } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
   const effectiveMaxWorkers = (() => {
     const concurrency = config?.concurrency ?? DEFAULT_CONFIG2.concurrency;
@@ -28694,7 +28932,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i2,
       startFrame,
       endFrame,
-      outputDir: join25(workDir, `worker-${i2}`)
+      outputDir: join26(workDir, `worker-${i2}`)
     });
   }
   return tasks;
@@ -28702,7 +28940,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 (!existsSync23(task.outputDir)) mkdirSync15(task.outputDir, { recursive: true });
+  if (!existsSync24(task.outputDir)) mkdirSync15(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -28792,17 +29030,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync23(outputDir)) mkdirSync15(outputDir, { recursive: true });
+  if (!existsSync24(outputDir)) mkdirSync15(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync23(task.outputDir)) {
+    if (!existsSync24(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 = join25(task.outputDir, file);
-      const targetPath = join25(outputDir, file);
+      const sourcePath = join26(task.outputDir, file);
+      const targetPath = join26(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -28839,8 +29077,8 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync16, existsSync as existsSync24, statSync as statSync7 } from "fs";
-import { join as join26, extname as extname6 } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync25, statSync as statSync9 } from "fs";
+import { join as join27, extname as extname6 } from "path";
 function stripEmbeddedRuntimeScripts(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -28909,12 +29147,12 @@ function createFileServer(options) {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join26(compiledDir, relativePath) : null;
+    const compiledPath = compiledDir ? join27(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync24(compiledPath) && statSync7(compiledPath).isFile()
+      compiledPath && existsSync25(compiledPath) && statSync9(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join26(projectDir, relativePath);
-    if (!existsSync24(filePath) || !statSync7(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join27(projectDir, relativePath);
+    if (!existsSync25(filePath) || !statSync9(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname6(filePath).toLowerCase();
@@ -30192,9 +30430,9 @@ var init_shaderTransitions = __esm({
 });
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
-import { join as join27 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync26, readdirSync as readdirSync12 } from "fs";
+import { join as join28 } 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);
@@ -30309,12 +30547,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join27(homedir6(), ".cache", "puppeteer", "chrome");
-  if (!existsSync25(baseDir)) return void 0;
-  const versions = readdirSync11(baseDir).sort().reverse();
+  const baseDir = join28(homedir7(), ".cache", "puppeteer", "chrome");
+  if (!existsSync26(baseDir)) return void 0;
+  const versions = readdirSync12(baseDir).sort().reverse();
   for (const version of versions) {
     const candidates = [
-      join27(
+      join28(
         baseDir,
         version,
         "chrome-mac-arm64",
@@ -30323,7 +30561,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join27(
+      join28(
         baseDir,
         version,
         "chrome-mac-x64",
@@ -30332,11 +30570,11 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join27(baseDir, version, "chrome-linux64", "chrome"),
-      join27(baseDir, version, "chrome-win64", "chrome.exe")
+      join28(baseDir, version, "chrome-linux64", "chrome"),
+      join28(baseDir, version, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
-      if (existsSync25(binary)) return binary;
+      if (existsSync26(binary)) return binary;
     }
   }
   return void 0;
@@ -30608,8 +30846,8 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync17, existsSync as existsSync26 } from "fs";
-import { join as join28, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
+import { join as join29, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
 import { transformSync } from "esbuild";
 function parseHTMLContent2(html) {
   const trimmed = html.trimStart().toLowerCase();
@@ -30677,7 +30915,7 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute4(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync26(filePath)) return null;
+  if (!existsSync27(filePath)) return null;
   try {
     return readFileSync17(filePath, "utf-8");
   } catch {
@@ -30685,7 +30923,7 @@ function safeReadFile(filePath) {
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync26(filePath)) return null;
+  if (!existsSync27(filePath)) return null;
   try {
     return readFileSync17(filePath);
   } catch {
@@ -30878,8 +31116,8 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join28(projectDir, "index.html");
-  if (!existsSync26(indexPath)) throw new Error("index.html not found in project directory");
+  const indexPath = join29(projectDir, "index.html");
+  if (!existsSync27(indexPath)) throw new Error("index.html not found in project directory");
   const rawHtml = readFileSync17(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
@@ -31003,6 +31241,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 innerCompId = innerRoot.getAttribute("data-composition-id");
       const innerW = innerRoot.getAttribute("data-width");
@@ -31155,7 +31402,7 @@ var init_compiler = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync27, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
 import { dirname as dirname9, resolve as resolve13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -31168,7 +31415,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync27(candidate)) {
+    if (existsSync28(candidate)) {
       return candidate;
     }
   }
@@ -31179,7 +31426,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync27(manifestPath)) {
+  if (!existsSync28(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
@@ -31193,7 +31440,7 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve13(dirname9(manifestPath), runtimeFileName);
-  if (!existsSync27(runtimePath)) {
+  if (!existsSync28(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync18(runtimePath, "utf8");
@@ -31235,16 +31482,16 @@ var init_hyperframeRuntimeLoader = __esm({
 // ../producer/src/services/fileServer.ts
 import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { readFileSync as readFileSync19, existsSync as existsSync28, realpathSync, statSync as statSync8 } from "fs";
-import { join as join29, extname as extname7, resolve as resolve14, sep as sep3 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync29, realpathSync, statSync as statSync10 } from "fs";
+import { join as join30, 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 && existsSync28(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
-  const normalizedParent = resolveSymlinks && existsSync28(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
+  const normalizedChild = resolveSymlinks && existsSync29(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync29(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -31333,14 +31580,14 @@ function createFileServer2(options) {
     const relativePath = requestPath.replace(/^\//, "");
     let filePath = null;
     if (compiledDir) {
-      const candidate = join29(compiledDir, relativePath);
-      if (existsSync28(candidate) && isPathInside(candidate, compiledDir) && statSync8(candidate).isFile()) {
+      const candidate = join30(compiledDir, relativePath);
+      if (existsSync29(candidate) && isPathInside(candidate, compiledDir) && statSync10(candidate).isFile()) {
         filePath = candidate;
       }
     }
     if (!filePath) {
-      const candidate = join29(projectDir, relativePath);
-      if (existsSync28(candidate) && isPathInside(candidate, projectDir) && statSync8(candidate).isFile()) {
+      const candidate = join30(projectDir, relativePath);
+      if (existsSync29(candidate) && isPathInside(candidate, projectDir) && statSync10(candidate).isFile()) {
         filePath = candidate;
       }
     }
@@ -31714,7 +31961,7 @@ var init_ffprobe2 = __esm({
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve15, basename as basename2, join as join30, relative as relative2, isAbsolute as isAbsolute5 } from "path";
+import { resolve as resolve15, basename as basename2, join as join31, relative as relative2, isAbsolute as isAbsolute5 } from "path";
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve15(childPath);
   const absParent = resolve15(parentPath);
@@ -31735,7 +31982,7 @@ function toExternalAssetKey(absPath) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = resolve15(projectDir);
   const projectName = basename2(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join30(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join31(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve15(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -31808,9 +32055,9 @@ var init_fontData_generated = __esm({
 });
 
 // ../producer/src/services/deterministicFonts.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync16, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join32 } from "path";
 function normalizeFamilyName(family) {
   return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
 }
@@ -31921,14 +32168,14 @@ function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function fontCacheDir(slug) {
-  const dir = join31(GOOGLE_FONTS_CACHE_DIR, slug);
-  if (!existsSync29(dir)) {
+  const dir = join32(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync30(dir)) {
     mkdirSync16(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join31(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join32(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -31954,7 +32201,7 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match[3] || "";
     if (!woff2Url) continue;
     const cachePath2 = cachedWoff2Path(slug, weight, style);
-    if (!existsSync29(cachePath2)) {
+    if (!existsSync30(cachePath2)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
@@ -32140,14 +32387,14 @@ var init_deterministicFonts = __esm({
       poppins: "poppins",
       "segoe ui": "roboto"
     };
-    GOOGLE_FONTS_CACHE_DIR = join31(homedir7(), ".cache", "hyperframes", "fonts");
+    GOOGLE_FONTS_CACHE_DIR = join32(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 readFileSync21, existsSync as existsSync30, mkdirSync as mkdirSync17 } from "fs";
-import { join as join32, dirname as dirname10, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync21, existsSync as existsSync31, mkdirSync as mkdirSync17 } from "fs";
+import { join as join33, dirname as dirname10, resolve as resolve16 } from "path";
 import postcss from "postcss";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -32198,16 +32445,16 @@ function detectRenderModeHints(html) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync30(downloadDir)) mkdirSync17(downloadDir, { recursive: true });
+    if (!existsSync31(downloadDir)) mkdirSync17(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join32(baseDir, filePath);
+    filePath = join33(baseDir, filePath);
   }
-  if (!existsSync30(filePath)) {
+  if (!existsSync31(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractMediaMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -32276,7 +32523,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync30(filePath)) {
+    if (!existsSync31(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync21(filePath, "utf-8");
@@ -32486,7 +32733,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve16(projectDir, srcPath);
-      if (existsSync30(filePath)) {
+      if (existsSync31(filePath)) {
         compHtml = readFileSync21(filePath, "utf-8");
       }
     }
@@ -32714,7 +32961,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync30(absPath)) return null;
+    if (!existsSync31(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -32993,7 +33240,7 @@ var init_logger = __esm({
 });
 
 // ../producer/src/services/frameDirCache.ts
-import { readdirSync as readdirSync12 } from "fs";
+import { readdirSync as readdirSync13 } from "fs";
 function getMaxFrameIndex(frameDir) {
   const cached2 = cache.get(frameDir);
   if (cached2 !== void 0) {
@@ -33003,7 +33250,7 @@ function getMaxFrameIndex(frameDir) {
   }
   let max = 0;
   try {
-    for (const name of readdirSync12(frameDir)) {
+    for (const name of readdirSync13(frameDir)) {
       const m2 = FRAME_FILENAME_RE.exec(name);
       if (!m2) continue;
       const n = Number(m2[1]);
@@ -33099,17 +33346,17 @@ var init_hdrImageTransferCache = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   mkdirSync as mkdirSync18,
   rmSync as rmSync7,
   readFileSync as readFileSync22,
-  readdirSync as readdirSync13,
-  statSync as statSync9,
+  readdirSync as readdirSync14,
+  statSync as statSync11,
   writeFileSync as writeFileSync12,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join33, dirname as dirname11, resolve as resolve17 } from "path";
+import { join as join34, dirname as dirname11, resolve as resolve17 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -33130,14 +33377,14 @@ function sampleDirectoryBytes(dir) {
     if (!current) continue;
     let entries2 = [];
     try {
-      entries2 = readdirSync13(current);
+      entries2 = readdirSync14(current);
     } catch {
       continue;
     }
     for (const name of entries2) {
-      const full = join33(current, name);
+      const full = join34(current, name);
       try {
-        const st2 = statSync9(full);
+        const st2 = statSync11(full);
         if (st2.isDirectory()) {
           stack.push(full);
         } else if (st2.isFile()) {
@@ -33210,16 +33457,16 @@ function installDebugLogger(logPath, log2 = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join33(workDir, "compiled");
+  const compileDir = join34(workDir, "compiled");
   mkdirSync18(compileDir, { recursive: true });
-  writeFileSync12(join33(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync12(join34(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join33(compileDir, srcPath);
+    const outPath = join34(compileDir, srcPath);
     mkdirSync18(dirname11(outPath), { recursive: true });
     writeFileSync12(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve17(join33(compileDir, relativePath));
+    const outPath = resolve17(join34(compileDir, relativePath));
     if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
@@ -33249,7 +33496,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       subCompositions: Array.from(compiled.subCompositions.keys()),
       renderModeHints: compiled.renderModeHints
     };
-    writeFileSync12(join33(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync12(join34(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(cfg, compiled, log2 = defaultLogger) {
@@ -33270,8 +33517,8 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrFrameDirs, hdrStartTimes, w
   if (videoFrameIndex < 1) return;
   const maxIndex = getMaxFrameIndex(frameDir);
   const effectiveIndex = maxIndex > 0 ? Math.min(videoFrameIndex, maxIndex) : videoFrameIndex;
-  const framePath = join33(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
-  if (!existsSync31(framePath)) {
+  const framePath = join34(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
+  if (!existsSync32(framePath)) {
     return;
   }
   try {
@@ -33454,7 +33701,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
           const localTime = time - startTime;
           const frameNum = Math.floor(localTime * fps) + 1;
-          const expectedFrame = frameDir ? join33(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
+          const expectedFrame = frameDir ? join34(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
           log2.info("[diag] hdr layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -33466,7 +33713,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
             localTime: localTime.toFixed(3),
             hdrFrameNum: frameNum,
             expectedFrame,
-            expectedFrameExists: expectedFrame ? existsSync31(expectedFrame) : false
+            expectedFrameExists: expectedFrame ? existsSync32(expectedFrame) : false
           });
         }
       }
@@ -33491,7 +33738,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 = join33(debugDumpDir, dumpName);
+          const dumpPath = join34(debugDumpDir, dumpName);
           writeFileSync12(dumpPath, domPng);
           log2.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
@@ -33565,8 +33812,8 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
   const moduleDir = dirname11(fileURLToPath3(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve17(process.env.PRODUCER_RENDERS_DIR, "..") : resolve17(moduleDir, "../..");
-  const debugDir = join33(producerRoot, ".debug");
-  const workDir = job.config.debug ? join33(debugDir, job.id) : join33(dirname11(outputPath), `work-${job.id}`);
+  const debugDir = join34(producerRoot, ".debug");
+  const workDir = job.config.debug ? join34(debugDir, job.id) : join34(dirname11(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log2 = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -33578,7 +33825,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     videoExtractionFailures: 0,
     imageDecodeFailures: 0
   };
-  const perfOutputPath = join33(workDir, "perf-summary.json");
+  const perfOutputPath = join34(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -33611,22 +33858,22 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync31(workDir)) mkdirSync18(workDir, { recursive: true });
+    if (!existsSync32(workDir)) mkdirSync18(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join33(workDir, "render.log");
+      const logPath = join34(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log2);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join33(projectDir, entryFile);
-    if (!existsSync31(htmlPath)) {
+    let htmlPath = join34(projectDir, entryFile);
+    if (!existsSync32(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync22(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join33(workDir, "standalone-entry.html");
-      const projectIndexPath = join33(projectDir, "index.html");
-      if (!existsSync31(projectIndexPath)) {
+      const wrapperPath = join34(workDir, "standalone-entry.html");
+      const projectIndexPath = join34(projectDir, "index.html");
+      if (!existsSync32(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -33649,7 +33896,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, join33(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join34(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     applyRenderModeHints(cfg, compiled, log2);
@@ -33681,7 +33928,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join33(workDir, "compiled"),
+        compiledDir: join34(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
@@ -33695,7 +33942,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join33(workDir, "probe"),
+        join34(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -33727,7 +33974,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join33(workDir, "downloads")
+            join34(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -33881,7 +34128,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 = join33(workDir, "compiled");
+    const compiledDir = join34(workDir, "compiled");
     let extractionResult = null;
     const nativeHdrVideoIds = /* @__PURE__ */ new Set();
     const videoTransfers = /* @__PURE__ */ new Map();
@@ -33890,10 +34137,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.videos.map(async (v) => {
           let videoPath = v.src;
           if (!videoPath.startsWith("/")) {
-            const fromCompiled = existsSync31(join33(compiledDir, videoPath)) ? join33(compiledDir, videoPath) : join33(projectDir, videoPath);
+            const fromCompiled = existsSync32(join34(compiledDir, videoPath)) ? join34(compiledDir, videoPath) : join34(projectDir, videoPath);
             videoPath = fromCompiled;
           }
-          if (!existsSync31(videoPath)) return;
+          if (!existsSync32(videoPath)) return;
           const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
@@ -33911,10 +34158,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.images.map(async (img) => {
           let imgPath = img.src;
           if (!imgPath.startsWith("/")) {
-            const fromCompiled = existsSync31(join33(compiledDir, imgPath)) ? join33(compiledDir, imgPath) : join33(projectDir, imgPath);
+            const fromCompiled = existsSync32(join34(compiledDir, imgPath)) ? join34(compiledDir, imgPath) : join34(projectDir, imgPath);
             imgPath = fromCompiled;
           }
-          if (!existsSync31(imgPath)) return null;
+          if (!existsSync32(imgPath)) return null;
           const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
@@ -33930,7 +34177,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join33(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join34(workDir, "video-frames") },
         abortSignal,
         { extractCacheDir: cfg.extractCacheDir },
         compiledDir
@@ -33988,13 +34235,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join33(workDir, "audio.aac");
+    const audioOutputPath = join34(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join33(workDir, "audio-work"),
+        join34(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -34012,14 +34259,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join33(workDir, "compiled"),
+        compiledDir: join34(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join33(workDir, "captured-frames");
-    if (!existsSync31(framesDir)) mkdirSync18(framesDir, { recursive: true });
+    const framesDir = join34(workDir, "captured-frames");
+    if (!existsSync32(framesDir)) mkdirSync18(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -34034,7 +34281,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const workerCount = calculateOptimalWorkers(totalFrames, job.config.workers, cfg);
     const FORMAT_EXT2 = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
     const videoExt = FORMAT_EXT2[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join33(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join34(workDir, `video-only${videoExt}`);
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
@@ -34056,8 +34303,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         if (!hdrVideoIds.includes(v.id)) continue;
         let srcPath = v.src;
         if (!srcPath.startsWith("/")) {
-          const fromCompiled = join33(compiledDir, srcPath);
-          srcPath = existsSync31(fromCompiled) ? fromCompiled : join33(projectDir, srcPath);
+          const fromCompiled = join34(compiledDir, srcPath);
+          srcPath = existsSync32(fromCompiled) ? fromCompiled : join34(projectDir, srcPath);
         }
         hdrVideoSrcPaths.set(v.id, srcPath);
       }
@@ -34187,7 +34434,7 @@ 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 = join33(framesDir, `hdr_${videoId}`);
+          const frameDir = join34(framesDir, `hdr_${videoId}`);
           mkdirSync18(frameDir, { recursive: true });
           const duration = video.end - video.start;
           const dims = hdrExtractionDims.get(videoId) ?? { width, height };
@@ -34207,7 +34454,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             "-c:v",
             "png",
             "-y",
-            join33(frameDir, "frame_%04d.png")
+            join34(frameDir, "frame_%04d.png")
           ];
           const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
           if (!result.success) {
@@ -34275,8 +34522,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
           const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-          const debugDumpDir = debugDumpEnabled ? join33(framesDir, "debug-composite") : null;
-          if (debugDumpDir && !existsSync31(debugDumpDir)) {
+          const debugDumpDir = debugDumpEnabled ? join34(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync32(debugDumpDir)) {
             mkdirSync18(debugDumpDir, { recursive: true });
           }
           if (!effectiveHdr) {
@@ -34423,7 +34670,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 i2
               );
               if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-                const previewPath = join33(
+                const previewPath = join34(
                   debugDumpDir,
                   `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
                 );
@@ -34770,7 +35017,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     updateJobStatus(job, "complete", "Render complete", 100, onProgress);
     const totalElapsed = Date.now() - pipelineStart;
     sampleMemory();
-    const tmpPeakBytes = existsSync31(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync32(workDir) ? sampleDirectoryBytes(workDir) : 0;
     const perfSummary = {
       renderId: job.id,
       totalElapsedMs: totalElapsed,
@@ -34804,8 +35051,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync31(outputPath)) {
-        const debugOutput = join33(workDir, `output${videoExt}`);
+      if (existsSync32(outputPath)) {
+        const debugOutput = join34(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else if (process.env.KEEP_TEMP === "1") {
@@ -34891,7 +35138,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync31(workDir)) rmSync7(workDir, { recursive: true, force: true });
+          if (existsSync32(workDir)) rmSync7(workDir, { recursive: true, force: true });
         },
         log2
       );
@@ -34951,8 +35198,8 @@ var init_config3 = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync32, readFileSync as readFileSync23, statSync as statSync10 } from "fs";
-import { resolve as resolve18, join as join34 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync23, statSync as statSync12 } from "fs";
+import { resolve as resolve18, join as join35 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -34980,7 +35227,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve18(projectDir);
-  if (!existsSync32(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
+  if (!existsSync33(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -34991,7 +35238,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync32(absoluteEntryPath) && statSync10(absoluteEntryPath).isFile()) {
+    if (existsSync33(absoluteEntryPath) && statSync12(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync23(absoluteEntryPath, "utf-8"),
@@ -35000,7 +35247,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join35(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -35088,15 +35335,15 @@ var init_semaphore = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync33,
+  existsSync as existsSync34,
   mkdirSync as mkdirSync19,
-  statSync as statSync11,
+  statSync as statSync13,
   mkdtempSync as mkdtempSync2,
   writeFileSync as writeFileSync13,
   rmSync as rmSync8,
   createReadStream
 } from "fs";
-import { resolve as resolve19, dirname as dirname12, join as join35 } from "path";
+import { resolve as resolve19, dirname as dirname12, join as join36 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -35119,11 +35366,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve19(projectDir);
-    if (!existsSync33(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+    if (!existsSync34(absProjectDir) || !statSync13(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync33(resolve19(absProjectDir, entry))) {
+    if (!existsSync34(resolve19(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -35148,8 +35395,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync2(join35(tempRoot, "producer-project-"));
-  writeFileSync13(join35(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync2(join36(tempRoot, "producer-project-"));
+  writeFileSync13(join36(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -35272,7 +35519,7 @@ function createRenderHandlers(options = {}) {
       log2
     );
     const outputDir = dirname12(absoluteOutputPath);
-    if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
+    if (!existsSync34(outputDir)) mkdirSync19(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log2.info("render started", {
       requestId,
@@ -35299,7 +35546,7 @@ function createRenderHandlers(options = {}) {
           log2.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+      const fileSize = existsSync34(absoluteOutputPath) ? statSync13(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -35383,7 +35630,7 @@ function createRenderHandlers(options = {}) {
         log2
       );
       const outputDir = dirname12(absoluteOutputPath);
-      if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
+      if (!existsSync34(outputDir)) mkdirSync19(outputDir, { recursive: true });
       log2.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -35428,7 +35675,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+        const fileSize = existsSync34(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 });
@@ -35487,11 +35734,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync33(artifact.path)) {
+    if (!existsSync34(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",
@@ -35625,20 +35872,20 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { existsSync as existsSync34, readFileSync as readFileSync24, writeFileSync as writeFileSync14, statSync as statSync12 } from "fs";
-import { resolve as resolve20, join as join36, basename as basename3 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync24, writeFileSync as writeFileSync14, statSync as statSync14 } from "fs";
+import { resolve as resolve20, join as join37, basename as basename3 } from "path";
 function resolveDistDir() {
   return resolveStudioBundle().dir;
 }
 function resolveStudioBundle() {
   const builtPath = resolve20(__dirname, "studio");
   const builtIndex = resolve20(builtPath, "index.html");
-  if (existsSync34(builtIndex)) {
+  if (existsSync35(builtIndex)) {
     return { dir: builtPath, indexPath: builtIndex, available: true, checkedPaths: [builtIndex] };
   }
   const devPath = resolve20(__dirname, "..", "..", "..", "studio", "dist");
   const devIndex = resolve20(devPath, "index.html");
-  if (existsSync34(devIndex)) {
+  if (existsSync35(devIndex)) {
     return {
       dir: devPath,
       indexPath: devIndex,
@@ -35655,9 +35902,9 @@ function resolveStudioBundle() {
 }
 function resolveRuntimePath() {
   const builtPath = resolve20(__dirname, "hyperframe-runtime.js");
-  if (existsSync34(builtPath)) return builtPath;
+  if (existsSync35(builtPath)) return builtPath;
   const iifePath = resolve20(__dirname, "hyperframe.runtime.iife.js");
-  if (existsSync34(iifePath)) return iifePath;
+  if (existsSync35(iifePath)) return iifePath;
   const devPath = resolve20(
     __dirname,
     "..",
@@ -35667,7 +35914,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync34(devPath)) return devPath;
+  if (existsSync35(devPath)) return devPath;
   return builtPath;
 }
 async function getThumbnailBrowser() {
@@ -35729,7 +35976,7 @@ function createStudioServer(options) {
       return lintHyperframeHtml2(html, opts);
     },
     runtimeUrl: "/api/runtime.js",
-    rendersDir: () => join36(projectDir, "renders"),
+    rendersDir: () => join37(projectDir, "renders"),
     startRender(opts) {
       const state = {
         id: opts.jobId,
@@ -35844,7 +36091,7 @@ function createStudioServer(options) {
   });
   app.get("/api/runtime.js", (c2) => {
     const serve4 = async () => {
-      const runtimeSource = await loadRuntimeSource() ?? (existsSync34(runtimePath) ? readFileSync24(runtimePath, "utf-8") : null);
+      const runtimeSource = await loadRuntimeSource() ?? (existsSync35(runtimePath) ? readFileSync24(runtimePath, "utf-8") : null);
       if (!runtimeSource) return c2.text("runtime not available", 404);
       return c2.body(runtimeSource, 200, {
         "Content-Type": "text/javascript",
@@ -35880,7 +36127,7 @@ function createStudioServer(options) {
   });
   app.get("/assets/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync34(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync35(filePath) || !statSync14(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync24(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -35888,7 +36135,7 @@ function createStudioServer(options) {
   });
   app.get("/icons/*", (c2) => {
     const filePath = resolve20(studioDir, c2.req.path.slice(1));
-    if (!existsSync34(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    if (!existsSync35(filePath) || !statSync14(filePath).isFile()) return c2.text("not found", 404);
     const content = readFileSync24(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
@@ -35896,7 +36143,7 @@ function createStudioServer(options) {
   });
   app.get("*", (c2) => {
     const indexPath = resolve20(studioDir, "index.html");
-    if (!existsSync34(indexPath)) {
+    if (!existsSync35(indexPath)) {
       return c2.html(
         `<!doctype html>
 <html>
@@ -35976,20 +36223,20 @@ __export(preview_exports, {
   examples: () => examples
 });
 import { spawn as spawn8 } from "child_process";
-import { existsSync as existsSync35, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync20 } from "fs";
-import { resolve as resolve21, dirname as dirname13, basename as basename4, join as join37 } from "path";
+import { existsSync as existsSync36, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync20 } from "fs";
+import { resolve as resolve21, dirname as dirname13, basename as basename4, join as join38 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire } from "module";
 async function runDevMode(dir, projectName) {
   const thisFile = fileURLToPath4(import.meta.url);
   const repoRoot = resolve21(dirname13(thisFile), "..", "..", "..", "..");
-  const projectsDir = join37(repoRoot, "packages", "studio", "data", "projects");
+  const projectsDir = join38(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename4(dir);
-  const symlinkPath = join37(projectsDir, pName);
+  const symlinkPath = join38(projectsDir, pName);
   mkdirSync20(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync35(symlinkPath)) {
+    if (existsSync36(symlinkPath)) {
       try {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
@@ -36001,7 +36248,7 @@ async function runDevMode(dir, projectName) {
       } catch {
       }
     }
-    if (!existsSync35(symlinkPath)) {
+    if (!existsSync36(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -36009,7 +36256,7 @@ async function runDevMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview"));
   const s2 = be();
   s2.start("Starting studio...");
-  const studioPkgDir = join37(repoRoot, "packages", "studio");
+  const studioPkgDir = join38(repoRoot, "packages", "studio");
   const child = spawn8("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -36043,7 +36290,7 @@ async function runDevMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync36(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -36054,7 +36301,7 @@ async function runDevMode(dir, projectName) {
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join37(dir, "package.json"));
+    const req = createRequire(join38(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -36062,20 +36309,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir, projectName) {
-  const req = createRequire(join37(dir, "package.json"));
+  const req = createRequire(join38(dir, "package.json"));
   const studioPkgPath = dirname13(req.resolve("@hyperframes/studio/package.json"));
   const pName = projectName ?? basename4(dir);
-  const projectsDir = join37(studioPkgPath, "data", "projects");
-  const symlinkPath = join37(projectsDir, pName);
+  const projectsDir = join38(studioPkgPath, "data", "projects");
+  const symlinkPath = join38(projectsDir, pName);
   mkdirSync20(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync35(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync36(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve21(readlinkSync(symlinkPath)) !== resolve21(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
-    if (!existsSync35(symlinkPath)) {
+    if (!existsSync36(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -36114,7 +36361,7 @@ async function runLocalStudioMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync36(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -36290,8 +36537,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 = join37(dir, "index.html");
-        if (existsSync35(indexPath)) {
+        const indexPath = join38(dir, "index.html");
+        if (existsSync36(indexPath)) {
           const project = { dir, name: projectName, indexPath };
           const lintResult = lintProject(project);
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
@@ -36320,20 +36567,20 @@ __export(init_exports, {
   examples: () => examples2
 });
 import {
-  existsSync as existsSync36,
+  existsSync as existsSync37,
   mkdirSync as mkdirSync21,
   copyFileSync as copyFileSync3,
   cpSync,
   writeFileSync as writeFileSync15,
   readFileSync as readFileSync25,
-  readdirSync as readdirSync14
+  readdirSync as readdirSync15
 } from "fs";
-import { resolve as resolve22, basename as basename5, join as join38, dirname as dirname14 } from "path";
+import { resolve as resolve22, basename as basename5, join as join39, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { execFileSync as execFileSync4, spawn as spawn9 } from "child_process";
+import { execFileSync as execFileSync5, spawn as spawn9 } 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 }
@@ -36400,7 +36647,7 @@ function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname14(fileURLToPath5(import.meta.url));
   const devPath = resolve22(base, ...devSegments);
   const builtPath = resolve22(base, ...builtSegments);
-  return existsSync36(devPath) ? devPath : builtPath;
+  return existsSync37(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -36409,7 +36656,7 @@ function getSharedTemplateDir() {
   return resolveAssetDir(["..", "templates", "_shared"], ["templates", "_shared"]);
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync14(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join38(e2.parentPath ?? e2.path, e2.name));
+  const htmlFiles = readdirSync15(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join39(e2.parentPath ?? e2.path, e2.name));
   for (const file of htmlFiles) {
     let content = readFileSync25(file, "utf-8");
     if (videoFilename) {
@@ -36516,7 +36763,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
   mkdirSync21(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
-  if (existsSync36(templateDir)) {
+  if (existsSync37(templateDir)) {
     cpSync(templateDir, destDir, { recursive: true });
   } else {
     await fetchRemoteTemplate(templateId, destDir);
@@ -36535,14 +36782,14 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync36(resolve22(destDir, "hyperframes.json"))) {
+  if (!existsSync37(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 (existsSync36(sharedDir)) {
-    for (const entry of readdirSync14(sharedDir, { withFileTypes: true })) {
-      const src = join38(sharedDir, entry.name);
+  if (existsSync37(sharedDir)) {
+    for (const entry of readdirSync15(sharedDir, { withFileTypes: true })) {
+      const src = join39(sharedDir, entry.name);
       const dest = resolve22(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
@@ -36656,7 +36903,7 @@ var init_init = __esm({
           const templateId2 = exampleFlag ?? "blank";
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve22(name2);
-          if (existsSync36(destDir2) && readdirSync14(destDir2).length > 0) {
+          if (existsSync37(destDir2) && readdirSync15(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
@@ -36670,7 +36917,7 @@ var init_init = __esm({
           }
           if (videoFlag) {
             const videoPath = resolve22(videoFlag);
-            if (!existsSync36(videoPath)) {
+            if (!existsSync37(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -36684,7 +36931,7 @@ var init_init = __esm({
           }
           if (audioFlag) {
             const audioPath = resolve22(audioFlag);
-            if (!existsSync36(audioPath)) {
+            if (!existsSync37(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -36730,11 +36977,11 @@ var init_init = __esm({
           }
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve22(destDir2, "transcript.json");
-          if (existsSync36(transcriptFile2)) {
+          if (existsSync37(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f3 of readdirSync14(destDir2).filter((f4) => !f4.startsWith("."))) {
+          for (const f3 of readdirSync15(destDir2).filter((f4) => !f4.startsWith("."))) {
             console.log(`  ${c.accent(f3)}`);
           }
           console.log();
@@ -36782,7 +37029,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve22(name);
-        if (existsSync36(destDir) && readdirSync14(destDir).length > 0) {
+        if (existsSync37(destDir) && readdirSync15(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -36797,7 +37044,7 @@ var init_init = __esm({
         let videoDuration;
         if (videoFlag) {
           const videoPath = resolve22(videoFlag);
-          if (!existsSync36(videoPath)) {
+          if (!existsSync37(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -36809,7 +37056,7 @@ var init_init = __esm({
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
           const audioPath = resolve22(audioFlag);
-          if (!existsSync36(audioPath)) {
+          if (!existsSync37(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -36902,10 +37149,10 @@ ${c.dim("Use --example blank for offline use.")}`
         }
         trackInitTemplate(templateId);
         const transcriptFile = resolve22(destDir, "transcript.json");
-        if (existsSync36(transcriptFile)) {
+        if (existsSync37(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
-        const files = readdirSync14(destDir);
+        const files = readdirSync15(destDir);
         Vt2(files.map((f3) => c.accent(f3)).join("\n"), c.success(`Created ${name}/`));
         if (!skipSkills) {
           const installSkills = await Rt({
@@ -36934,9 +37181,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: [] };
   }
@@ -36988,7 +37235,7 @@ __export(add_exports, {
   remapTarget: () => remapTarget,
   runAdd: () => runAdd
 });
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { resolve as resolve23, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
@@ -37014,8 +37261,8 @@ function buildSnippet(item, relativeTarget) {
 async function runAdd(opts) {
   const projectDir = resolve23(opts.projectDir);
   let config = loadProjectConfig(projectDir);
-  const hasConfig = existsSync37(projectConfigPath(projectDir));
-  if (!hasConfig && existsSync37(resolve23(projectDir, "index.html"))) {
+  const hasConfig = existsSync38(projectConfigPath(projectDir));
+  if (!hasConfig && existsSync38(resolve23(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -37114,10 +37361,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 = existsSync37(projectConfigPath(projectDir));
+        const hasConfigBefore = existsSync38(projectConfigPath(projectDir));
         try {
           const result = await runAdd({ name: args.name, projectDir, skipClipboard });
-          const wroteConfig = !hasConfigBefore && existsSync37(projectConfigPath(projectDir));
+          const wroteConfig = !hasConfigBefore && existsSync38(projectConfigPath(projectDir));
           if (json) {
             console.log(JSON.stringify(result));
             return;
@@ -37327,17 +37574,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync38, statSync as statSync13 } from "fs";
+import { existsSync as existsSync39, 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 (!existsSync38(dir) || !statSync13(dir).isDirectory()) {
+  if (!existsSync39(dir) || !statSync15(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync38(indexPath)) {
+  if (!existsSync39(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -37360,7 +37607,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync39, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync26 } from "fs";
 import { resolve as resolve26, dirname as dirname15 } from "path";
 function commandDir() {
   return dirname15(new URL(import.meta.url).pathname);
@@ -37375,7 +37622,7 @@ function resolveRuntimePath2() {
     resolve26(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
-    if (existsSync39(p)) return p;
+    if (existsSync40(p)) return p;
   }
   return null;
 }
@@ -37389,7 +37636,7 @@ function resolvePlayerPath() {
     resolve26(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
-    if (existsSync39(p)) return p;
+    if (existsSync40(p)) return p;
   }
   return null;
 }
@@ -37491,7 +37738,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 (!existsSync39(filePath)) return ctx.text("Not found", 404);
+          if (!existsSync40(filePath)) return ctx.text("Not found", 404);
           const content = readFileSync26(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
@@ -37567,23 +37814,23 @@ var init_play = __esm({
 });
 
 // src/utils/publishProject.ts
-import { basename as basename7, join as join39, relative as relative4 } from "path";
-import { readdirSync as readdirSync15, readFileSync as readFileSync27, statSync as statSync14 } from "fs";
+import { basename as basename7, join as join40, relative as relative4 } from "path";
+import { readdirSync as readdirSync16, readFileSync as readFileSync27, statSync as statSync16 } from "fs";
 import AdmZip from "adm-zip";
 function shouldIgnoreSegment(segment) {
   return segment.startsWith(".") || IGNORED_DIRS.has(segment) || IGNORED_FILES.has(segment);
 }
 function collectProjectFiles(rootDir, currentDir, paths) {
-  for (const entry of readdirSync15(currentDir, { withFileTypes: true })) {
+  for (const entry of readdirSync16(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
-    const absolutePath = join39(currentDir, entry.name);
+    const absolutePath = join40(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);
   }
 }
@@ -37595,7 +37842,7 @@ function createPublishArchive(projectDir) {
   }
   const archive = new AdmZip();
   for (const filePath of filePaths) {
-    archive.addFile(filePath, readFileSync27(join39(projectDir, filePath)));
+    archive.addFile(filePath, readFileSync27(join40(projectDir, filePath)));
   }
   return {
     buffer: archive.toBuffer(),
@@ -37651,8 +37898,8 @@ __export(publish_exports, {
   examples: () => examples6
 });
 import { basename as basename8, resolve as resolve27 } from "path";
-import { existsSync as existsSync40 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync41 } from "fs";
+import { join as join41 } from "path";
 var examples6, publish_default;
 var init_publish = __esm({
   "src/commands/publish.ts"() {
@@ -37687,8 +37934,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 = join40(dir, "index.html");
-        if (existsSync40(indexPath)) {
+        const indexPath = join41(dir, "index.html");
+        if (existsSync41(indexPath)) {
           const lintResult = lintProject({ dir, name: projectName, indexPath });
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
             console.log();
@@ -37859,10 +38106,10 @@ __export(render_exports, {
   default: () => render_default,
   examples: () => examples7
 });
-import { mkdirSync as mkdirSync22, readFileSync as readFileSync28, statSync as statSync15, writeFileSync as writeFileSync16, rmSync as rmSync9 } from "fs";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync28, statSync as statSync17, writeFileSync as writeFileSync16, rmSync as rmSync9 } from "fs";
 import { cpus as cpus3, freemem as freemem3, tmpdir as tmpdir4 } from "os";
-import { resolve as resolve28, dirname as dirname16, join as join41, basename as basename9 } from "path";
-import { execFileSync as execFileSync5, spawn as spawn10 } from "child_process";
+import { resolve as resolve28, dirname as dirname16, join as join42, basename as basename9 } from "path";
+import { execFileSync as execFileSync6, spawn as spawn10 } from "child_process";
 function defaultWorkerCount() {
   return Math.max(1, Math.min(Math.floor(CPU_CORE_COUNT * 3 / 4), 8));
 }
@@ -37874,7 +38121,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;
@@ -37884,7 +38131,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;
@@ -37898,11 +38145,11 @@ function ensureDockerImage(version, quiet) {
   }
   if (!quiet) console.log(c.dim(`  Building Docker image: ${tag}...`));
   const dockerfilePath = resolveDockerfilePath();
-  const tmpDir = join41(tmpdir4(), `hyperframes-docker-${Date.now()}`);
+  const tmpDir = join42(tmpdir4(), `hyperframes-docker-${Date.now()}`);
   mkdirSync22(tmpDir, { recursive: true });
-  writeFileSync16(join41(tmpDir, "Dockerfile"), readFileSync28(dockerfilePath));
+  writeFileSync16(join42(tmpDir, "Dockerfile"), readFileSync28(dockerfilePath));
   try {
-    execFileSync5(
+    execFileSync6(
       "docker",
       [
         "build",
@@ -38087,7 +38334,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);
@@ -38248,7 +38495,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) : join41(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        const outputPath = args.output ? resolve28(args.output) : join42(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
         mkdirSync22(dirname16(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
@@ -38724,8 +38971,8 @@ __export(layout_exports, {
   examples: () => examples9
 });
 import { createServer } from "http";
-import { existsSync as existsSync41, readFileSync as readFileSync29 } from "fs";
-import { dirname as dirname17, isAbsolute as isAbsolute6, join as join42, relative as relative5, resolve as resolve29 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync29 } from "fs";
+import { dirname as dirname17, isAbsolute as isAbsolute6, join as join43, relative as relative5, resolve as resolve29 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -38795,7 +39042,7 @@ async function bundleProjectHtml(projectDir) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync41(runtimePath)) {
+  if (existsSync42(runtimePath)) {
     const runtimeSource = readFileSync29(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -38820,7 +39067,7 @@ async function serveProject(projectDir, html) {
       res.end();
       return;
     }
-    if (existsSync41(filePath)) {
+    if (existsSync42(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync29(filePath));
       return;
@@ -38924,11 +39171,11 @@ async function runLayoutAudit(projectDir, opts) {
 }
 function loadLayoutAuditScript() {
   const candidates = [
-    join42(__dirname2, "layout-audit.browser.js"),
-    join42(__dirname2, "commands", "layout-audit.browser.js")
+    join43(__dirname2, "layout-audit.browser.js"),
+    join43(__dirname2, "commands", "layout-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync41(candidate)) return readFileSync29(candidate, "utf-8");
+    if (existsSync42(candidate)) return readFileSync29(candidate, "utf-8");
   }
   throw new Error("Missing layout audit browser script");
 }
@@ -39148,16 +39395,16 @@ __export(info_exports, {
   default: () => info_default,
   examples: () => examples11
 });
-import { readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync16 } from "fs";
-import { join as join43 } from "path";
+import { readFileSync as readFileSync30, readdirSync as readdirSync17, statSync as statSync18 } from "fs";
+import { join as join44 } from "path";
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync16(dir, { withFileTypes: true })) {
-    const path2 = join43(dir, entry.name);
+  for (const entry of readdirSync17(dir, { withFileTypes: true })) {
+    const path2 = join44(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
     } else {
-      total += statSync16(path2).size;
+      total += statSync18(path2).size;
     }
   }
   return total;
@@ -39241,7 +39488,7 @@ __export(compositions_exports, {
   default: () => compositions_default,
   examples: () => examples12
 });
-import { existsSync as existsSync42, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync31 } from "fs";
 import { resolve as resolve30, dirname as dirname18 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
@@ -39255,7 +39502,7 @@ function parseCompositions(html, baseDir) {
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
       const subPath = resolve30(baseDir, compositionSrc);
-      if (existsSync42(subPath)) {
+      if (existsSync43(subPath)) {
         const subHtml = readFileSync31(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
@@ -39388,8 +39635,8 @@ __export(benchmark_exports, {
   default: () => benchmark_default,
   examples: () => examples13
 });
-import { existsSync as existsSync43, statSync as statSync17 } from "fs";
-import { resolve as resolve31, join as join44 } from "path";
+import { existsSync as existsSync44, statSync as statSync19 } from "fs";
+import { resolve as resolve31, join as join45 } from "path";
 var examples13, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -39464,7 +39711,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 = join44(
+            const outputPath = join45(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i2}.mp4`
             );
@@ -39478,8 +39725,8 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync43(outputPath)) {
-                const stat3 = statSync17(outputPath);
+              if (existsSync44(outputPath)) {
+                const stat3 = statSync19(outputPath);
                 fileSize = stat3.size;
               }
               runs.push({ elapsedMs, fileSize });
@@ -39694,8 +39941,8 @@ __export(transcribe_exports2, {
   default: () => transcribe_default,
   examples: () => examples15
 });
-import { existsSync as existsSync44, writeFileSync as writeFileSync17 } from "fs";
-import { resolve as resolve32, join as join45, extname as extname8 } from "path";
+import { existsSync as existsSync45, writeFileSync as writeFileSync17 } from "fs";
+import { resolve as resolve32, join as join46, 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);
@@ -39703,7 +39950,7 @@ async function importTranscript(inputPath, dir, json) {
     console.error(c.error("No words found in transcript."));
     process.exit(1);
   }
-  const outPath = join45(dir, "transcript.json");
+  const outPath = join46(dir, "transcript.json");
   writeFileSync17(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
@@ -39820,7 +40067,7 @@ var init_transcribe2 = __esm({
       },
       async run({ args }) {
         const inputPath = resolve32(args.input);
-        if (!existsSync44(inputPath)) {
+        if (!existsSync45(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
@@ -39841,9 +40088,9 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync23 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join46 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync23 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join47 } from "path";
 function inferLangFromVoiceId(voiceId) {
   const first = voiceId.charAt(0).toLowerCase();
   return VOICE_PREFIX_LANG[first] ?? "en-us";
@@ -39852,8 +40099,8 @@ function isSupportedLang(value) {
   return SUPPORTED_LANGS.includes(value);
 }
 async function ensureModel2(model = DEFAULT_MODEL2, options) {
-  const modelPath = join46(MODELS_DIR2, `${model}.onnx`);
-  if (existsSync45(modelPath)) return modelPath;
+  const modelPath = join47(MODELS_DIR2, `${model}.onnx`);
+  if (existsSync46(modelPath)) return modelPath;
   const url = MODEL_URLS[model];
   if (!url) {
     throw new Error(
@@ -39863,18 +40110,18 @@ async function ensureModel2(model = DEFAULT_MODEL2, options) {
   mkdirSync23(MODELS_DIR2, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath);
-  if (!existsSync45(modelPath)) {
+  if (!existsSync46(modelPath)) {
     throw new Error(`Model download failed: ${model}`);
   }
   return modelPath;
 }
 async function ensureVoices(options) {
-  const voicesPath = join46(VOICES_DIR, "voices-v1.0.bin");
-  if (existsSync45(voicesPath)) return voicesPath;
+  const voicesPath = join47(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync46(voicesPath)) return voicesPath;
   mkdirSync23(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
-  if (!existsSync45(voicesPath)) {
+  if (!existsSync46(voicesPath)) {
     throw new Error("Voice data download failed");
   }
   return voicesPath;
@@ -39884,9 +40131,9 @@ var init_manager3 = __esm({
   "src/tts/manager.ts"() {
     "use strict";
     init_download();
-    CACHE_DIR3 = join46(homedir8(), ".cache", "hyperframes", "tts");
-    MODELS_DIR2 = join46(CACHE_DIR3, "models");
-    VOICES_DIR = join46(CACHE_DIR3, "voices");
+    CACHE_DIR3 = join47(homedir9(), ".cache", "hyperframes", "tts");
+    MODELS_DIR2 = join47(CACHE_DIR3, "models");
+    VOICES_DIR = join47(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"
@@ -39946,22 +40193,22 @@ var synthesize_exports = {};
 __export(synthesize_exports, {
   synthesize: () => synthesize
 });
-import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync46, writeFileSync as writeFileSync18, mkdirSync as mkdirSync24, readdirSync as readdirSync17, unlinkSync as unlinkSync6 } from "fs";
-import { join as join47, dirname as dirname19, basename as basename10 } from "path";
-import { homedir as homedir9 } from "os";
+import { execFileSync as execFileSync7 } from "child_process";
+import { existsSync as existsSync47, writeFileSync as writeFileSync18, mkdirSync as mkdirSync24, readdirSync as readdirSync18, unlinkSync as unlinkSync6 } from "fs";
+import { join as join48, dirname as dirname19, 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
@@ -39974,7 +40221,7 @@ function findPython() {
 }
 function hasPythonPackage(python, pkg) {
   try {
-    execFileSync6(python, ["-c", `import ${pkg}`], {
+    execFileSync7(python, ["-c", `import ${pkg}`], {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     });
@@ -39984,15 +40231,15 @@ function hasPythonPackage(python, pkg) {
   }
 }
 function ensureSynthScript() {
-  if (!existsSync46(SCRIPT_PATH)) {
+  if (!existsSync47(SCRIPT_PATH)) {
     mkdirSync24(SCRIPT_DIR, { recursive: true });
     writeFileSync18(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename10(SCRIPT_PATH);
     try {
-      for (const entry of readdirSync17(SCRIPT_DIR)) {
+      for (const entry of readdirSync18(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync6(join47(SCRIPT_DIR, entry));
+            unlinkSync6(join48(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -40029,7 +40276,7 @@ async function synthesize(text, outputPath, options) {
   mkdirSync24(dirname19(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],
       {
@@ -40038,7 +40285,7 @@ async function synthesize(text, outputPath, options) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    if (!existsSync46(outputPath)) {
+    if (!existsSync47(outputPath)) {
       throw new Error("Synthesis completed but no output file was created");
     }
     const lines = stdout2.trim().split("\n");
@@ -40051,7 +40298,7 @@ async function synthesize(text, outputPath, options) {
       langApplied: result.langApplied
     };
   } catch (err) {
-    if (err instanceof SyntaxError && existsSync46(outputPath)) {
+    if (err instanceof SyntaxError && existsSync47(outputPath)) {
       throw new Error(
         "Speech was generated but metadata could not be read. Check the output file manually."
       );
@@ -40102,8 +40349,8 @@ print(json.dumps({
     "langApplied": bool(lang and supports_lang),
 }))
 `;
-    SCRIPT_DIR = join47(homedir9(), ".cache", "hyperframes", "tts");
-    SCRIPT_PATH = join47(SCRIPT_DIR, "synth-v2.py");
+    SCRIPT_DIR = join48(homedir10(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join48(SCRIPT_DIR, "synth-v2.py");
   }
 });
 
@@ -40113,7 +40360,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples16
 });
-import { existsSync as existsSync47, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync32 } 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) }));
@@ -40223,7 +40470,7 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve33(args.input);
-        if (existsSync47(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
+        if (existsSync48(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync32(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
@@ -40316,15 +40563,15 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples17
 });
-import { readFileSync as readFileSync33, existsSync as existsSync48 } from "fs";
-import { resolve as resolve34, dirname as dirname20, join as join48 } from "path";
+import { readFileSync as readFileSync33, existsSync as existsSync49 } from "fs";
+import { resolve as resolve34, dirname as dirname20, join as join49 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath7(import.meta.url);
   const dir = dirname20(thisFile);
   const devPath = resolve34(dir, "..", "docs");
   const builtPath = resolve34(dir, "docs");
-  return existsSync48(devPath) ? devPath : builtPath;
+  return existsSync49(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -40421,8 +40668,8 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join48(docsDir(), entry.file);
-        if (!existsSync48(filePath)) {
+        const filePath = join49(docsDir(), entry.file);
+        if (!existsSync49(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
@@ -40441,7 +40688,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) {
@@ -40606,7 +40853,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(
@@ -40852,8 +41099,8 @@ var validate_exports = {};
 __export(validate_exports, {
   default: () => validate_default
 });
-import { existsSync as existsSync49, readFileSync as readFileSync34 } from "fs";
-import { resolve as resolve35, join as join49, dirname as dirname21 } from "path";
+import { existsSync as existsSync50, readFileSync as readFileSync34 } from "fs";
+import { resolve as resolve35, join as join50, dirname as dirname21 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function getCompositionDuration3(page) {
   return page.evaluate(() => {
@@ -40908,7 +41155,7 @@ async function validateInBrowser(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync49(runtimePath)) {
+  if (existsSync50(runtimePath)) {
     const runtimeSource = readFileSync34(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -40924,8 +41171,8 @@ async function validateInBrowser(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = join49(projectDir, decodeURIComponent(url));
-    if (existsSync49(filePath)) {
+    const filePath = join50(projectDir, decodeURIComponent(url));
+    if (existsSync50(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync34(filePath));
       return;
@@ -41118,13 +41365,13 @@ __export(snapshot_exports, {
   examples: () => examples21
 });
 import { spawn as spawn11 } from "child_process";
-import { existsSync as existsSync50, mkdtempSync as mkdtempSync3, readFileSync as readFileSync35, mkdirSync as mkdirSync25, rmSync as rmSync10 } from "fs";
+import { existsSync as existsSync51, mkdtempSync as mkdtempSync3, readFileSync as readFileSync35, mkdirSync as mkdirSync25, rmSync as rmSync10 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { resolve as resolve36, join as join50, dirname as dirname22, relative as relative6, isAbsolute as isAbsolute7 } from "path";
+import { resolve as resolve36, join as join51, dirname as dirname22, relative as relative6, isAbsolute as isAbsolute7 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
-  const tmp = mkdtempSync3(join50(tmpdir5(), "hf-snapshot-frame-"));
-  const outPath = join50(tmp, "frame.png");
+  const tmp = mkdtempSync3(join51(tmpdir5(), "hf-snapshot-frame-"));
+  const outPath = join51(tmp, "frame.png");
   try {
     const result = await new Promise(
       (resolvePromise) => {
@@ -41164,7 +41411,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
         });
       }
     );
-    if (result.code !== 0 || result.timedOut || !existsSync50(outPath)) return null;
+    if (result.code !== 0 || result.timedOut || !existsSync51(outPath)) return null;
     return readFileSync35(outPath);
   } finally {
     try {
@@ -41187,7 +41434,7 @@ async function captureSnapshots(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync50(runtimePath)) {
+  if (existsSync51(runtimePath)) {
     const runtimeSource = readFileSync35(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
@@ -41210,7 +41457,7 @@ async function captureSnapshots(projectDir, opts) {
       res.end();
       return;
     }
-    if (existsSync50(filePath)) {
+    if (existsSync51(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
       res.end(readFileSync35(filePath));
       return;
@@ -41285,7 +41532,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 = join50(projectDir, "snapshots");
+      const snapshotDir = join51(projectDir, "snapshots");
       mkdirSync25(snapshotDir, { recursive: true });
       let injectVideoFramesBatch2 = null;
       let syncVideoFrameVisibility2 = null;
@@ -41360,7 +41607,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) && existsSync50(candidate)) {
+              if (!rel.startsWith("..") && !isAbsolute7(rel) && existsSync51(candidate)) {
                 filePath = candidate;
               }
             } catch {
@@ -41390,7 +41637,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 = join50(snapshotDir, filename);
+        const framePath = join51(snapshotDir, filename);
         await page.screenshot({ path: framePath, type: "png" });
         savedPaths.push(`snapshots/${filename}`);
       }
@@ -41476,13 +41723,13 @@ ${c.error("\u2717")} Snapshot failed: ${msg}`);
 
 // src/capture/assetDownloader.ts
 import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync26 } from "fs";
-import { join as join51, extname as extname10 } from "path";
+import { join as join52, extname as extname10 } from "path";
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
-  const assetsDir = join51(outputDir, "assets");
+  const assetsDir = join52(outputDir, "assets");
   mkdirSync26(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync26(join51(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync26(join52(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;
@@ -41490,7 +41737,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 {
-      writeFileSync19(join51(outputDir, localPath), svg.outerHTML, "utf-8");
+      writeFileSync19(join52(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
@@ -41503,7 +41750,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
       if (buffer) {
-        writeFileSync19(join51(outputDir, localPath), buffer);
+        writeFileSync19(join52(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -41560,7 +41807,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
         const slug = isMeaningful ? slugify(rawName) : `${prefix}-${imgIdx}`;
         const name = `${slug}${ext}`;
         const localPath = `assets/${name}`;
-        writeFileSync19(join51(outputDir, localPath), buffer);
+        writeFileSync19(join52(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -41573,7 +41820,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) {
-        writeFileSync19(join51(outputDir, localPath), buffer);
+        writeFileSync19(join52(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -41596,7 +41843,7 @@ function normalizeUrl(u) {
   }
 }
 async function downloadAndRewriteFonts(css, outputDir) {
-  const assetsDir = join51(outputDir, "assets", "fonts");
+  const assetsDir = join52(outputDir, "assets", "fonts");
   mkdirSync26(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
@@ -41632,7 +41879,7 @@ async function downloadAndRewriteFonts(css, outputDir) {
     try {
       const urlObj = new URL(fontUrl);
       const filename = urlObj.pathname.split("/").pop() || `font-${count}.woff2`;
-      const localPath = join51(assetsDir, filename);
+      const localPath = join52(assetsDir, filename);
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
@@ -42429,8 +42676,8 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync27, writeFileSync as writeFileSync20, readdirSync as readdirSync18, readFileSync as readFileSync36, statSync as statSync18 } from "fs";
-import { join as join52 } from "path";
+import { mkdirSync as mkdirSync27, writeFileSync as writeFileSync20, readdirSync as readdirSync19, readFileSync as readFileSync36, statSync as statSync20 } from "fs";
+import { join as join53 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -42463,7 +42710,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
             const hash2 = buf.toString("base64").slice(0, 100);
             if (savedHashes.has(hash2)) continue;
             savedHashes.add(hash2);
-            writeFileSync20(join52(lottieDir, `animation-${savedCount}.lottie`), buf);
+            writeFileSync20(join53(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -42481,7 +42728,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync20(join52(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync20(join53(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -42491,22 +42738,22 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
-  const previewDir = join52(lottieDir, "previews");
+  const previewDir = join53(lottieDir, "previews");
   mkdirSync27(previewDir, { recursive: true });
-  for (const file of readdirSync18(lottieDir)) {
+  for (const file of readdirSync19(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync36(join52(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync36(join53(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(join52(lottieDir, file)).size;
+      const fileSize = statSync20(join53(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(readFileSync36(join52(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync36(join53(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -42536,7 +42783,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
         await previewPage.waitForFunction(() => window.__READY === true, { timeout: 5e3 }).catch(() => {
         });
         await previewPage.screenshot({
-          path: join52(previewDir, previewName),
+          path: join53(previewDir, previewName),
           type: "png",
           omitBackground: true
         });
@@ -42560,7 +42807,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   }
   if (manifest.length > 0) {
     writeFileSync20(
-      join52(outputDir, "extracted", "lottie-manifest.json"),
+      join53(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -42622,15 +42869,15 @@ async function captureVideoManifest(page, outputDir, progress) {
     return true;
   });
   if (uniqueVideos.length > 0) {
-    const videoManifestDir = join52(outputDir, "assets", "videos");
+    const videoManifestDir = join53(outputDir, "assets", "videos");
     mkdirSync27(videoManifestDir, { recursive: true });
-    const previewDir = join52(videoManifestDir, "previews");
+    const previewDir = join53(videoManifestDir, "previews");
     mkdirSync27(previewDir, { recursive: true });
     const videoManifest = [];
     for (let vi = 0; vi < uniqueVideos.length && vi < 20; vi++) {
       const v = uniqueVideos[vi];
       const previewName = `video-${vi}-preview.png`;
-      const previewPath = join52(previewDir, previewName);
+      const previewPath = join53(previewDir, previewName);
       try {
         await page.evaluate(`window.scrollTo(0, ${Math.max(0, v.top - 100)})`);
         await new Promise((r2) => setTimeout(r2, 300));
@@ -42669,7 +42916,7 @@ async function captureVideoManifest(page, outputDir, progress) {
     }
     if (videoManifest.length > 0) {
       writeFileSync20(
-        join52(outputDir, "extracted", "video-manifest.json"),
+        join53(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
       );
@@ -49623,7 +49870,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({
@@ -49633,10 +49880,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,
@@ -83124,8 +83371,8 @@ ${underline2}`);
 });
 
 // src/capture/contentExtractor.ts
-import { readdirSync as readdirSync19, statSync as statSync20, readFileSync as readFileSync37 } from "fs";
-import { join as join53 } from "path";
+import { readdirSync as readdirSync20, statSync as statSync22, readFileSync as readFileSync37 } from "fs";
+import { join as join54 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
   try {
@@ -83245,7 +83492,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 = readdirSync19(join53(outputDir, "assets")).filter(
+    const imageFiles = readdirSync20(join54(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";
@@ -83254,8 +83501,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 = join53(outputDir, "assets", file);
-          const stat3 = statSync20(filePath);
+          const filePath = join54(outputDir, "assets", file);
+          const stat3 = statSync22(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
           const buffer = readFileSync37(filePath);
           const base64 = buffer.toString("base64");
@@ -83303,12 +83550,12 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join53(outputDir, "assets");
+  const assetsPath = join54(outputDir, "assets");
   try {
-    for (const file of readdirSync19(assetsPath)) {
+    for (const file of readdirSync20(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join53(assetsPath, file);
-      const stat3 = statSync20(filePath);
+      const filePath = join54(assetsPath, file);
+      const stat3 = statSync22(filePath);
       if (!stat3.isFile()) continue;
       const sizeKb = Math.round(stat3.size / 1024);
       const catalogMatch = catalogedAssets.find(
@@ -83336,8 +83583,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join53(assetsPath, "svgs");
-    for (const file of readdirSync19(svgsPath)) {
+    const svgsPath = join54(assetsPath, "svgs");
+    for (const file of readdirSync20(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
         (s2) => s2.label && file.includes(
@@ -83351,8 +83598,8 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join53(assetsPath, "fonts");
-    for (const file of readdirSync19(fontsPath)) {
+    const fontsPath = join54(assetsPath, "fonts");
+    for (const file of readdirSync20(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
   } catch {
@@ -83371,12 +83618,12 @@ __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
 import { writeFileSync as writeFileSync21 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, detectedLibraries) {
   const prompt = buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries);
-  writeFileSync21(join54(outputDir, "AGENTS.md"), prompt, "utf-8");
-  writeFileSync21(join54(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync21(join54(outputDir, ".cursorrules"), prompt, "utf-8");
+  writeFileSync21(join55(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync21(join55(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync21(join55(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -83443,8 +83690,8 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync51, writeFileSync as writeFileSync22, readFileSync as readFileSync38 } from "fs";
-import { join as join55, resolve as resolve37 } from "path";
+import { existsSync as existsSync52, writeFileSync as writeFileSync22, readFileSync as readFileSync38 } from "fs";
+import { join as join56, resolve as resolve37 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve37(startDir);
@@ -83470,8 +83717,8 @@ function loadEnvFile(startDir) {
   }
 }
 async function generateProjectScaffold(outputDir, url, tokens, animationCatalog, hasScreenshots, hasLotties, hasShaders, catalogedAssets, progress, warnings, detectedLibraries) {
-  const metaPath = join55(outputDir, "meta.json");
-  if (!existsSync51(metaPath)) {
+  const metaPath = join56(outputDir, "meta.json");
+  if (!existsSync52(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
     writeFileSync22(
       metaPath,
@@ -83509,9 +83756,9 @@ __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
 import { writeFileSync as writeFileSync23, mkdirSync as mkdirSync28 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
-  const screenshotsDir = join56(outputDir, "screenshots");
+  const screenshotsDir = join57(outputDir, "screenshots");
   mkdirSync28(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
@@ -83545,7 +83792,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 = join56(screenshotsDir, filename);
+      const filePath = join57(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
       writeFileSync23(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
@@ -83858,8 +84105,8 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync24, existsSync as existsSync52 } from "fs";
-import { join as join57 } from "path";
+import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync24, existsSync as existsSync53 } from "fs";
+import { join as join58 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -83876,9 +84123,9 @@ async function captureWebsite(opts, onProgress) {
     onProgress?.(stage, detail);
   };
   loadEnvFile(outputDir);
-  mkdirSync29(join57(outputDir, "extracted"), { recursive: true });
-  mkdirSync29(join57(outputDir, "screenshots"), { recursive: true });
-  mkdirSync29(join57(outputDir, "assets"), { recursive: true });
+  mkdirSync29(join58(outputDir, "extracted"), { recursive: true });
+  mkdirSync29(join58(outputDir, "screenshots"), { recursive: true });
+  mkdirSync29(join58(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -84034,7 +84281,7 @@ async function captureWebsite(opts, onProgress) {
     } catch {
     }
     if (discoveredLotties.length > 0) {
-      const lottieDir = join57(outputDir, "assets", "lottie");
+      const lottieDir = join58(outputDir, "assets", "lottie");
       mkdirSync29(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
@@ -84054,7 +84301,7 @@ async function captureWebsite(opts, onProgress) {
         });
         capturedShaders = unique;
         writeFileSync24(
-          join57(outputDir, "extracted", "shaders.json"),
+          join58(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -84065,7 +84312,7 @@ async function captureWebsite(opts, onProgress) {
     progress("tokens", "Extracting design tokens...");
     const tokens = await extractTokens(page1);
     writeFileSync24(
-      join57(outputDir, "extracted", "tokens.json"),
+      join58(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokens, null, 2),
       "utf-8"
     );
@@ -84139,7 +84386,7 @@ async function captureWebsite(opts, onProgress) {
         representativeAnimations: representativeAnims
       };
       writeFileSync24(
-        join57(outputDir, "extracted", "animations.json"),
+        join58(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -84150,18 +84397,18 @@ async function captureWebsite(opts, onProgress) {
       assets = await downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks);
     }
     if (visibleTextContent) {
-      writeFileSync24(join57(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync24(join58(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     if (catalogedAssets.length > 0) {
       writeFileSync24(
-        join57(outputDir, "extracted", "assets-catalog.json"),
+        join58(outputDir, "extracted", "assets-catalog.json"),
         JSON.stringify(catalogedAssets, null, 2),
         "utf-8"
       );
     }
     if (detectedLibraries.length > 0) {
       writeFileSync24(
-        join57(outputDir, "extracted", "detected-libraries.json"),
+        join58(outputDir, "extracted", "detected-libraries.json"),
         JSON.stringify(detectedLibraries, null, 2),
         "utf-8"
       );
@@ -84172,7 +84419,7 @@ async function captureWebsite(opts, onProgress) {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
         writeFileSync24(
-          join57(outputDir, "extracted", "asset-descriptions.md"),
+          join58(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"
         );
@@ -84188,7 +84435,7 @@ async function captureWebsite(opts, onProgress) {
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync52(join57(outputDir, "extracted", "shaders.json")),
+      existsSync53(join58(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
       warnings,
@@ -84536,8 +84783,8 @@ __export(autoUpdate_exports, {
 });
 import { spawn as spawn12 } from "child_process";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync30, openSync } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join58 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join59 } from "path";
 import { compareVersions as compareVersions2 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -84560,7 +84807,7 @@ function log(line) {
 }
 function launchDetachedInstall(installCommand, version) {
   mkdirSync30(CONFIG_DIR2, { recursive: true, mode: 448 });
-  const configFile = join58(CONFIG_DIR2, "config.json");
+  const configFile = join59(CONFIG_DIR2, "config.json");
   const nodeScript = `
     const { exec } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -84679,8 +84926,8 @@ var init_autoUpdate = __esm({
     init_config();
     init_env();
     init_installerDetection();
-    CONFIG_DIR2 = join58(homedir10(), ".hyperframes");
-    LOG_FILE = join58(CONFIG_DIR2, "auto-update.log");
+    CONFIG_DIR2 = join59(homedir11(), ".hyperframes");
+    LOG_FILE = join59(CONFIG_DIR2, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });