hyperframes 0.4.27 → 0.4.29

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.27" : "0.0.0-dev";
+    VERSION = true ? "0.4.29" : "0.0.0-dev";
   }
 });
 
@@ -9838,8 +9838,8 @@ function flushSync() {
   eventQueue = [];
   const payload = JSON.stringify({ api_key: POSTHOG_API_KEY, batch });
   try {
-    const { spawn: spawn13 } = __require("child_process");
-    const child = spawn13(
+    const { spawn: spawn14 } = __require("child_process");
+    const child = spawn14(
       process.execPath,
       [
         "-e",
@@ -10491,9 +10491,9 @@ function findWavDataChunk(buf) {
   return null;
 }
 function detectSpeechOnset(wavPath) {
-  const SAMPLE_RATE = 16e3;
+  const SAMPLE_RATE2 = 16e3;
   const WINDOW_SECONDS = 0.5;
-  const WINDOW_SAMPLES = SAMPLE_RATE * WINDOW_SECONDS;
+  const WINDOW_SAMPLES = SAMPLE_RATE2 * WINDOW_SECONDS;
   const SUSTAINED_WINDOWS = 3;
   const SILENCE_THRESHOLD_RATIO = 0.6;
   const MIN_INTRO_SECONDS = 3;
@@ -11390,11 +11390,138 @@ var init_projects = __esm({
   }
 });
 
+// ../core/src/studio-api/helpers/mime.ts
+function getMimeType(path2) {
+  const ext = path2.slice(path2.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function isAudioFile2(name) {
+  return (getMimeType(name) ?? "").startsWith("audio/");
+}
+var MIME_TYPES;
+var init_mime = __esm({
+  "../core/src/studio-api/helpers/mime.ts"() {
+    "use strict";
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".css": "text/css",
+      ".js": "text/javascript",
+      ".mjs": "text/javascript",
+      ".json": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".ico": "image/x-icon",
+      ".mp4": "video/mp4",
+      ".mov": "video/quicktime",
+      ".webm": "video/webm",
+      ".mp3": "audio/mpeg",
+      ".wav": "audio/wav",
+      ".ogg": "audio/ogg",
+      ".m4a": "audio/mp4",
+      ".aac": "audio/aac",
+      ".flac": "audio/flac",
+      ".opus": "audio/ogg",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".txt": "text/plain",
+      ".md": "text/markdown"
+    };
+  }
+});
+
+// ../core/src/studio-api/helpers/waveform.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join11 } from "path";
+function buildWaveformCacheKey(assetPath) {
+  return `${WAVEFORM_CACHE_VERSION}_${assetPath.replace(/[/\\]/g, "_")}.json`;
+}
+function computePeaks(floats, count) {
+  const step = floats.length / count;
+  const peaks = [];
+  for (let i2 = 0; i2 < count; i2++) {
+    const start = Math.floor(i2 * step);
+    const end = Math.min(Math.floor((i2 + 1) * step), floats.length);
+    let max = 0;
+    for (let j2 = start; j2 < end; j2++) {
+      const abs = Math.abs(floats[j2] ?? 0);
+      if (abs > max) max = abs;
+    }
+    peaks.push(max);
+  }
+  const maxPeak = Math.max(...peaks, 1e-3);
+  return peaks.map((p) => p / maxPeak);
+}
+function decodeAudioPeaks(audioPath) {
+  return new Promise((resolve39, reject) => {
+    const proc = spawn2(
+      "ffmpeg",
+      [
+        "-i",
+        audioPath,
+        "-af",
+        "atrim=start_sample=1152",
+        "-f",
+        "f32le",
+        "-ac",
+        "1",
+        "-ar",
+        String(SAMPLE_RATE),
+        "-vn",
+        "pipe:1"
+      ],
+      { stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const chunks = [];
+    proc.stdout?.on("data", (chunk) => chunks.push(chunk));
+    proc.on("close", (code) => {
+      if (code !== 0 && chunks.length === 0) {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+        return;
+      }
+      const buf = Buffer.concat(chunks);
+      const numSamples = Math.floor(buf.length / 4);
+      if (numSamples === 0) {
+        reject(new Error("ffmpeg produced no audio samples"));
+        return;
+      }
+      const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + numSamples * 4);
+      resolve39(computePeaks(new Float32Array(ab), PEAK_COUNT));
+    });
+    proc.on("error", reject);
+  });
+}
+async function generateWaveformCache(projectDir, assetPath) {
+  const audioPath = join11(projectDir, assetPath);
+  if (!existsSync9(audioPath)) return;
+  const cacheDir = join11(projectDir, ".waveform-cache");
+  const cachePath2 = join11(cacheDir, buildWaveformCacheKey(assetPath));
+  if (existsSync9(cachePath2)) return;
+  const peaks = await decodeAudioPeaks(audioPath);
+  mkdirSync5(cacheDir, { recursive: true });
+  writeFileSync5(cachePath2, JSON.stringify(peaks));
+}
+var SAMPLE_RATE, PEAK_COUNT, WAVEFORM_CACHE_VERSION;
+var init_waveform = __esm({
+  "../core/src/studio-api/helpers/waveform.ts"() {
+    "use strict";
+    SAMPLE_RATE = 4e3;
+    PEAK_COUNT = 4e3;
+    WAVEFORM_CACHE_VERSION = "v2";
+  }
+});
+
 // ../core/src/studio-api/helpers/mediaValidation.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename, join as join11 } from "path";
+import { basename, join as join12 } from "path";
 function validateUploadedMedia(filePath, runner = spawnSync) {
   const isVideo2 = VIDEO_EXT.test(filePath);
   const isAudio = AUDIO_EXT.test(filePath);
@@ -11433,10 +11560,10 @@ function validateUploadedMedia(filePath, runner = spawnSync) {
   }
 }
 function validateUploadedMediaBuffer(fileName, buffer, runner = spawnSync) {
-  const tempDir = mkdtempSync(join11(tmpdir2(), "hyperframes-upload-"));
-  const tempPath = join11(tempDir, basename(fileName));
+  const tempDir = mkdtempSync(join12(tmpdir2(), "hyperframes-upload-"));
+  const tempPath = join12(tempDir, basename(fileName));
   try {
-    writeFileSync5(tempPath, buffer);
+    writeFileSync6(tempPath, buffer);
     return validateUploadedMedia(tempPath, runner);
   } finally {
     rmSync2(tempDir, { recursive: true, force: true });
@@ -23289,7 +23416,7 @@ var init_html_classes = __esm({
 
 // ../../node_modules/.bun/linkedom@0.18.12/node_modules/linkedom/esm/shared/mime.js
 var voidElements2, Mime;
-var init_mime = __esm({
+var init_mime2 = __esm({
   "../../node_modules/.bun/linkedom@0.18.12/node_modules/linkedom/esm/shared/mime.js"() {
     "use strict";
     voidElements2 = { test: () => true };
@@ -23554,7 +23681,7 @@ var init_document = __esm({
     init_symbols();
     init_facades();
     init_html_classes();
-    init_mime();
+    init_mime2();
     init_utils2();
     init_object();
     init_non_element_parent_node();
@@ -24093,17 +24220,17 @@ var init_sourceMutation = __esm({
 // ../core/src/studio-api/routes/files.ts
 import { bodyLimit } from "hono/body-limit";
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   readFileSync as readFileSync9,
-  writeFileSync as writeFileSync6,
-  mkdirSync as mkdirSync5,
+  writeFileSync as writeFileSync7,
+  mkdirSync as mkdirSync6,
   unlinkSync as unlinkSync3,
   rmSync as rmSync3,
   statSync,
   renameSync as renameSync2,
   readdirSync as readdirSync4
 } from "fs";
-import { resolve as resolve9, dirname as dirname5, join as join12 } from "path";
+import { resolve as resolve9, dirname as dirname5, join as join13 } from "path";
 async function resolveProjectFile(c2, adapter2, opts) {
   const id = c2.req.param("id");
   const project = await adapter2.resolveProject(id);
@@ -24118,14 +24245,14 @@ async function resolveProjectFile(c2, adapter2, opts) {
   if (!isSafePath(project.dir, absPath)) {
     return { error: c2.json({ error: "forbidden" }, 403) };
   }
-  if (opts?.mustExist && !existsSync9(absPath)) {
+  if (opts?.mustExist && !existsSync10(absPath)) {
     return { error: c2.json({ error: "not found" }, 404) };
   }
   return { project, filePath, absPath };
 }
 function ensureDir(filePath) {
   const dir = dirname5(filePath);
-  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
 }
 function generateCopyPath(projectDir, originalPath) {
   const ext = originalPath.includes(".") ? "." + originalPath.split(".").pop() : "";
@@ -24134,7 +24261,7 @@ function generateCopyPath(projectDir, originalPath) {
   const cleanBase = copyMatch ? base.slice(0, -copyMatch[0].length) : base;
   let num = copyMatch ? copyMatch[1] ? parseInt(copyMatch[1]) + 1 : 2 : 1;
   let candidate = num === 1 ? `${cleanBase} (copy)${ext}` : `${cleanBase} (copy ${num})${ext}`;
-  while (existsSync9(resolve9(projectDir, candidate))) {
+  while (existsSync10(resolve9(projectDir, candidate))) {
     num++;
     candidate = `${cleanBase} (copy ${num})${ext}`;
   }
@@ -24143,7 +24270,7 @@ function generateCopyPath(projectDir, originalPath) {
 function walkFiles(dir, filter2) {
   const results = [];
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const full = join12(dir, entry.name);
+    const full = join13(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".thumbnails" || entry.name === "renders")
         continue;
@@ -24165,7 +24292,7 @@ function updateReferences(projectDir, oldPath, newPath) {
     if (!content.includes(oldPath)) continue;
     const updated = content.split(oldPath).join(newPath);
     if (updated !== content) {
-      writeFileSync6(file, updated, "utf-8");
+      writeFileSync7(file, updated, "utf-8");
       updatedCount++;
     }
   }
@@ -24183,18 +24310,18 @@ function registerFileRoutes(api, adapter2) {
     if ("error" in res) return res.error;
     ensureDir(res.absPath);
     const body = await c2.req.text();
-    writeFileSync6(res.absPath, body, "utf-8");
+    writeFileSync7(res.absPath, body, "utf-8");
     return c2.json({ ok: true });
   });
   api.post("/projects/:id/files/*", async (c2) => {
     const res = await resolveProjectFile(c2, adapter2);
     if ("error" in res) return res.error;
-    if (existsSync9(res.absPath)) {
+    if (existsSync10(res.absPath)) {
       return c2.json({ error: "already exists" }, 409);
     }
     ensureDir(res.absPath);
     const body = await c2.req.text().catch(() => "");
-    writeFileSync6(res.absPath, body, "utf-8");
+    writeFileSync7(res.absPath, body, "utf-8");
     return c2.json({ ok: true, path: res.filePath }, 201);
   });
   api.delete("/projects/:id/files/*", async (c2) => {
@@ -24222,7 +24349,7 @@ function registerFileRoutes(api, adapter2) {
     if (!isSafePath(project.dir, absPath)) {
       return c2.json({ error: "forbidden" }, 403);
     }
-    if (!existsSync9(absPath)) {
+    if (!existsSync10(absPath)) {
       return c2.json({ error: "not found" }, 404);
     }
     const body = await c2.req.json().catch(() => null);
@@ -24234,7 +24361,7 @@ function registerFileRoutes(api, adapter2) {
     if (patchedContent === originalContent) {
       return c2.json({ ok: true, changed: false, content: originalContent });
     }
-    writeFileSync6(absPath, patchedContent, "utf-8");
+    writeFileSync7(absPath, patchedContent, "utf-8");
     return c2.json({ ok: true, changed: true, content: patchedContent });
   });
   api.patch("/projects/:id/files/*", async (c2) => {
@@ -24248,7 +24375,7 @@ function registerFileRoutes(api, adapter2) {
     if (!isSafePath(res.project.dir, newAbs)) {
       return c2.json({ error: "forbidden" }, 403);
     }
-    if (existsSync9(newAbs)) {
+    if (existsSync10(newAbs)) {
       return c2.json({ error: "already exists" }, 409);
     }
     ensureDir(newAbs);
@@ -24264,7 +24391,7 @@ function registerFileRoutes(api, adapter2) {
       return c2.json({ error: "path required" }, 400);
     }
     const srcAbs = resolve9(project.dir, body.path);
-    if (!isSafePath(project.dir, srcAbs) || !existsSync9(srcAbs)) {
+    if (!isSafePath(project.dir, srcAbs) || !existsSync10(srcAbs)) {
       return c2.json({ error: "not found" }, 404);
     }
     const copyPath = generateCopyPath(project.dir, body.path);
@@ -24273,7 +24400,7 @@ function registerFileRoutes(api, adapter2) {
       return c2.json({ error: "forbidden" }, 403);
     }
     ensureDir(destAbs);
-    writeFileSync6(destAbs, readFileSync9(srcAbs));
+    writeFileSync7(destAbs, readFileSync9(srcAbs));
     return c2.json({ ok: true, path: copyPath }, 201);
   });
   const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
@@ -24289,7 +24416,7 @@ function registerFileRoutes(api, adapter2) {
       const subDir = c2.req.query("dir") ?? "";
       const targetDir = subDir ? resolve9(project.dir, subDir) : project.dir;
       if (!isSafePath(project.dir, targetDir)) return c2.json({ error: "forbidden" }, 403);
-      if (subDir && !existsSync9(targetDir)) mkdirSync5(targetDir, { recursive: true });
+      if (subDir && !existsSync10(targetDir)) mkdirSync6(targetDir, { recursive: true });
       const formData = await c2.req.formData();
       const uploaded = [];
       const skipped = [];
@@ -24306,12 +24433,12 @@ function registerFileRoutes(api, adapter2) {
         if (!isSafePath(project.dir, destPath)) continue;
         let finalPath = destPath;
         let finalName = name;
-        if (existsSync9(finalPath)) {
+        if (existsSync10(finalPath)) {
           const dotIdx = name.indexOf(".", name.startsWith(".") ? 1 : 0);
           const ext = dotIdx > 0 ? name.slice(dotIdx) : "";
           const base = dotIdx > 0 ? name.slice(0, dotIdx) : name;
           let n = 2;
-          while (n < 1e4 && existsSync9(resolve9(targetDir, `${base} (${n})${ext}`))) n++;
+          while (n < 1e4 && existsSync10(resolve9(targetDir, `${base} (${n})${ext}`))) n++;
           if (n >= 1e4) {
             skipped.push(name);
             continue;
@@ -24325,8 +24452,13 @@ function registerFileRoutes(api, adapter2) {
           invalid.push({ name: finalName, reason: validation.reason });
           continue;
         }
-        writeFileSync6(finalPath, buffer);
-        uploaded.push(subDir ? join12(subDir, finalName) : finalName);
+        writeFileSync7(finalPath, buffer);
+        const relativePath = subDir ? join13(subDir, finalName) : finalName;
+        uploaded.push(relativePath);
+        if (isAudioFile2(finalName)) {
+          generateWaveformCache(project.dir, relativePath).catch(() => {
+          });
+        }
       }
       return c2.json({ ok: true, files: uploaded, skipped, invalid }, 201);
     }
@@ -24335,57 +24467,20 @@ function registerFileRoutes(api, adapter2) {
 var init_files = __esm({
   "../core/src/studio-api/routes/files.ts"() {
     "use strict";
+    init_mime();
+    init_waveform();
     init_mediaValidation();
     init_safePath();
     init_sourceMutation();
   }
 });
 
-// ../core/src/studio-api/helpers/mime.ts
-function getMimeType(path2) {
-  const ext = path2.slice(path2.lastIndexOf(".")).toLowerCase();
-  return MIME_TYPES[ext] || "application/octet-stream";
-}
-var MIME_TYPES;
-var init_mime2 = __esm({
-  "../core/src/studio-api/helpers/mime.ts"() {
-    "use strict";
-    MIME_TYPES = {
-      ".html": "text/html",
-      ".css": "text/css",
-      ".js": "text/javascript",
-      ".mjs": "text/javascript",
-      ".json": "application/json",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".webp": "image/webp",
-      ".ico": "image/x-icon",
-      ".mp4": "video/mp4",
-      ".mov": "video/quicktime",
-      ".webm": "video/webm",
-      ".mp3": "audio/mpeg",
-      ".wav": "audio/wav",
-      ".ogg": "audio/ogg",
-      ".m4a": "audio/mp4",
-      ".woff": "font/woff",
-      ".woff2": "font/woff2",
-      ".ttf": "font/ttf",
-      ".otf": "font/otf",
-      ".txt": "text/plain",
-      ".md": "text/markdown"
-    };
-  }
-});
-
 // ../core/src/studio-api/helpers/subComposition.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join14 } from "path";
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref) {
-  const compFile = join13(projectDir, compPath);
-  if (!existsSync10(compFile)) return null;
+  const compFile = join14(projectDir, compPath);
+  if (!existsSync11(compFile)) return null;
   const rawComp = readFileSync10(compFile, "utf-8");
   const templateMatch = rawComp.match(/<template[^>]*>([\s\S]*)<\/template>/i);
   const content = templateMatch?.[1] ?? rawComp;
@@ -24404,9 +24499,9 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref) {
     styleEl.textContent = rewriteCssAssetUrls(styleEl.textContent || "", compPath);
   }
   const rewrittenContent = contentDoc.body.innerHTML || content;
-  const indexPath = join13(projectDir, "index.html");
+  const indexPath = join14(projectDir, "index.html");
   let headContent = "";
-  if (existsSync10(indexPath)) {
+  if (existsSync11(indexPath)) {
     const indexHtml = readFileSync10(indexPath, "utf-8");
     const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     headContent = headMatch?.[1] ?? "";
@@ -24443,7 +24538,7 @@ var init_subComposition = __esm({
 });
 
 // ../core/src/studio-api/routes/preview.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
 import { resolve as resolve10 } from "path";
 function registerPreviewRoutes(api, adapter2) {
   api.get("/projects/:id/preview", async (c2) => {
@@ -24453,7 +24548,7 @@ function registerPreviewRoutes(api, adapter2) {
       let bundled = await adapter2.bundle(project.dir);
       if (!bundled) {
         const indexPath = resolve10(project.dir, "index.html");
-        if (!existsSync11(indexPath)) return c2.text("not found", 404);
+        if (!existsSync12(indexPath)) return c2.text("not found", 404);
         bundled = readFileSync11(indexPath, "utf-8");
       }
       if (!bundled.includes("hyperframe.runtime") && !bundled.includes("hyperframes-preview-runtime")) {
@@ -24469,7 +24564,7 @@ ${runtimeTag}`;
       return c2.html(bundled);
     } catch {
       const file = resolve10(project.dir, "index.html");
-      if (existsSync11(file)) return c2.html(readFileSync11(file, "utf-8"));
+      if (existsSync12(file)) return c2.html(readFileSync11(file, "utf-8"));
       return c2.text("not found", 404);
     }
   });
@@ -24480,7 +24575,7 @@ ${runtimeTag}`;
       c2.req.path.replace(`/projects/${project.id}/preview/comp/`, "").split("?")[0] ?? ""
     );
     const compFile = resolve10(project.dir, compPath);
-    if (!isSafePath(project.dir, compFile) || !existsSync11(compFile) || !statSync2(compFile).isFile()) {
+    if (!isSafePath(project.dir, compFile) || !existsSync12(compFile) || !statSync2(compFile).isFile()) {
       return c2.text("not found", 404);
     }
     const baseHref = `/api/projects/${project.id}/preview/`;
@@ -24495,7 +24590,7 @@ ${runtimeTag}`;
       c2.req.path.replace(`/projects/${project.id}/preview/`, "").split("?")[0] ?? ""
     );
     const file = resolve10(project.dir, subPath);
-    if (!isSafePath(project.dir, file) || !existsSync11(file) || !statSync2(file).isFile()) {
+    if (!isSafePath(project.dir, file) || !existsSync12(file) || !statSync2(file).isFile()) {
       return c2.text("not found", 404);
     }
     const contentType = getMimeType(subPath);
@@ -24534,14 +24629,14 @@ var init_preview = __esm({
   "../core/src/studio-api/routes/preview.ts"() {
     "use strict";
     init_safePath();
-    init_mime2();
+    init_mime();
     init_subComposition();
   }
 });
 
 // ../core/src/studio-api/routes/lint.ts
 import { readFileSync as readFileSync12 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function registerLintRoutes(api, adapter2) {
   api.get("/projects/:id/lint", async (c2) => {
     const project = await adapter2.resolveProject(c2.req.param("id"));
@@ -24550,7 +24645,7 @@ function registerLintRoutes(api, adapter2) {
       const htmlFiles = walkDir(project.dir).filter((f3) => f3.endsWith(".html"));
       const allFindings = [];
       for (const file of htmlFiles) {
-        const content = readFileSync12(join14(project.dir, file), "utf-8");
+        const content = readFileSync12(join15(project.dir, file), "utf-8");
         const result = await adapter2.lint(content, { filePath: file });
         if (result?.findings) {
           for (const f3 of result.findings) {
@@ -24574,8 +24669,8 @@ var init_lint2 = __esm({
 
 // ../core/src/studio-api/routes/render.ts
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync12, readFileSync as readFileSync13, mkdirSync as mkdirSync6, unlinkSync as unlinkSync4, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { join as join16 } from "path";
 function registerRenderRoutes(api, adapter2) {
   const renderJobs = /* @__PURE__ */ new Map();
   const TTL_MS = 3e5;
@@ -24612,9 +24707,9 @@ function registerRenderRoutes(api, adapter2) {
     const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
     const jobId = `${project.id}_${datePart}_${timePart}`;
     const rendersDir = adapter2.rendersDir(project);
-    if (!existsSync12(rendersDir)) mkdirSync6(rendersDir, { recursive: true });
+    if (!existsSync13(rendersDir)) mkdirSync7(rendersDir, { recursive: true });
     const ext = FORMAT_EXT2[format] ?? ".mp4";
-    const outputPath = join15(rendersDir, `${jobId}${ext}`);
+    const outputPath = join16(rendersDir, `${jobId}${ext}`);
     const jobState = adapter2.startRender({
       project,
       outputPath,
@@ -24679,7 +24774,7 @@ function registerRenderRoutes(api, adapter2) {
   api.get("/render/:jobId/view", (c2) => {
     const { jobId } = c2.req.param();
     const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync12(job.outputPath)) {
+    if (!job?.outputPath || !existsSync13(job.outputPath)) {
       return c2.json({ error: "not found" }, 404);
     }
     const contentType = renderContentType(job.outputPath);
@@ -24697,7 +24792,7 @@ function registerRenderRoutes(api, adapter2) {
   api.get("/render/:jobId/download", (c2) => {
     const { jobId } = c2.req.param();
     const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync12(job.outputPath)) {
+    if (!job?.outputPath || !existsSync13(job.outputPath)) {
       return c2.json({ error: "not found" }, 404);
     }
     const contentType = renderContentType(job.outputPath);
@@ -24716,8 +24811,8 @@ function registerRenderRoutes(api, adapter2) {
       if (state.id === jobId && state.outputPath) {
         const dir = state.outputPath.replace(/\/[^/]+$/, "");
         for (const ext of [".mp4", ".webm", ".mov", ".meta.json"]) {
-          const fp = join15(dir, `${jobId}${ext}`);
-          if (existsSync12(fp)) unlinkSync4(fp);
+          const fp = join16(dir, `${jobId}${ext}`);
+          if (existsSync13(fp)) unlinkSync4(fp);
         }
         break;
       }
@@ -24731,8 +24826,8 @@ function registerRenderRoutes(api, adapter2) {
     const filename = c2.req.path.split("/renders/file/")[1];
     if (!filename) return c2.json({ error: "missing filename" }, 400);
     const rendersDir = adapter2.rendersDir(project);
-    const fp = join15(rendersDir, filename);
-    if (!existsSync12(fp)) return c2.json({ error: "not found" }, 404);
+    const fp = join16(rendersDir, filename);
+    if (!existsSync13(fp)) return c2.json({ error: "not found" }, 404);
     const contentType = renderContentType(fp);
     const content = readFileSync13(fp);
     return new Response(content, {
@@ -24748,15 +24843,15 @@ function registerRenderRoutes(api, adapter2) {
     const project = await adapter2.resolveProject(c2.req.param("id"));
     if (!project) return c2.json({ error: "not found" }, 404);
     const rendersDir = adapter2.rendersDir(project);
-    if (!existsSync12(rendersDir)) return c2.json({ renders: [] });
+    if (!existsSync13(rendersDir)) return c2.json({ renders: [] });
     const files = readdirSync5(rendersDir).filter((f3) => f3.endsWith(".mp4") || f3.endsWith(".webm") || f3.endsWith(".mov")).map((f3) => {
-      const fp = join15(rendersDir, f3);
+      const fp = join16(rendersDir, f3);
       const stat3 = statSync3(fp);
       const rid = f3.replace(/\.(mp4|webm|mov)$/, "");
-      const metaPath = join15(rendersDir, `${rid}.meta.json`);
+      const metaPath = join16(rendersDir, `${rid}.meta.json`);
       let status = "complete";
       let durationMs;
-      if (existsSync12(metaPath)) {
+      if (existsSync13(metaPath)) {
         try {
           const meta = JSON.parse(readFileSync13(metaPath, "utf-8"));
           if (meta.status === "failed") status = "failed";
@@ -24779,7 +24874,7 @@ function registerRenderRoutes(api, adapter2) {
           id: file.id,
           status: file.status,
           progress: 100,
-          outputPath: join15(rendersDir, file.filename),
+          outputPath: join16(rendersDir, file.filename),
           createdAt: file.createdAt
         });
       }
@@ -24794,8 +24889,8 @@ 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 { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join17 } from "path";
 function registerThumbnailRoutes(api, adapter2) {
   api.get("/projects/:id/thumbnail/*", async (c2) => {
     if (!adapter2.generateThumbnail) {
@@ -24815,8 +24910,8 @@ function registerThumbnailRoutes(api, adapter2) {
     let compW = vpWidth || 1920;
     let compH = vpHeight || 1080;
     if (!vpWidth) {
-      const htmlFile = join16(project.dir, compPath);
-      if (existsSync13(htmlFile)) {
+      const htmlFile = join17(project.dir, compPath);
+      if (existsSync14(htmlFile)) {
         const html = readFileSync14(htmlFile, "utf-8");
         const wMatch = html.match(/data-width=["'](\d+)["']/);
         const hMatch = html.match(/data-height=["'](\d+)["']/);
@@ -24825,11 +24920,11 @@ 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 cacheDir = join17(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 cachePath2 = join16(cacheDir, cacheKey);
-    if (existsSync13(cachePath2)) {
+    const cachePath2 = join17(cacheDir, cacheKey);
+    if (existsSync14(cachePath2)) {
       return new Response(new Uint8Array(readFileSync14(cachePath2)), {
         headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
       });
@@ -24847,8 +24942,8 @@ function registerThumbnailRoutes(api, adapter2) {
       if (!buffer) {
         return c2.json({ error: "Thumbnail generation returned null" }, 500);
       }
-      if (!existsSync13(cacheDir)) mkdirSync7(cacheDir, { recursive: true });
-      writeFileSync7(cachePath2, buffer);
+      if (!existsSync14(cacheDir)) mkdirSync8(cacheDir, { recursive: true });
+      writeFileSync8(cachePath2, buffer);
       return new Response(new Uint8Array(buffer), {
         headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
       });
@@ -24866,6 +24961,50 @@ var init_thumbnail = __esm({
   }
 });
 
+// ../core/src/studio-api/routes/waveform.ts
+import { existsSync as existsSync15, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
+import { join as join18 } from "path";
+function registerWaveformRoutes(api, adapter2) {
+  api.get("/projects/:id/waveform/*", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const assetPath = decodeURIComponent(
+      c2.req.path.replace(`/projects/${project.id}/waveform/`, "").split("?")[0] ?? ""
+    );
+    const audioPath = join18(project.dir, assetPath);
+    if (!existsSync15(audioPath)) return c2.json({ error: "file not found" }, 404);
+    const cacheDir = join18(project.dir, ".waveform-cache");
+    const cachePath2 = join18(cacheDir, buildWaveformCacheKey(assetPath));
+    if (existsSync15(cachePath2)) {
+      try {
+        const peaks2 = JSON.parse(readFileSync15(cachePath2, "utf-8"));
+        return c2.json({ peaks: peaks2 });
+      } catch {
+      }
+    }
+    let peaks;
+    try {
+      peaks = await decodeAudioPeaks(audioPath);
+    } catch {
+      return c2.json({ error: "failed to decode audio" }, 500);
+    }
+    try {
+      mkdirSync9(cacheDir, { recursive: true });
+      writeFileSync9(cachePath2, JSON.stringify(peaks));
+    } catch {
+    }
+    return c2.json({ peaks });
+  });
+}
+var init_waveform2 = __esm({
+  "../core/src/studio-api/routes/waveform.ts"() {
+    "use strict";
+    init_waveform();
+    init_mime();
+    init_waveform();
+  }
+});
+
 // ../core/src/studio-api/createStudioApi.ts
 import { Hono } from "hono";
 function createStudioApi(adapter2) {
@@ -24876,6 +25015,7 @@ function createStudioApi(adapter2) {
   registerLintRoutes(api, adapter2);
   registerRenderRoutes(api, adapter2);
   registerThumbnailRoutes(api, adapter2);
+  registerWaveformRoutes(api, adapter2);
   return api;
 }
 var init_createStudioApi = __esm({
@@ -24887,6 +25027,7 @@ var init_createStudioApi = __esm({
     init_lint2();
     init_render();
     init_thumbnail();
+    init_waveform2();
   }
 });
 
@@ -24905,7 +25046,7 @@ var init_studio_api = __esm({
     "use strict";
     init_createStudioApi();
     init_safePath();
-    init_mime2();
+    init_mime();
     init_subComposition();
   }
 });
@@ -24921,9 +25062,9 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync14, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync16, rmSync as rmSync4 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 import { Browser, detectBrowserPlatform, getInstalledBrowsers, install } from "@puppeteer/browsers";
 function setBrowserPath(path2) {
   _browserPathOverride = path2;
@@ -24943,17 +25084,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync14(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync16(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync14(envPath)) {
+  if (envPath && existsSync16(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync14(CACHE_DIR2)) {
+  if (!existsSync16(CACHE_DIR2)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR2 });
@@ -24965,7 +25106,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync14(p)) {
+    if (existsSync16(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -24999,7 +25140,7 @@ async function ensureBrowser(options) {
   return { executablePath: installed.executablePath, source: "download" };
 }
 function clearBrowser() {
-  if (!existsSync14(CACHE_DIR2)) {
+  if (!existsSync16(CACHE_DIR2)) {
     return false;
   }
   rmSync4(CACHE_DIR2, { recursive: true, force: true });
@@ -25010,7 +25151,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 = join19(homedir4(), ".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",
@@ -25137,8 +25278,8 @@ 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 { existsSync as existsSync17, readdirSync as readdirSync6 } from "fs";
+import { join as join20 } from "path";
 import { homedir as homedir5 } from "os";
 async function getPuppeteer() {
   if (_puppeteer) return _puppeteer;
@@ -25159,19 +25300,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 = join20(homedir5(), ".cache", "puppeteer", "chrome-headless-shell");
+  if (!existsSync17(baseDir)) return void 0;
   try {
     const versions = readdirSync6(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")
+        join20(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
+        join20(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
+        join20(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
+        join20(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
       ];
       for (const binary of candidates) {
-        if (existsSync15(binary)) return binary;
+        if (existsSync17(binary)) return binary;
       }
     }
   } catch {
@@ -25634,10 +25775,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 existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { join as join21 } from "path";
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync16(outputDir)) mkdirSync8(outputDir, { recursive: true });
+  if (!existsSync18(outputDir)) mkdirSync10(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -25841,13 +25982,13 @@ 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 = join21(session.outputDir, "diagnostics");
+    if (!existsSync18(diagnosticsDir)) mkdirSync10(diagnosticsDir, { recursive: true });
+    const base = join21(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");
-    writeFileSync8(
+    writeFileSync10(`${base}.html`, html, "utf-8");
+    writeFileSync10(
       `${base}.json`,
       JSON.stringify(
         {
@@ -25941,8 +26082,8 @@ 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);
-  writeFileSync8(framePath, buffer);
+  const framePath = join21(outputDir, frameName);
+  writeFileSync10(framePath, buffer);
   return { frameIndex, time: quantizedTime, path: framePath, captureTimeMs };
 }
 async function captureFrameToBuffer(session, frameIndex, time) {
@@ -25962,8 +26103,8 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync16(outputDir)) {
-    mkdirSync8(outputDir, { recursive: true });
+  if (!existsSync18(outputDir)) {
+    mkdirSync10(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
   session.onBeforeCapture = onBeforeCapture;
@@ -26006,10 +26147,10 @@ var init_frameCapture = __esm({
 });
 
 // ../engine/src/utils/gpuEncoder.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 async function detectGpuEncoder() {
   return new Promise((resolve39) => {
-    const ffmpeg = spawn2("ffmpeg", ["-encoders"], {
+    const ffmpeg = spawn3("ffmpeg", ["-encoders"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout2 = "";
@@ -26129,7 +26270,7 @@ var init_hdr = __esm({
 });
 
 // ../engine/src/utils/runFfmpeg.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function formatFfmpegError(exitCode, stderr, tailLines = DEFAULT_STDERR_TAIL_LINES) {
   const tail = (stderr ?? "").split(/\r?\n/).filter((line) => line.length > 0).slice(-tailLines).join("\n");
   if (exitCode === null) {
@@ -26145,7 +26286,7 @@ async function runFfmpeg(args, opts) {
   const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
   const onStderr = opts?.onStderr;
   return new Promise((resolve39) => {
-    const ffmpeg = spawn3("ffmpeg", args);
+    const ffmpeg = spawn4("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
       ffmpeg.kill("SIGTERM");
@@ -26199,9 +26340,9 @@ 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 { spawn as spawn5 } from "child_process";
+import { copyFileSync, existsSync as existsSync19, mkdirSync as mkdirSync11, readdirSync as readdirSync7, statSync as statSync4, writeFileSync as writeFileSync11 } from "fs";
+import { join as join22, dirname as dirname6 } from "path";
 function getEncoderPreset(quality, format = "mp4", hdr) {
   const base = ENCODER_PRESETS[quality];
   if (format === "webm") {
@@ -26352,7 +26493,7 @@ 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 });
+  if (!existsSync19(outputDir)) mkdirSync11(outputDir, { recursive: true });
   const files = readdirSync7(framesDir).filter((f3) => f3.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
@@ -26369,11 +26510,11 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
-  const inputPath = join20(framesDir, framePattern);
+  const inputPath = join22(framesDir, framePattern);
   const inputArgs = ["-framerate", String(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   return new Promise((resolve39) => {
-    const ffmpeg = spawn4("ffmpeg", args);
+    const ffmpeg = spawn5("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
       ffmpeg.kill("SIGTERM");
@@ -26418,7 +26559,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync17(outputPath) ? statSync4(outputPath).size : 0;
+      const fileSize = existsSync19(outputPath) ? statSync4(outputPath).size : 0;
       resolve39({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
@@ -26450,8 +26591,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 = join22(dirname6(outputPath), "chunk-encode");
+  if (!existsSync19(chunkDir)) mkdirSync11(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i2 = 0; i2 < chunkCount; i2++) {
     if (signal?.aborted) {
@@ -26467,8 +26608,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 = join22(chunkDir, `chunk_${String(i2).padStart(4, "0")}${ext}`);
+    const inputPath = join22(framesDir, framePattern);
     const inputArgs = [
       "-framerate",
       String(options.fps),
@@ -26483,7 +26624,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
     const chunkResult = await new Promise((resolve39) => {
-      const ffmpeg = spawn4("ffmpeg", args);
+      const ffmpeg = spawn5("ffmpeg", args);
       let stderr = "";
       ffmpeg.stderr.on("data", (d) => {
         stderr += d.toString();
@@ -26508,9 +26649,9 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     }
     chunkPaths.push(chunkPath);
   }
-  const concatListPath = join20(chunkDir, "concat-list.txt");
+  const concatListPath = join22(chunkDir, "concat-list.txt");
   const concatInput = chunkPaths.map((path2) => `file '${path2.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync9(concatListPath, concatInput, "utf-8");
+  writeFileSync11(concatListPath, concatInput, "utf-8");
   const concatArgs = [
     "-f",
     "concat",
@@ -26524,7 +26665,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     outputPath
   ];
   const concatResult = await new Promise((resolve39) => {
-    const ffmpeg = spawn4("ffmpeg", concatArgs);
+    const ffmpeg = spawn5("ffmpeg", concatArgs);
     let stderr = "";
     ffmpeg.stderr.on("data", (d) => {
       stderr += d.toString();
@@ -26547,7 +26688,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync17(outputPath) ? statSync4(outputPath).size : 0;
+  const fileSize = existsSync19(outputPath) ? statSync4(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -26558,7 +26699,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 (!existsSync19(outputDir)) mkdirSync11(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
@@ -26628,8 +26769,8 @@ 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 { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, statSync as statSync5 } from "fs";
 import { dirname as dirname7 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
@@ -26812,14 +26953,14 @@ 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 (!existsSync20(outputDir)) mkdirSync12(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
   const args = buildStreamingArgs(options, outputPath, gpuEncoder);
   const startTime = Date.now();
-  const ffmpeg = spawn5("ffmpeg", args, {
+  const ffmpeg = spawn6("ffmpeg", args, {
     stdio: ["pipe", "pipe", "pipe"]
   });
   let exitStatus = "running";
@@ -26894,7 +27035,7 @@ Process error: ${err.message}`;
           error: formatFfmpegError(exitCode, stderr)
         };
       }
-      const fileSize = existsSync18(outputPath) ? statSync5(outputPath).size : 0;
+      const fileSize = existsSync20(outputPath) ? statSync5(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -26912,12 +27053,12 @@ var init_streamingEncoder = __esm({
 });
 
 // ../engine/src/utils/ffprobe.ts
-import { spawn as spawn6 } from "child_process";
-import { readFileSync as readFileSync15 } from "fs";
+import { spawn as spawn7 } from "child_process";
+import { readFileSync as readFileSync16 } from "fs";
 import { extname as extname4 } from "path";
 function runFfprobe(args) {
   return new Promise((resolve39, reject) => {
-    const proc = spawn6("ffprobe", args);
+    const proc = spawn7("ffprobe", args);
     let stdout2 = "";
     let stderr = "";
     proc.stdout.on("data", (data) => {
@@ -27007,7 +27148,7 @@ function extractPngMetadataFromBuffer(buf) {
 function extractStillImageMetadata(filePath) {
   if (extname4(filePath).toLowerCase() !== ".png") return null;
   try {
-    return extractPngMetadataFromBuffer(readFileSync15(filePath));
+    return extractPngMetadataFromBuffer(readFileSync16(filePath));
   } catch {
     return null;
   }
@@ -27186,9 +27327,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 existsSync21, mkdirSync as mkdirSync13 } from "fs";
 import { createHash } from "crypto";
-import { join as join21, extname as extname5 } from "path";
+import { join as join23, extname as extname5 } from "path";
 import { Readable } from "stream";
 import { finished } from "stream/promises";
 function getFilenameFromUrl(url) {
@@ -27199,19 +27340,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync19(cachedPath)) {
+  if (cachedPath && existsSync21(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync19(destDir)) {
-    mkdirSync11(destDir, { recursive: true });
+  if (!existsSync21(destDir)) {
+    mkdirSync13(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join21(destDir, filename);
-  if (existsSync19(localPath)) {
+  const localPath = join23(destDir, filename);
+  if (existsSync21(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -27303,9 +27444,9 @@ 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 mkdirSync14, readdirSync as readdirSync8, statSync as statSync6, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync22 } from "fs";
+import { join as join24 } from "path";
 function readKeyStat(videoPath) {
   try {
     const stat3 = statSync6(videoPath);
@@ -27334,15 +27475,15 @@ 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 = join24(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync22(join24(dir, COMPLETE_SENTINEL));
   return { entry: { dir, keyHash }, hit: complete };
 }
 function ensureCacheEntryDir(entry) {
-  mkdirSync12(entry.dir, { recursive: true });
+  mkdirSync14(entry.dir, { recursive: true });
 }
 function markCacheEntryComplete(entry) {
-  writeFileSync10(join22(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
+  writeFileSync12(join24(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
 }
 function rehydrateCacheEntry(entry, options) {
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${options.format}`;
@@ -27350,7 +27491,7 @@ function rehydrateCacheEntry(entry, options) {
   const suffix = `.${options.format}`;
   const files = readdirSync8(entry.dir).filter((f3) => f3.startsWith(FRAME_FILENAME_PREFIX) && f3.endsWith(suffix)).sort();
   files.forEach((file, idx) => {
-    framePaths.set(idx, join22(entry.dir, file));
+    framePaths.set(idx, join24(entry.dir, file));
   });
   return {
     videoId: options.videoId,
@@ -27375,9 +27516,9 @@ 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 { spawn as spawn8 } from "child_process";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readdirSync as readdirSync9, rmSync as rmSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join25 } from "path";
 function parseVideoElements(html) {
   const videos = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -27447,12 +27588,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 ?? join25(outputDir, videoId);
+  if (!existsSync23(videoOutputDir)) mkdirSync15(videoOutputDir, { recursive: true });
   const metadata = await extractMediaMetadata(videoPath);
   const format = resolveFrameFormat(metadata, options.format);
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
-  const outputPattern = join23(videoOutputDir, framePattern);
+  const outputPattern = join25(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -27473,7 +27614,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (format === "png") args.push("-compression_level", "6");
   args.push("-y", outputPattern);
   return new Promise((resolve39, reject) => {
-    const ffmpeg = spawn7("ffmpeg", args);
+    const ffmpeg = spawn8("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
       ffmpeg.kill("SIGTERM");
@@ -27505,7 +27646,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       const framePaths = /* @__PURE__ */ new Map();
       const files = readdirSync9(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, join25(videoOutputDir, file));
       });
       resolve39({
         videoId,
@@ -27632,15 +27773,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 ? join25(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync23(fromCompiled) ? fromCompiled : join25(baseDir, videoPath);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join23(options.outputDir, "_downloads");
-        mkdirSync13(downloadDir, { recursive: true });
+        const downloadDir = join25(options.outputDir, "_downloads");
+        mkdirSync15(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(videoPath, downloadDir);
       }
-      if (!existsSync21(videoPath)) {
+      if (!existsSync23(videoPath)) {
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }
@@ -27673,8 +27814,8 @@ 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");
-    mkdirSync13(convertDir, { recursive: true });
+    const convertDir = join25(options.outputDir, "_hdr_normalized");
+    mkdirSync15(convertDir, { recursive: true });
     for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
       if (signal?.aborted) break;
       const cs = videoColorSpaces[i2] ?? null;
@@ -27695,7 +27836,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 = join25(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
           await convertSdrToHdr(
             entry.videoPath,
@@ -27730,7 +27871,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
   }
   const vfrPreflightStart = Date.now();
-  const vfrNormDir = join23(options.outputDir, "_vfr_normalized");
+  const vfrNormDir = join25(options.outputDir, "_vfr_normalized");
   for (let i2 = 0; i2 < resolvedVideos.length; i2++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i2];
@@ -27744,8 +27885,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
-    mkdirSync13(vfrNormDir, { recursive: true });
-    const normalizedPath = join23(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    mkdirSync15(vfrNormDir, { recursive: true });
+    const normalizedPath = join25(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
         entry.videoPath,
@@ -28001,7 +28142,7 @@ var init_videoFrameExtractor = __esm({
       cleanup() {
         for (const video of this.videos.values()) {
           if (video.extracted.ownedByLookup) continue;
-          if (existsSync21(video.extracted.outputDir)) {
+          if (existsSync23(video.extracted.outputDir)) {
             rmSync5(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -28309,8 +28450,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 existsSync24, mkdirSync as mkdirSync16, rmSync as rmSync6 } from "fs";
+import { isAbsolute as isAbsolute3, join as join26, dirname as dirname8 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -28361,7 +28502,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 (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = ["-i", videoPath];
   if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
   if (options?.duration !== void 0) args.push("-t", String(options.duration));
@@ -28388,7 +28529,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 (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -28424,7 +28565,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 (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -28467,7 +28608,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     };
   }
   const outputDir = dirname8(outputPath);
-  if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  if (!existsSync24(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i2) => {
@@ -28528,7 +28669,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 (!existsSync24(workDir)) mkdirSync16(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -28538,8 +28679,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 ? join26(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync24(fromCompiled) ? fromCompiled : join26(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -28551,7 +28692,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync22(srcPath)) {
+        if (!existsSync24(srcPath)) {
           errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
@@ -28562,7 +28703,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 = join26(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -28579,7 +28720,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join24(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join26(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -28633,9 +28774,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 existsSync25, mkdirSync as mkdirSync17, readdirSync as readdirSync10 } from "fs";
 import { copyFile, rename } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
   const effectiveMaxWorkers = (() => {
     const concurrency = config?.concurrency ?? DEFAULT_CONFIG2.concurrency;
@@ -28678,7 +28819,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i2,
       startFrame,
       endFrame,
-      outputDir: join25(workDir, `worker-${i2}`)
+      outputDir: join27(workDir, `worker-${i2}`)
     });
   }
   return tasks;
@@ -28686,7 +28827,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 (!existsSync25(task.outputDir)) mkdirSync17(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -28776,17 +28917,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync23(outputDir)) mkdirSync15(outputDir, { recursive: true });
+  if (!existsSync25(outputDir)) mkdirSync17(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 (!existsSync25(task.outputDir)) {
       continue;
     }
     const files = readdirSync10(task.outputDir).filter((f3) => f3.startsWith("frame_") && (f3.endsWith(".jpg") || f3.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join25(task.outputDir, file);
-      const targetPath = join25(outputDir, file);
+      const sourcePath = join27(task.outputDir, file);
+      const targetPath = join27(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -28823,8 +28964,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 readFileSync17, existsSync as existsSync26, statSync as statSync7 } from "fs";
+import { join as join28, extname as extname6 } from "path";
 function stripEmbeddedRuntimeScripts(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -28893,22 +29034,22 @@ 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 ? join28(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync24(compiledPath) && statSync7(compiledPath).isFile()
+      compiledPath && existsSync26(compiledPath) && statSync7(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join26(projectDir, relativePath);
-    if (!existsSync24(filePath) || !statSync7(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join28(projectDir, relativePath);
+    if (!existsSync26(filePath) || !statSync7(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname6(filePath).toLowerCase();
     const contentType = MIME_TYPES2[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync16(filePath, "utf-8");
+      const rawHtml = readFileSync17(filePath, "utf-8");
       const html = relativePath === "index.html" ? injectScriptsIntoHtml(rawHtml, headScripts, bodyScripts, stripEmbeddedRuntime) : rawHtml;
       return c2.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync16(filePath);
+    const content = readFileSync17(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -30176,8 +30317,8 @@ 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 { existsSync as existsSync27, readdirSync as readdirSync11 } from "fs";
+import { join as join29 } from "path";
 import { homedir as homedir6 } from "os";
 function linearToPQ(L2) {
   const Lp = Math.max(0, L2 * SDR_NITS / PQ_MAX_NITS);
@@ -30293,12 +30434,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 baseDir = join29(homedir6(), ".cache", "puppeteer", "chrome");
+  if (!existsSync27(baseDir)) return void 0;
   const versions = readdirSync11(baseDir).sort().reverse();
   for (const version of versions) {
     const candidates = [
-      join27(
+      join29(
         baseDir,
         version,
         "chrome-mac-arm64",
@@ -30307,7 +30448,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join27(
+      join29(
         baseDir,
         version,
         "chrome-mac-x64",
@@ -30316,11 +30457,11 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join27(baseDir, version, "chrome-linux64", "chrome"),
-      join27(baseDir, version, "chrome-win64", "chrome.exe")
+      join29(baseDir, version, "chrome-linux64", "chrome"),
+      join29(baseDir, version, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
-      if (existsSync25(binary)) return binary;
+      if (existsSync27(binary)) return binary;
     }
   }
   return void 0;
@@ -30592,8 +30733,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 readFileSync18, existsSync as existsSync28 } from "fs";
+import { join as join30, resolve as resolve12, isAbsolute as isAbsolute4, sep as sep2 } from "path";
 import { transformSync } from "esbuild";
 function parseHTMLContent2(html) {
   const trimmed = html.trimStart().toLowerCase();
@@ -30661,17 +30802,17 @@ 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 (!existsSync28(filePath)) return null;
   try {
-    return readFileSync17(filePath, "utf-8");
+    return readFileSync18(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync26(filePath)) return null;
+  if (!existsSync28(filePath)) return null;
   try {
-    return readFileSync17(filePath);
+    return readFileSync18(filePath);
   } catch {
     return null;
   }
@@ -30862,9 +31003,9 @@ 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 rawHtml = readFileSync17(indexPath, "utf-8");
+  const indexPath = join30(projectDir, "index.html");
+  if (!existsSync28(indexPath)) throw new Error("index.html not found in project directory");
+  const rawHtml = readFileSync18(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
   if (!staticGuard.isValid) {
@@ -31139,7 +31280,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 existsSync29, readFileSync as readFileSync19 } from "fs";
 import { dirname as dirname9, resolve as resolve13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -31152,7 +31293,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync27(candidate)) {
+    if (existsSync29(candidate)) {
       return candidate;
     }
   }
@@ -31163,12 +31304,12 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync27(manifestPath)) {
+  if (!existsSync29(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync18(manifestPath, "utf8");
+  const manifestRaw = readFileSync19(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -31177,10 +31318,10 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve13(dirname9(manifestPath), runtimeFileName);
-  if (!existsSync27(runtimePath)) {
+  if (!existsSync29(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync18(runtimePath, "utf8");
+  const runtimeSource = readFileSync19(runtimePath, "utf8");
   const runtimeSha = createHash3("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -31219,16 +31360,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 readFileSync20, existsSync as existsSync30, realpathSync, statSync as statSync8 } from "fs";
+import { join as join31, 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 && existsSync30(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync30(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -31317,14 +31458,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 = join31(compiledDir, relativePath);
+      if (existsSync30(candidate) && isPathInside(candidate, compiledDir) && statSync8(candidate).isFile()) {
         filePath = candidate;
       }
     }
     if (!filePath) {
-      const candidate = join29(projectDir, relativePath);
-      if (existsSync28(candidate) && isPathInside(candidate, projectDir) && statSync8(candidate).isFile()) {
+      const candidate = join31(projectDir, relativePath);
+      if (existsSync30(candidate) && isPathInside(candidate, projectDir) && statSync8(candidate).isFile()) {
         filePath = candidate;
       }
     }
@@ -31337,7 +31478,7 @@ function createFileServer2(options) {
     const ext = extname7(filePath).toLowerCase();
     const contentType = MIME_TYPES3[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync19(filePath, "utf-8");
+      const rawHtml = readFileSync20(filePath, "utf-8");
       const isIndex = relativePath === "index.html";
       let html = rawHtml;
       if (preHeadScripts.length > 0) {
@@ -31346,7 +31487,7 @@ function createFileServer2(options) {
       html = isIndex ? injectScriptsIntoHtml2(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
       return c2.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync19(filePath);
+    const content = readFileSync20(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -31698,7 +31839,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 join32, relative as relative2, isAbsolute as isAbsolute5 } from "path";
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve15(childPath);
   const absParent = resolve15(parentPath);
@@ -31719,7 +31860,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 ?? join32(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve15(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -31792,9 +31933,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 { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join31 } from "path";
+import { join as join33 } from "path";
 function normalizeFamilyName(family) {
   return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
 }
@@ -31905,14 +32046,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)) {
-    mkdirSync16(dir, { recursive: true });
+  const dir = join33(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync31(dir)) {
+    mkdirSync18(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join31(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join33(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -31938,17 +32079,17 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match[3] || "";
     if (!woff2Url) continue;
     const cachePath2 = cachedWoff2Path(slug, weight, style);
-    if (!existsSync29(cachePath2)) {
+    if (!existsSync31(cachePath2)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
         const buffer = Buffer.from(await fontRes.arrayBuffer());
-        writeFileSync11(cachePath2, buffer);
+        writeFileSync13(cachePath2, buffer);
       } catch {
         continue;
       }
     }
-    const fontBytes = readFileSync20(cachePath2);
+    const fontBytes = readFileSync21(cachePath2);
     const dataUri = `data:font/woff2;base64,${fontBytes.toString("base64")}`;
     faces.push({ weight, style, dataUri });
   }
@@ -32124,14 +32265,14 @@ var init_deterministicFonts = __esm({
       poppins: "poppins",
       "segoe ui": "roboto"
     };
-    GOOGLE_FONTS_CACHE_DIR = join31(homedir7(), ".cache", "hyperframes", "fonts");
+    GOOGLE_FONTS_CACHE_DIR = join33(homedir7(), ".cache", "hyperframes", "fonts");
     WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
   }
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync21, existsSync as existsSync30, mkdirSync as mkdirSync17 } from "fs";
-import { join as join32, dirname as dirname10, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync32, mkdirSync as mkdirSync19 } from "fs";
+import { join as join34, dirname as dirname10, resolve as resolve16 } from "path";
 import postcss from "postcss";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -32182,16 +32323,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 (!existsSync32(downloadDir)) mkdirSync19(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join32(baseDir, filePath);
+    filePath = join34(baseDir, filePath);
   }
-  if (!existsSync30(filePath)) {
+  if (!existsSync32(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractMediaMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -32260,10 +32401,10 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync30(filePath)) {
+    if (!existsSync32(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync21(filePath, "utf-8");
+    const rawSubHtml = readFileSync22(filePath, "utf-8");
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, absoluteStart, absoluteEnd, filePath, rawSubHtml, nestedVisited });
@@ -32470,8 +32611,8 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve16(projectDir, srcPath);
-      if (existsSync30(filePath)) {
-        compHtml = readFileSync21(filePath, "utf-8");
+      if (existsSync32(filePath)) {
+        compHtml = readFileSync22(filePath, "utf-8");
       }
     }
     if (!compHtml) {
@@ -32698,7 +32839,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync30(absPath)) return null;
+    if (!existsSync32(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -32743,7 +32884,7 @@ function collectExternalAssets(html, projectDir) {
   };
 }
 async function compileForRender(projectDir, htmlPath, downloadDir) {
-  const rawHtml = readFileSync21(htmlPath, "utf-8");
+  const rawHtml = readFileSync22(htmlPath, "utf-8");
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
@@ -33083,17 +33224,17 @@ var init_hdrImageTransferCache = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync20,
   rmSync as rmSync7,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   readdirSync as readdirSync13,
   statSync as statSync9,
-  writeFileSync as writeFileSync12,
+  writeFileSync as writeFileSync14,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join33, dirname as dirname11, resolve as resolve17 } from "path";
+import { join as join35, 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";
@@ -33119,7 +33260,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries2) {
-      const full = join33(current, name);
+      const full = join35(current, name);
       try {
         const st2 = statSync9(full);
         if (st2.isDirectory()) {
@@ -33194,21 +33335,21 @@ function installDebugLogger(logPath, log2 = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join33(workDir, "compiled");
-  mkdirSync18(compileDir, { recursive: true });
-  writeFileSync12(join33(compileDir, "index.html"), compiled.html, "utf-8");
+  const compileDir = join35(workDir, "compiled");
+  mkdirSync20(compileDir, { recursive: true });
+  writeFileSync14(join35(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join33(compileDir, srcPath);
-    mkdirSync18(dirname11(outPath), { recursive: true });
-    writeFileSync12(outPath, html, "utf-8");
+    const outPath = join35(compileDir, srcPath);
+    mkdirSync20(dirname11(outPath), { recursive: true });
+    writeFileSync14(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve17(join33(compileDir, relativePath));
+    const outPath = resolve17(join35(compileDir, relativePath));
     if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync18(dirname11(outPath), { recursive: true });
+    mkdirSync20(dirname11(outPath), { recursive: true });
     copyFileSync2(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -33233,7 +33374,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");
+    writeFileSync14(join35(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(cfg, compiled, log2 = defaultLogger) {
@@ -33254,12 +33395,12 @@ 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 = join35(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
+  if (!existsSync33(framePath)) {
     return;
   }
   try {
-    const { data: hdrRgb, width: srcW, height: srcH } = decodePngToRgb48le(readFileSync22(framePath));
+    const { data: hdrRgb, width: srcW, height: srcH } = decodePngToRgb48le(readFileSync23(framePath));
     if (sourceTransfer && targetTransfer && sourceTransfer !== targetTransfer) {
       convertTransfer(hdrRgb, sourceTransfer, targetTransfer);
     }
@@ -33438,7 +33579,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 ? join35(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
           log2.info("[diag] hdr layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -33450,7 +33591,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
             localTime: localTime.toFixed(3),
             hdrFrameNum: frameNum,
             expectedFrame,
-            expectedFrameExists: expectedFrame ? existsSync31(expectedFrame) : false
+            expectedFrameExists: expectedFrame ? existsSync33(expectedFrame) : false
           });
         }
       }
@@ -33475,8 +33616,8 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
         if (shouldLog && debugDumpDir) {
           const after2 = countNonZeroRgb48(canvas);
           const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-          const dumpPath = join33(debugDumpDir, dumpName);
-          writeFileSync12(dumpPath, domPng);
+          const dumpPath = join35(debugDumpDir, dumpName);
+          writeFileSync14(dumpPath, domPng);
           log2.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -33549,8 +33690,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 = join35(producerRoot, ".debug");
+  const workDir = job.config.debug ? join35(debugDir, job.id) : join35(dirname11(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log2 = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -33562,7 +33703,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     videoExtractionFailures: 0,
     imageDecodeFailures: 0
   };
-  const perfOutputPath = join33(workDir, "perf-summary.json");
+  const perfOutputPath = join35(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -33595,28 +33736,28 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync31(workDir)) mkdirSync18(workDir, { recursive: true });
+    if (!existsSync33(workDir)) mkdirSync20(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join33(workDir, "render.log");
+      const logPath = join35(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log2);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join33(projectDir, entryFile);
-    if (!existsSync31(htmlPath)) {
+    let htmlPath = join35(projectDir, entryFile);
+    if (!existsSync33(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync22(htmlPath, "utf-8");
+    const rawEntry = readFileSync23(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 = join35(workDir, "standalone-entry.html");
+      const projectIndexPath = join35(projectDir, "index.html");
+      if (!existsSync33(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync22(projectIndexPath, "utf-8"),
+        readFileSync23(projectIndexPath, "utf-8"),
         entryFile
       );
       if (!standaloneHtml) {
@@ -33624,7 +33765,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync12(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync14(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log2.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -33633,7 +33774,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, join35(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     applyRenderModeHints(cfg, compiled, log2);
@@ -33665,7 +33806,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: join35(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
@@ -33679,7 +33820,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join33(workDir, "probe"),
+        join35(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -33711,7 +33852,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join33(workDir, "downloads")
+            join35(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -33865,7 +34006,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 = join35(workDir, "compiled");
     let extractionResult = null;
     const nativeHdrVideoIds = /* @__PURE__ */ new Set();
     const videoTransfers = /* @__PURE__ */ new Map();
@@ -33874,10 +34015,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 = existsSync33(join35(compiledDir, videoPath)) ? join35(compiledDir, videoPath) : join35(projectDir, videoPath);
             videoPath = fromCompiled;
           }
-          if (!existsSync31(videoPath)) return;
+          if (!existsSync33(videoPath)) return;
           const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
@@ -33895,10 +34036,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 = existsSync33(join35(compiledDir, imgPath)) ? join35(compiledDir, imgPath) : join35(projectDir, imgPath);
             imgPath = fromCompiled;
           }
-          if (!existsSync31(imgPath)) return null;
+          if (!existsSync33(imgPath)) return null;
           const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
@@ -33914,7 +34055,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: join35(workDir, "video-frames") },
         abortSignal,
         { extractCacheDir: cfg.extractCacheDir },
         compiledDir
@@ -33972,13 +34113,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 = join35(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join33(workDir, "audio-work"),
+        join35(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -33996,14 +34137,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join33(workDir, "compiled"),
+        compiledDir: join35(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join33(workDir, "captured-frames");
-    if (!existsSync31(framesDir)) mkdirSync18(framesDir, { recursive: true });
+    const framesDir = join35(workDir, "captured-frames");
+    if (!existsSync33(framesDir)) mkdirSync20(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -34018,7 +34159,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 = join35(workDir, `video-only${videoExt}`);
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
@@ -34040,8 +34181,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 = join35(compiledDir, srcPath);
+          srcPath = existsSync33(fromCompiled) ? fromCompiled : join35(projectDir, srcPath);
         }
         hdrVideoSrcPaths.set(v.id, srcPath);
       }
@@ -34171,8 +34312,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         for (const [videoId, srcPath] of hdrVideoSrcPaths) {
           const video = composition.videos.find((v) => v.id === videoId);
           if (!video) continue;
-          const frameDir = join33(framesDir, `hdr_${videoId}`);
-          mkdirSync18(frameDir, { recursive: true });
+          const frameDir = join35(framesDir, `hdr_${videoId}`);
+          mkdirSync20(frameDir, { recursive: true });
           const duration = video.end - video.start;
           const dims = hdrExtractionDims.get(videoId) ?? { width, height };
           const ffmpegArgs = [
@@ -34191,7 +34332,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             "-c:v",
             "png",
             "-y",
-            join33(frameDir, "frame_%04d.png")
+            join35(frameDir, "frame_%04d.png")
           ];
           const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
           if (!result.success) {
@@ -34210,7 +34351,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         const hdrImageBuffers = /* @__PURE__ */ new Map();
         for (const [imageId, srcPath] of hdrImageSrcPaths) {
           try {
-            const decoded = decodePngToRgb48le(readFileSync22(srcPath));
+            const decoded = decodePngToRgb48le(readFileSync23(srcPath));
             const layout2 = hdrExtractionDims.get(imageId);
             const fitInfo = hdrImageFitInfo.get(imageId);
             if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
@@ -34259,9 +34400,9 @@ 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)) {
-            mkdirSync18(debugDumpDir, { recursive: true });
+          const debugDumpDir = debugDumpEnabled ? join35(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync33(debugDumpDir)) {
+            mkdirSync20(debugDumpDir, { recursive: true });
           }
           if (!effectiveHdr) {
             throw new Error(
@@ -34407,11 +34548,11 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 i2
               );
               if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-                const previewPath = join33(
+                const previewPath = join35(
                   debugDumpDir,
                   `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`
                 );
-                writeFileSync12(previewPath, normalCanvas);
+                writeFileSync14(previewPath, normalCanvas);
               }
               hdrEncoder.writeFrame(normalCanvas);
             }
@@ -34754,7 +34895,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 = existsSync33(workDir) ? sampleDirectoryBytes(workDir) : 0;
     const perfSummary = {
       renderId: job.id,
       totalElapsedMs: totalElapsed,
@@ -34779,7 +34920,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync12(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync14(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log2.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -34788,8 +34929,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync31(outputPath)) {
-        const debugOutput = join33(workDir, `output${videoExt}`);
+      if (existsSync33(outputPath)) {
+        const debugOutput = join35(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else if (process.env.KEEP_TEMP === "1") {
@@ -34875,7 +35016,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync31(workDir)) rmSync7(workDir, { recursive: true, force: true });
+          if (existsSync33(workDir)) rmSync7(workDir, { recursive: true, force: true });
         },
         log2
       );
@@ -34935,8 +35076,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 existsSync34, readFileSync as readFileSync24, statSync as statSync10 } from "fs";
+import { resolve as resolve18, join as join36 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -34964,7 +35105,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve18(projectDir);
-  if (!existsSync32(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
+  if (!existsSync34(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -34975,16 +35116,16 @@ 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 (existsSync34(absoluteEntryPath) && statSync10(absoluteEntryPath).isFile()) {
       return {
         entryFile,
-        html: readFileSync23(absoluteEntryPath, "utf-8"),
+        html: readFileSync24(absoluteEntryPath, "utf-8"),
         source: "projectDir"
       };
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join36(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -35072,15 +35213,15 @@ var init_semaphore = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync33,
-  mkdirSync as mkdirSync19,
+  existsSync as existsSync35,
+  mkdirSync as mkdirSync21,
   statSync as statSync11,
   mkdtempSync as mkdtempSync2,
-  writeFileSync as writeFileSync13,
+  writeFileSync as writeFileSync15,
   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 join37 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -35103,11 +35244,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 (!existsSync35(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync33(resolve19(absProjectDir, entry))) {
+    if (!existsSync35(resolve19(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -35132,8 +35273,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(join37(tempRoot, "producer-project-"));
+  writeFileSync15(join37(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -35256,7 +35397,7 @@ function createRenderHandlers(options = {}) {
       log2
     );
     const outputDir = dirname12(absoluteOutputPath);
-    if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
+    if (!existsSync35(outputDir)) mkdirSync21(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log2.info("render started", {
       requestId,
@@ -35283,7 +35424,7 @@ function createRenderHandlers(options = {}) {
           log2.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+      const fileSize = existsSync35(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -35367,7 +35508,7 @@ function createRenderHandlers(options = {}) {
         log2
       );
       const outputDir = dirname12(absoluteOutputPath);
-      if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
+      if (!existsSync35(outputDir)) mkdirSync21(outputDir, { recursive: true });
       log2.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -35412,7 +35553,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync33(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
+        const fileSize = existsSync35(absoluteOutputPath) ? statSync11(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log2.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -35471,7 +35612,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync33(artifact.path)) {
+    if (!existsSync35(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -35609,20 +35750,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 existsSync36, readFileSync as readFileSync25, writeFileSync as writeFileSync16, statSync as statSync12 } from "fs";
+import { resolve as resolve20, join as join38, 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 (existsSync36(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 (existsSync36(devIndex)) {
     return {
       dir: devPath,
       indexPath: devIndex,
@@ -35639,9 +35780,9 @@ function resolveStudioBundle() {
 }
 function resolveRuntimePath() {
   const builtPath = resolve20(__dirname, "hyperframe-runtime.js");
-  if (existsSync34(builtPath)) return builtPath;
+  if (existsSync36(builtPath)) return builtPath;
   const iifePath = resolve20(__dirname, "hyperframe.runtime.iife.js");
-  if (existsSync34(iifePath)) return iifePath;
+  if (existsSync36(iifePath)) return iifePath;
   const devPath = resolve20(
     __dirname,
     "..",
@@ -35651,7 +35792,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync34(devPath)) return devPath;
+  if (existsSync36(devPath)) return devPath;
   return builtPath;
 }
 async function getThumbnailBrowser() {
@@ -35713,7 +35854,7 @@ function createStudioServer(options) {
       return lintHyperframeHtml2(html, opts);
     },
     runtimeUrl: "/api/runtime.js",
-    rendersDir: () => join36(projectDir, "renders"),
+    rendersDir: () => join38(projectDir, "renders"),
     startRender(opts) {
       const state = {
         id: opts.jobId,
@@ -35746,7 +35887,7 @@ function createStudioServer(options) {
           state.status = "complete";
           state.progress = 100;
           const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-          writeFileSync14(
+          writeFileSync16(
             metaPath,
             JSON.stringify({ status: "complete", durationMs: Date.now() - startTime })
           );
@@ -35755,7 +35896,7 @@ function createStudioServer(options) {
           state.error = err instanceof Error ? err.message : String(err);
           try {
             const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-            writeFileSync14(metaPath, JSON.stringify({ status: "failed" }));
+            writeFileSync16(metaPath, JSON.stringify({ status: "failed" }));
           } catch {
           }
         }
@@ -35828,7 +35969,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() ?? (existsSync36(runtimePath) ? readFileSync25(runtimePath, "utf-8") : null);
       if (!runtimeSource) return c2.text("runtime not available", 404);
       return c2.body(runtimeSource, 200, {
         "Content-Type": "text/javascript",
@@ -35864,23 +36005,23 @@ 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);
-    const content = readFileSync24(filePath);
+    if (!existsSync36(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    const content = readFileSync25(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
     });
   });
   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);
-    const content = readFileSync24(filePath);
+    if (!existsSync36(filePath) || !statSync12(filePath).isFile()) return c2.text("not found", 404);
+    const content = readFileSync25(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
     });
   });
   app.get("*", (c2) => {
     const indexPath = resolve20(studioDir, "index.html");
-    if (!existsSync34(indexPath)) {
+    if (!existsSync36(indexPath)) {
       return c2.html(
         `<!doctype html>
 <html>
@@ -35936,7 +36077,7 @@ function createStudioServer(options) {
         500
       );
     }
-    return c2.html(readFileSync24(indexPath, "utf-8"));
+    return c2.html(readFileSync25(indexPath, "utf-8"));
   });
   return { app, watcher };
 }
@@ -35959,21 +36100,21 @@ __export(preview_exports, {
   default: () => preview_default,
   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 { spawn as spawn9 } from "child_process";
+import { existsSync as existsSync37, lstatSync, symlinkSync, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync22 } from "fs";
+import { resolve as resolve21, dirname as dirname13, basename as basename4, join as join39 } 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 = join39(repoRoot, "packages", "studio", "data", "projects");
   const pName = projectName ?? basename4(dir);
-  const symlinkPath = join37(projectsDir, pName);
-  mkdirSync20(projectsDir, { recursive: true });
+  const symlinkPath = join39(projectsDir, pName);
+  mkdirSync22(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync35(symlinkPath)) {
+    if (existsSync37(symlinkPath)) {
       try {
         const stat3 = lstatSync(symlinkPath);
         if (stat3.isSymbolicLink()) {
@@ -35985,7 +36126,7 @@ async function runDevMode(dir, projectName) {
       } catch {
       }
     }
-    if (!existsSync35(symlinkPath)) {
+    if (!existsSync37(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -35993,8 +36134,8 @@ async function runDevMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview"));
   const s2 = be();
   s2.start("Starting studio...");
-  const studioPkgDir = join37(repoRoot, "packages", "studio");
-  const child = spawn8("pnpm", ["exec", "vite"], {
+  const studioPkgDir = join39(repoRoot, "packages", "studio");
+  const child = spawn9("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -36027,7 +36168,7 @@ async function runDevMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync37(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -36038,7 +36179,7 @@ async function runDevMode(dir, projectName) {
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join37(dir, "package.json"));
+    const req = createRequire(join39(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -36046,20 +36187,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir, projectName) {
-  const req = createRequire(join37(dir, "package.json"));
+  const req = createRequire(join39(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);
-  mkdirSync20(projectsDir, { recursive: true });
+  const projectsDir = join39(studioPkgPath, "data", "projects");
+  const symlinkPath = join39(projectsDir, pName);
+  mkdirSync22(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync35(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync37(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve21(readlinkSync(symlinkPath)) !== resolve21(dir)) {
         unlinkSync5(symlinkPath);
       }
     }
-    if (!existsSync35(symlinkPath)) {
+    if (!existsSync37(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -36067,7 +36208,7 @@ async function runLocalStudioMode(dir, projectName) {
   Wt2(c.bold("hyperframes preview") + c.dim(" (local studio)"));
   const s2 = be();
   s2.start("Starting studio...");
-  const child = spawn8("npx", ["vite"], {
+  const child = spawn9("npx", ["vite"], {
     cwd: studioPkgPath,
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -36098,7 +36239,7 @@ async function runLocalStudioMode(dir, projectName) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync35(symlinkPath)) unlinkSync5(symlinkPath);
+        if (existsSync37(symlinkPath)) unlinkSync5(symlinkPath);
       } catch {
       }
     });
@@ -36274,8 +36415,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 = join39(dir, "index.html");
+        if (existsSync37(indexPath)) {
           const project = { dir, name: projectName, indexPath };
           const lintResult = lintProject(project);
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
@@ -36304,17 +36445,17 @@ __export(init_exports, {
   examples: () => examples2
 });
 import {
-  existsSync as existsSync36,
-  mkdirSync as mkdirSync21,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync23,
   copyFileSync as copyFileSync3,
   cpSync,
-  writeFileSync as writeFileSync15,
-  readFileSync as readFileSync25,
+  writeFileSync as writeFileSync17,
+  readFileSync as readFileSync26,
   readdirSync as readdirSync14
 } 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 join40, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { execFileSync as execFileSync4, spawn as spawn9 } from "child_process";
+import { execFileSync as execFileSync4, spawn as spawn10 } from "child_process";
 function probeVideo(filePath) {
   try {
     const raw = execFileSync4(
@@ -36356,7 +36497,7 @@ function isWebCompatible(codec) {
 }
 function transcodeToMp4(inputPath, outputPath) {
   return new Promise((resolvePromise) => {
-    const child = spawn9(
+    const child = spawn10(
       "ffmpeg",
       [
         "-i",
@@ -36384,7 +36525,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 existsSync38(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -36393,9 +36534,9 @@ 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 = readdirSync14(dir, { withFileTypes: true, recursive: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".html")).map((e2) => join40(e2.parentPath ?? e2.path, e2.name));
   for (const file of htmlFiles) {
-    let content = readFileSync25(file, "utf-8");
+    let content = readFileSync26(file, "utf-8");
     if (videoFilename) {
       content = content.replaceAll("__VIDEO_SRC__", videoFilename);
     } else {
@@ -36406,7 +36547,7 @@ function patchVideoSrc(dir, videoFilename, durationSeconds) {
     }
     const dur = durationSeconds ? String(Math.round(durationSeconds * 100) / 100) : "10";
     content = content.replaceAll("__VIDEO_DURATION__", dur);
-    writeFileSync15(file, content, "utf-8");
+    writeFileSync17(file, content, "utf-8");
   }
 }
 async function patchTranscript(dir, transcriptPath) {
@@ -36498,15 +36639,15 @@ async function handleVideoFile(videoPath, destDir, interactive) {
   return { meta, localVideoName };
 }
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
-  mkdirSync21(destDir, { recursive: true });
+  mkdirSync23(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
-  if (existsSync36(templateDir)) {
+  if (existsSync38(templateDir)) {
     cpSync(templateDir, destDir, { recursive: true });
   } else {
     await fetchRemoteTemplate(templateId, destDir);
   }
   patchVideoSrc(destDir, localVideoName, durationSeconds);
-  writeFileSync15(
+  writeFileSync17(
     resolve22(destDir, "meta.json"),
     JSON.stringify(
       {
@@ -36519,14 +36660,14 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
     ),
     "utf-8"
   );
-  if (!existsSync36(resolve22(destDir, "hyperframes.json"))) {
+  if (!existsSync38(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)) {
+  if (existsSync38(sharedDir)) {
     for (const entry of readdirSync14(sharedDir, { withFileTypes: true })) {
-      const src = join38(sharedDir, entry.name);
+      const src = join40(sharedDir, entry.name);
       const dest = resolve22(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
@@ -36640,11 +36781,11 @@ 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 (existsSync38(destDir2) && readdirSync14(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
-          mkdirSync21(destDir2, { recursive: true });
+          mkdirSync23(destDir2, { recursive: true });
           let localVideoName2;
           let videoDuration2;
           let sourceFilePath2;
@@ -36654,7 +36795,7 @@ var init_init = __esm({
           }
           if (videoFlag) {
             const videoPath = resolve22(videoFlag);
-            if (!existsSync36(videoPath)) {
+            if (!existsSync38(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -36668,7 +36809,7 @@ var init_init = __esm({
           }
           if (audioFlag) {
             const audioPath = resolve22(audioFlag);
-            if (!existsSync36(audioPath)) {
+            if (!existsSync38(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -36714,7 +36855,7 @@ var init_init = __esm({
           }
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve22(destDir2, "transcript.json");
-          if (existsSync36(transcriptFile2)) {
+          if (existsSync38(transcriptFile2)) {
             await patchTranscript(destDir2, transcriptFile2);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
@@ -36766,7 +36907,7 @@ var init_init = __esm({
           name = nameResult;
         }
         const destDir = resolve22(name);
-        if (existsSync36(destDir) && readdirSync14(destDir).length > 0) {
+        if (existsSync38(destDir) && readdirSync14(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -36781,24 +36922,24 @@ var init_init = __esm({
         let videoDuration;
         if (videoFlag) {
           const videoPath = resolve22(videoFlag);
-          if (!existsSync36(videoPath)) {
+          if (!existsSync38(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
           }
-          mkdirSync21(destDir, { recursive: true });
+          mkdirSync23(destDir, { recursive: true });
           sourceFilePath = videoPath;
           const result = await handleVideoFile(videoPath, destDir, true);
           localVideoName = result.localVideoName;
           videoDuration = result.meta.durationSeconds;
         } else if (audioFlag) {
           const audioPath = resolve22(audioFlag);
-          if (!existsSync36(audioPath)) {
+          if (!existsSync38(audioPath)) {
             R2.error(`File not found: ${audioFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
           }
-          mkdirSync21(destDir, { recursive: true });
+          mkdirSync23(destDir, { recursive: true });
           sourceFilePath = audioPath;
           copyFileSync3(audioPath, resolve22(destDir, basename5(audioPath)));
           R2.info(`Audio copied to ${c.accent(basename5(audioPath))}`);
@@ -36886,7 +37027,7 @@ ${c.dim("Use --example blank for offline use.")}`
         }
         trackInitTemplate(templateId);
         const transcriptFile = resolve22(destDir, "transcript.json");
-        if (existsSync36(transcriptFile)) {
+        if (existsSync38(transcriptFile)) {
           await patchTranscript(destDir, transcriptFile);
         }
         const files = readdirSync14(destDir);
@@ -36972,7 +37113,7 @@ __export(add_exports, {
   remapTarget: () => remapTarget,
   runAdd: () => runAdd
 });
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import { resolve as resolve23, relative as relative3 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
@@ -36998,8 +37139,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 = existsSync39(projectConfigPath(projectDir));
+  if (!hasConfig && existsSync39(resolve23(projectDir, "index.html"))) {
     writeProjectConfig(projectDir, DEFAULT_PROJECT_CONFIG);
     config = DEFAULT_PROJECT_CONFIG;
   }
@@ -37098,10 +37239,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 = existsSync39(projectConfigPath(projectDir));
         try {
           const result = await runAdd({ name: args.name, projectDir, skipClipboard });
-          const wroteConfig = !hasConfigBefore && existsSync37(projectConfigPath(projectDir));
+          const wroteConfig = !hasConfigBefore && existsSync39(projectConfigPath(projectDir));
           if (json) {
             console.log(JSON.stringify(result));
             return;
@@ -37311,17 +37452,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync38, statSync as statSync13 } from "fs";
+import { existsSync as existsSync40, statSync as statSync13 } from "fs";
 import { resolve as resolve25, basename as basename6 } from "path";
 function resolveProject(dirArg) {
   const dir = resolve25(dirArg ?? ".");
   const name = basename6(dir);
   const indexPath = resolve25(dir, "index.html");
-  if (!existsSync38(dir) || !statSync13(dir).isDirectory()) {
+  if (!existsSync40(dir) || !statSync13(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync38(indexPath)) {
+  if (!existsSync40(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -37344,7 +37485,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync39, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync27 } from "fs";
 import { resolve as resolve26, dirname as dirname15 } from "path";
 function commandDir() {
   return dirname15(new URL(import.meta.url).pathname);
@@ -37359,7 +37500,7 @@ function resolveRuntimePath2() {
     resolve26(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
   ];
   for (const p of candidates) {
-    if (existsSync39(p)) return p;
+    if (existsSync41(p)) return p;
   }
   return null;
 }
@@ -37373,7 +37514,7 @@ function resolvePlayerPath() {
     resolve26(d, "..", "hyperframes-player.global.js")
   ];
   for (const p of candidates) {
-    if (existsSync39(p)) return p;
+    if (existsSync41(p)) return p;
   }
   return null;
 }
@@ -37460,13 +37601,13 @@ var init_play = __esm({
         const { createAdaptorServer } = await import("@hono/node-server");
         const app = new Hono6();
         app.get("/player.js", (ctx) => {
-          return ctx.body(readFileSync26(playerPath, "utf-8"), 200, {
+          return ctx.body(readFileSync27(playerPath, "utf-8"), 200, {
             "Content-Type": "application/javascript",
             "Cache-Control": "no-cache"
           });
         });
         app.get("/runtime.js", (ctx) => {
-          return ctx.body(readFileSync26(runtimePath, "utf-8"), 200, {
+          return ctx.body(readFileSync27(runtimePath, "utf-8"), 200, {
             "Content-Type": "application/javascript",
             "Cache-Control": "no-cache"
           });
@@ -37475,8 +37616,8 @@ 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);
-          const content = readFileSync26(filePath, "utf-8");
+          if (!existsSync41(filePath)) return ctx.text("Not found", 404);
+          const content = readFileSync27(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
             return ctx.html(injected);
@@ -37495,7 +37636,7 @@ var init_play = __esm({
             mp3: "audio/mpeg",
             wav: "audio/wav"
           };
-          return ctx.body(readFileSync26(filePath), 200, {
+          return ctx.body(readFileSync27(filePath), 200, {
             "Content-Type": types3[ext] ?? "application/octet-stream"
           });
         });
@@ -37551,8 +37692,8 @@ 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 join41, relative as relative4 } from "path";
+import { readdirSync as readdirSync15, readFileSync as readFileSync28, statSync as statSync14 } from "fs";
 import AdmZip from "adm-zip";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -37643,7 +37784,7 @@ function shouldIgnoreSegment(segment) {
 function collectProjectFiles(rootDir, currentDir, paths) {
   for (const entry of readdirSync15(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
-    const absolutePath = join39(currentDir, entry.name);
+    const absolutePath = join41(currentDir, entry.name);
     const relativePath = relative4(rootDir, absolutePath).replaceAll("\\", "/");
     if (!relativePath) continue;
     if (entry.isDirectory()) {
@@ -37662,7 +37803,7 @@ function createPublishArchive(projectDir) {
   }
   const archive = new AdmZip();
   for (const filePath of filePaths) {
-    archive.addFile(filePath, readFileSync27(join39(projectDir, filePath)));
+    archive.addFile(filePath, readFileSync28(join41(projectDir, filePath)));
   }
   return {
     buffer: archive.toBuffer(),
@@ -37778,8 +37919,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 existsSync42 } from "fs";
+import { join as join42 } from "path";
 var examples6, publish_default;
 var init_publish = __esm({
   "src/commands/publish.ts"() {
@@ -37814,8 +37955,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 = join42(dir, "index.html");
+        if (existsSync42(indexPath)) {
           const lintResult = lintProject({ dir, name: projectName, indexPath });
           if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
             console.log();
@@ -37986,10 +38127,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 mkdirSync24, readFileSync as readFileSync29, statSync as statSync15, writeFileSync as writeFileSync18, 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 join43, basename as basename9 } from "path";
+import { execFileSync as execFileSync5, spawn as spawn11 } from "child_process";
 function defaultWorkerCount() {
   return Math.max(1, Math.min(Math.floor(CPU_CORE_COUNT * 3 / 4), 8));
 }
@@ -38025,9 +38166,9 @@ 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()}`);
-  mkdirSync22(tmpDir, { recursive: true });
-  writeFileSync16(join41(tmpDir, "Dockerfile"), readFileSync28(dockerfilePath));
+  const tmpDir = join43(tmpdir4(), `hyperframes-docker-${Date.now()}`);
+  mkdirSync24(tmpDir, { recursive: true });
+  writeFileSync18(join43(tmpDir, "Dockerfile"), readFileSync29(dockerfilePath));
   try {
     execFileSync5(
       "docker",
@@ -38096,7 +38237,7 @@ async function renderDocker(projectDir, outputPath, options) {
   }
   try {
     await new Promise((resolvePromise, reject) => {
-      const child = spawn10("docker", dockerArgs, {
+      const child = spawn11("docker", dockerArgs, {
         // When quiet, still show stderr so container errors surface
         stdio: options.quiet ? ["pipe", "pipe", "inherit"] : "inherit"
       });
@@ -38375,8 +38516,8 @@ var init_render2 = __esm({
         const now = /* @__PURE__ */ new Date();
         const datePart = now.toISOString().slice(0, 10);
         const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
-        const outputPath = args.output ? resolve28(args.output) : join41(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
-        mkdirSync22(dirname16(outputPath), { recursive: true });
+        const outputPath = args.output ? resolve28(args.output) : join43(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        mkdirSync24(dirname16(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
         const quiet = args.quiet ?? false;
@@ -38851,8 +38992,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 existsSync43, readFileSync as readFileSync30 } from "fs";
+import { dirname as dirname17, isAbsolute as isAbsolute6, join as join44, relative as relative5, resolve as resolve29 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -38922,8 +39063,8 @@ async function bundleProjectHtml(projectDir) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync41(runtimePath)) {
-    const runtimeSource = readFileSync29(runtimePath, "utf-8");
+  if (existsSync43(runtimePath)) {
+    const runtimeSource = readFileSync30(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
       () => `<script data-hyperframes-preview-runtime="1">${runtimeSource}</script>`
@@ -38947,9 +39088,9 @@ async function serveProject(projectDir, html) {
       res.end();
       return;
     }
-    if (existsSync41(filePath)) {
+    if (existsSync43(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
-      res.end(readFileSync29(filePath));
+      res.end(readFileSync30(filePath));
       return;
     }
     res.writeHead(404);
@@ -39051,11 +39192,11 @@ async function runLayoutAudit(projectDir, opts) {
 }
 function loadLayoutAuditScript() {
   const candidates = [
-    join42(__dirname2, "layout-audit.browser.js"),
-    join42(__dirname2, "commands", "layout-audit.browser.js")
+    join44(__dirname2, "layout-audit.browser.js"),
+    join44(__dirname2, "commands", "layout-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync41(candidate)) return readFileSync29(candidate, "utf-8");
+    if (existsSync43(candidate)) return readFileSync30(candidate, "utf-8");
   }
   throw new Error("Missing layout audit browser script");
 }
@@ -39275,12 +39416,12 @@ __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 readFileSync31, readdirSync as readdirSync16, statSync as statSync16 } from "fs";
+import { join as join45 } from "path";
 function totalSize(dir) {
   let total = 0;
   for (const entry of readdirSync16(dir, { withFileTypes: true })) {
-    const path2 = join43(dir, entry.name);
+    const path2 = join45(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path2);
     } else {
@@ -39312,7 +39453,7 @@ var init_info = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync30(project.indexPath, "utf-8");
+        const html = readFileSync31(project.indexPath, "utf-8");
         ensureDOMParser();
         const parsed = parseHtml(html);
         const tracks = new Set(parsed.elements.map((el) => el.zIndex));
@@ -39368,7 +39509,7 @@ __export(compositions_exports, {
   default: () => compositions_default,
   examples: () => examples12
 });
-import { existsSync as existsSync42, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync32 } from "fs";
 import { resolve as resolve30, dirname as dirname18 } from "path";
 function parseCompositions(html, baseDir) {
   const parser = new DOMParser();
@@ -39382,8 +39523,8 @@ function parseCompositions(html, baseDir) {
     const compositionSrc = div.getAttribute("data-composition-src");
     if (compositionSrc) {
       const subPath = resolve30(baseDir, compositionSrc);
-      if (existsSync42(subPath)) {
-        const subHtml = readFileSync31(subPath, "utf-8");
+      if (existsSync44(subPath)) {
+        const subHtml = readFileSync32(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
         return;
@@ -39477,7 +39618,7 @@ var init_compositions = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync31(project.indexPath, "utf-8");
+        const html = readFileSync32(project.indexPath, "utf-8");
         ensureDOMParser();
         const compositions = parseCompositions(html, dirname18(project.indexPath));
         if (compositions.length === 0) {
@@ -39515,8 +39656,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 existsSync45, statSync as statSync17 } from "fs";
+import { resolve as resolve31, join as join46 } from "path";
 var examples13, DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -39591,7 +39732,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 = join46(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i2}.mp4`
             );
@@ -39605,7 +39746,7 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync43(outputPath)) {
+              if (existsSync45(outputPath)) {
                 const stat3 = statSync17(outputPath);
                 fileSize = stat3.size;
               }
@@ -39821,8 +39962,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 existsSync46, writeFileSync as writeFileSync19 } from "fs";
+import { resolve as resolve32, join as join47, 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);
@@ -39830,8 +39971,8 @@ async function importTranscript(inputPath, dir, json) {
     console.error(c.error("No words found in transcript."));
     process.exit(1);
   }
-  const outPath = join45(dir, "transcript.json");
-  writeFileSync17(outPath, JSON.stringify(words, null, 2));
+  const outPath = join47(dir, "transcript.json");
+  writeFileSync19(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
     console.log(
@@ -39866,7 +40007,7 @@ async function transcribeAudio(inputPath, dir, opts) {
         );
       }
     }
-    writeFileSync17(result.transcriptPath, JSON.stringify(words, null, 2));
+    writeFileSync19(result.transcriptPath, JSON.stringify(words, null, 2));
     patchCaptionHtml2(dir, words);
     if (opts.json) {
       console.log(
@@ -39947,7 +40088,7 @@ var init_transcribe2 = __esm({
       },
       async run({ args }) {
         const inputPath = resolve32(args.input);
-        if (!existsSync44(inputPath)) {
+        if (!existsSync46(inputPath)) {
           console.error(c.error(`File not found: ${args.input}`));
           process.exit(1);
         }
@@ -39968,9 +40109,9 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync23 } from "fs";
+import { existsSync as existsSync47, mkdirSync as mkdirSync25 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join46 } from "path";
+import { join as join48 } from "path";
 function inferLangFromVoiceId(voiceId) {
   const first = voiceId.charAt(0).toLowerCase();
   return VOICE_PREFIX_LANG[first] ?? "en-us";
@@ -39979,29 +40120,29 @@ 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 = join48(MODELS_DIR2, `${model}.onnx`);
+  if (existsSync47(modelPath)) return modelPath;
   const url = MODEL_URLS[model];
   if (!url) {
     throw new Error(
       `Unknown TTS model: ${model}. Available: ${Object.keys(MODEL_URLS).join(", ")}`
     );
   }
-  mkdirSync23(MODELS_DIR2, { recursive: true });
+  mkdirSync25(MODELS_DIR2, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath);
-  if (!existsSync45(modelPath)) {
+  if (!existsSync47(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;
-  mkdirSync23(VOICES_DIR, { recursive: true });
+  const voicesPath = join48(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync47(voicesPath)) return voicesPath;
+  mkdirSync25(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
-  if (!existsSync45(voicesPath)) {
+  if (!existsSync47(voicesPath)) {
     throw new Error("Voice data download failed");
   }
   return voicesPath;
@@ -40011,9 +40152,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 = join48(homedir8(), ".cache", "hyperframes", "tts");
+    MODELS_DIR2 = join48(CACHE_DIR3, "models");
+    VOICES_DIR = join48(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"
@@ -40074,8 +40215,8 @@ __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 { existsSync as existsSync48, writeFileSync as writeFileSync20, mkdirSync as mkdirSync26, readdirSync as readdirSync17, unlinkSync as unlinkSync6 } from "fs";
+import { join as join49, dirname as dirname19, basename as basename10 } from "path";
 import { homedir as homedir9 } from "os";
 function findPython() {
   for (const name of ["python3", "python"]) {
@@ -40111,15 +40252,15 @@ function hasPythonPackage(python, pkg) {
   }
 }
 function ensureSynthScript() {
-  if (!existsSync46(SCRIPT_PATH)) {
-    mkdirSync24(SCRIPT_DIR, { recursive: true });
-    writeFileSync18(SCRIPT_PATH, SYNTH_SCRIPT);
+  if (!existsSync48(SCRIPT_PATH)) {
+    mkdirSync26(SCRIPT_DIR, { recursive: true });
+    writeFileSync20(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename10(SCRIPT_PATH);
     try {
       for (const entry of readdirSync17(SCRIPT_DIR)) {
         if (entry !== currentName && /^synth(-v\d+)?\.py$/.test(entry)) {
           try {
-            unlinkSync6(join47(SCRIPT_DIR, entry));
+            unlinkSync6(join49(SCRIPT_DIR, entry));
           } catch {
           }
         }
@@ -40153,7 +40294,7 @@ async function synthesize(text, outputPath, options) {
     ensureVoices({ onProgress: options?.onProgress })
   ]);
   const scriptPath = ensureSynthScript();
-  mkdirSync24(dirname19(outputPath), { recursive: true });
+  mkdirSync26(dirname19(outputPath), { recursive: true });
   options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
   try {
     const stdout2 = execFileSync6(
@@ -40165,7 +40306,7 @@ async function synthesize(text, outputPath, options) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    if (!existsSync46(outputPath)) {
+    if (!existsSync48(outputPath)) {
       throw new Error("Synthesis completed but no output file was created");
     }
     const lines = stdout2.trim().split("\n");
@@ -40178,7 +40319,7 @@ async function synthesize(text, outputPath, options) {
       langApplied: result.langApplied
     };
   } catch (err) {
-    if (err instanceof SyntaxError && existsSync46(outputPath)) {
+    if (err instanceof SyntaxError && existsSync48(outputPath)) {
       throw new Error(
         "Speech was generated but metadata could not be read. Check the output file manually."
       );
@@ -40229,8 +40370,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 = join49(homedir9(), ".cache", "hyperframes", "tts");
+    SCRIPT_PATH = join49(SCRIPT_DIR, "synth-v2.py");
   }
 });
 
@@ -40240,7 +40381,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples16
 });
-import { existsSync as existsSync47, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync33 } 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) }));
@@ -40350,8 +40491,8 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve33(args.input);
-        if (existsSync47(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
-          text = readFileSync32(maybeFile, "utf-8").trim();
+        if (existsSync49(maybeFile) && extname9(maybeFile).toLowerCase() === ".txt") {
+          text = readFileSync33(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
             process.exit(1);
@@ -40443,15 +40584,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 readFileSync34, existsSync as existsSync50 } from "fs";
+import { resolve as resolve34, dirname as dirname20, join as join50 } 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 existsSync50(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -40548,12 +40689,12 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join48(docsDir(), entry.file);
-        if (!existsSync48(filePath)) {
+        const filePath = join50(docsDir(), entry.file);
+        if (!existsSync50(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
-        const content = readFileSync33(filePath, "utf-8");
+        const content = readFileSync34(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -40979,8 +41120,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 existsSync51, readFileSync as readFileSync35 } from "fs";
+import { resolve as resolve35, join as join51, dirname as dirname21 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function getCompositionDuration3(page) {
   return page.evaluate(() => {
@@ -41035,8 +41176,8 @@ async function validateInBrowser(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync49(runtimePath)) {
-    const runtimeSource = readFileSync34(runtimePath, "utf-8");
+  if (existsSync51(runtimePath)) {
+    const runtimeSource = readFileSync35(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
       () => `<script data-hyperframes-preview-runtime="1">${runtimeSource}</script>`
@@ -41051,10 +41192,10 @@ async function validateInBrowser(projectDir, opts) {
       res.end(html);
       return;
     }
-    const filePath = join49(projectDir, decodeURIComponent(url));
-    if (existsSync49(filePath)) {
+    const filePath = join51(projectDir, decodeURIComponent(url));
+    if (existsSync51(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
-      res.end(readFileSync34(filePath));
+      res.end(readFileSync35(filePath));
       return;
     }
     res.writeHead(404);
@@ -41244,14 +41385,14 @@ __export(snapshot_exports, {
   default: () => snapshot_default,
   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 { spawn as spawn12 } from "child_process";
+import { existsSync as existsSync52, mkdtempSync as mkdtempSync3, readFileSync as readFileSync36, mkdirSync as mkdirSync27, 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 join52, 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(join52(tmpdir5(), "hf-snapshot-frame-"));
+  const outPath = join52(tmp, "frame.png");
   try {
     const result = await new Promise(
       (resolvePromise) => {
@@ -41271,7 +41412,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
           "-y",
           outPath
         );
-        const ff = spawn11("ffmpeg", args);
+        const ff = spawn12("ffmpeg", args);
         let stderr = "";
         let timedOut = false;
         const timer = setTimeout(() => {
@@ -41291,8 +41432,8 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
         });
       }
     );
-    if (result.code !== 0 || result.timedOut || !existsSync50(outPath)) return null;
-    return readFileSync35(outPath);
+    if (result.code !== 0 || result.timedOut || !existsSync52(outPath)) return null;
+    return readFileSync36(outPath);
   } finally {
     try {
       rmSync10(tmp, { recursive: true, force: true });
@@ -41314,8 +41455,8 @@ async function captureSnapshots(projectDir, opts) {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync50(runtimePath)) {
-    const runtimeSource = readFileSync35(runtimePath, "utf-8");
+  if (existsSync52(runtimePath)) {
+    const runtimeSource = readFileSync36(runtimePath, "utf-8");
     html = html.replace(
       /<script[^>]*data-hyperframes-preview-runtime[^>]*src="[^"]*"[^>]*><\/script>/,
       () => `<script data-hyperframes-preview-runtime="1">${runtimeSource}</script>`
@@ -41337,9 +41478,9 @@ async function captureSnapshots(projectDir, opts) {
       res.end();
       return;
     }
-    if (existsSync50(filePath)) {
+    if (existsSync52(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
-      res.end(readFileSync35(filePath));
+      res.end(readFileSync36(filePath));
       return;
     }
     res.writeHead(404);
@@ -41412,8 +41553,8 @@ async function captureSnapshots(projectDir, opts) {
         return [];
       }
       const positions = opts.at?.length ? opts.at : numFrames === 1 ? [duration / 2] : Array.from({ length: numFrames }, (_2, i2) => i2 / (numFrames - 1) * duration);
-      const snapshotDir = join50(projectDir, "snapshots");
-      mkdirSync25(snapshotDir, { recursive: true });
+      const snapshotDir = join52(projectDir, "snapshots");
+      mkdirSync27(snapshotDir, { recursive: true });
       let injectVideoFramesBatch2 = null;
       let syncVideoFrameVisibility2 = null;
       let extractMediaMetadata2 = null;
@@ -41487,7 +41628,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) && existsSync52(candidate)) {
                 filePath = candidate;
               }
             } catch {
@@ -41517,7 +41658,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 = join52(snapshotDir, filename);
         await page.screenshot({ path: framePath, type: "png" });
         savedPaths.push(`snapshots/${filename}`);
       }
@@ -41602,14 +41743,14 @@ ${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 { writeFileSync as writeFileSync21, mkdirSync as mkdirSync28 } from "fs";
+import { join as join53, extname as extname10 } from "path";
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
-  const assetsDir = join51(outputDir, "assets");
-  mkdirSync26(assetsDir, { recursive: true });
+  const assetsDir = join53(outputDir, "assets");
+  mkdirSync28(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync26(join51(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync28(join53(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;
@@ -41617,7 +41758,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");
+      writeFileSync21(join53(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
@@ -41630,7 +41771,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);
+        writeFileSync21(join53(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -41687,7 +41828,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);
+        writeFileSync21(join53(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -41700,7 +41841,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);
+        writeFileSync21(join53(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -41723,8 +41864,8 @@ function normalizeUrl(u) {
   }
 }
 async function downloadAndRewriteFonts(css, outputDir) {
-  const assetsDir = join51(outputDir, "assets", "fonts");
-  mkdirSync26(assetsDir, { recursive: true });
+  const assetsDir = join53(outputDir, "assets", "fonts");
+  mkdirSync28(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
   let match;
@@ -41759,11 +41900,11 @@ 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 = join53(assetsDir, filename);
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
-        writeFileSync19(localPath, buffer);
+        writeFileSync21(localPath, buffer);
         rewritten = rewritten.split(fontUrl).join(relativePath);
         familyCounts.set(family, familyCount + 1);
         count++;
@@ -42556,8 +42697,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 mkdirSync29, writeFileSync as writeFileSync22, readdirSync as readdirSync18, readFileSync as readFileSync37, statSync as statSync18 } from "fs";
+import { join as join54 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -42590,7 +42731,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);
+            writeFileSync22(join54(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -42608,7 +42749,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync20(join52(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync22(join54(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -42618,22 +42759,22 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 }
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
-  const previewDir = join52(lottieDir, "previews");
-  mkdirSync27(previewDir, { recursive: true });
+  const previewDir = join54(lottieDir, "previews");
+  mkdirSync29(previewDir, { recursive: true });
   for (const file of readdirSync18(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync36(join52(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync37(join54(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 = statSync18(join54(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(readFileSync37(join54(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -42663,7 +42804,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
         await previewPage.waitForFunction(() => window.__READY === true, { timeout: 5e3 }).catch(() => {
         });
         await previewPage.screenshot({
-          path: join52(previewDir, previewName),
+          path: join54(previewDir, previewName),
           type: "png",
           omitBackground: true
         });
@@ -42686,8 +42827,8 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
     }
   }
   if (manifest.length > 0) {
-    writeFileSync20(
-      join52(outputDir, "extracted", "lottie-manifest.json"),
+    writeFileSync22(
+      join54(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -42749,15 +42890,15 @@ async function captureVideoManifest(page, outputDir, progress) {
     return true;
   });
   if (uniqueVideos.length > 0) {
-    const videoManifestDir = join52(outputDir, "assets", "videos");
-    mkdirSync27(videoManifestDir, { recursive: true });
-    const previewDir = join52(videoManifestDir, "previews");
-    mkdirSync27(previewDir, { recursive: true });
+    const videoManifestDir = join54(outputDir, "assets", "videos");
+    mkdirSync29(videoManifestDir, { recursive: true });
+    const previewDir = join54(videoManifestDir, "previews");
+    mkdirSync29(previewDir, { recursive: true });
     const videoManifest = [];
     for (let vi = 0; vi < uniqueVideos.length && vi < 20; vi++) {
       const v = uniqueVideos[vi];
       const previewName = `video-${vi}-preview.png`;
-      const previewPath = join52(previewDir, previewName);
+      const previewPath = join54(previewDir, previewName);
       try {
         await page.evaluate(`window.scrollTo(0, ${Math.max(0, v.top - 100)})`);
         await new Promise((r2) => setTimeout(r2, 300));
@@ -42795,8 +42936,8 @@ async function captureVideoManifest(page, outputDir, progress) {
       });
     }
     if (videoManifest.length > 0) {
-      writeFileSync20(
-        join52(outputDir, "extracted", "video-manifest.json"),
+      writeFileSync22(
+        join54(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
       );
@@ -83251,8 +83392,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 readdirSync19, statSync as statSync20, readFileSync as readFileSync38 } from "fs";
+import { join as join55 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
   try {
@@ -83372,7 +83513,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 = readdirSync19(join55(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";
@@ -83381,10 +83522,10 @@ 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 filePath = join55(outputDir, "assets", file);
           const stat3 = statSync20(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
-          const buffer = readFileSync37(filePath);
+          const buffer = readFileSync38(filePath);
           const base64 = buffer.toString("base64");
           const ext = file.split(".").pop()?.toLowerCase() || "png";
           const mimeType = ext === "jpg" ? "image/jpeg" : `image/${ext}`;
@@ -83430,11 +83571,11 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   const uncaptionedLines = [];
   const svgLines = [];
   const fontLines = [];
-  const assetsPath = join53(outputDir, "assets");
+  const assetsPath = join55(outputDir, "assets");
   try {
     for (const file of readdirSync19(assetsPath)) {
       if (file === "svgs" || file === "fonts" || file === "lottie" || file === "videos") continue;
-      const filePath = join53(assetsPath, file);
+      const filePath = join55(assetsPath, file);
       const stat3 = statSync20(filePath);
       if (!stat3.isFile()) continue;
       const sizeKb = Math.round(stat3.size / 1024);
@@ -83463,7 +83604,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const svgsPath = join53(assetsPath, "svgs");
+    const svgsPath = join55(assetsPath, "svgs");
     for (const file of readdirSync19(svgsPath)) {
       if (!file.endsWith(".svg")) continue;
       const svgMatch = tokens.svgs.find(
@@ -83478,7 +83619,7 @@ function generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCap
   } catch {
   }
   try {
-    const fontsPath = join53(assetsPath, "fonts");
+    const fontsPath = join55(assetsPath, "fonts");
     for (const file of readdirSync19(fontsPath)) {
       fontLines.push(`fonts/${file} \u2014 font file`);
     }
@@ -83497,13 +83638,13 @@ var agentPromptGenerator_exports = {};
 __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
-import { writeFileSync as writeFileSync21 } from "fs";
-import { join as join54 } from "path";
+import { writeFileSync as writeFileSync23 } from "fs";
+import { join as join56 } 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");
+  writeFileSync23(join56(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync23(join56(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync23(join56(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(url, tokens, hasScreenshot, hasLottie, hasShaders, detectedLibraries) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -83570,15 +83711,15 @@ 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 existsSync53, writeFileSync as writeFileSync24, readFileSync as readFileSync39 } from "fs";
+import { join as join57, resolve as resolve37 } from "path";
 function loadEnvFile(startDir) {
   try {
     let dir = resolve37(startDir);
     for (let i2 = 0; i2 < 5; i2++) {
       const envPath = resolve37(dir, ".env");
       try {
-        const envContent = readFileSync38(envPath, "utf-8");
+        const envContent = readFileSync39(envPath, "utf-8");
         for (const line of envContent.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -83597,10 +83738,10 @@ 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 = join57(outputDir, "meta.json");
+  if (!existsSync53(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
-    writeFileSync22(
+    writeFileSync24(
       metaPath,
       JSON.stringify({ id: hostname + "-video", name: tokens.title || hostname }, null, 2),
       "utf-8"
@@ -83635,11 +83776,11 @@ var screenshotCapture_exports = {};
 __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
-import { writeFileSync as writeFileSync23, mkdirSync as mkdirSync28 } from "fs";
-import { join as join56 } from "path";
+import { writeFileSync as writeFileSync25, mkdirSync as mkdirSync30 } from "fs";
+import { join as join58 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
-  const screenshotsDir = join56(outputDir, "screenshots");
-  mkdirSync28(screenshotsDir, { recursive: true });
+  const screenshotsDir = join58(outputDir, "screenshots");
+  mkdirSync30(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
   try {
@@ -83672,9 +83813,9 @@ async function captureScrollScreenshots(page, outputDir) {
         finalPositions[i2] / Math.max(1, scrollHeight - viewportHeight) * 100
       );
       const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
-      const filePath = join56(screenshotsDir, filename);
+      const filePath = join58(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
-      writeFileSync23(filePath, buffer);
+      writeFileSync25(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
     }
     await page.evaluate(`window.scrollTo(0, 0)`);
@@ -83985,8 +84126,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 mkdirSync31, writeFileSync as writeFileSync26, existsSync as existsSync54 } from "fs";
+import { join as join59 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
     url,
@@ -84003,9 +84144,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 });
+  mkdirSync31(join59(outputDir, "extracted"), { recursive: true });
+  mkdirSync31(join59(outputDir, "screenshots"), { recursive: true });
+  mkdirSync31(join59(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -84161,8 +84302,8 @@ async function captureWebsite(opts, onProgress) {
     } catch {
     }
     if (discoveredLotties.length > 0) {
-      const lottieDir = join57(outputDir, "assets", "lottie");
-      mkdirSync29(lottieDir, { recursive: true });
+      const lottieDir = join59(outputDir, "assets", "lottie");
+      mkdirSync31(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
         await renderLottiePreviews(chromeBrowser, lottieDir, outputDir);
@@ -84180,8 +84321,8 @@ async function captureWebsite(opts, onProgress) {
           return true;
         });
         capturedShaders = unique;
-        writeFileSync24(
-          join57(outputDir, "extracted", "shaders.json"),
+        writeFileSync26(
+          join59(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
         );
@@ -84191,8 +84332,8 @@ async function captureWebsite(opts, onProgress) {
     }
     progress("tokens", "Extracting design tokens...");
     const tokens = await extractTokens(page1);
-    writeFileSync24(
-      join57(outputDir, "extracted", "tokens.json"),
+    writeFileSync26(
+      join59(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokens, null, 2),
       "utf-8"
     );
@@ -84265,8 +84406,8 @@ async function captureWebsite(opts, onProgress) {
         scrollTriggeredElements: (animationCatalog.scrollTargets || []).length,
         representativeAnimations: representativeAnims
       };
-      writeFileSync24(
-        join57(outputDir, "extracted", "animations.json"),
+      writeFileSync26(
+        join59(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
       );
@@ -84277,18 +84418,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");
+      writeFileSync26(join59(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     if (catalogedAssets.length > 0) {
-      writeFileSync24(
-        join57(outputDir, "extracted", "assets-catalog.json"),
+      writeFileSync26(
+        join59(outputDir, "extracted", "assets-catalog.json"),
         JSON.stringify(catalogedAssets, null, 2),
         "utf-8"
       );
     }
     if (detectedLibraries.length > 0) {
-      writeFileSync24(
-        join57(outputDir, "extracted", "detected-libraries.json"),
+      writeFileSync26(
+        join59(outputDir, "extracted", "detected-libraries.json"),
         JSON.stringify(detectedLibraries, null, 2),
         "utf-8"
       );
@@ -84298,8 +84439,8 @@ async function captureWebsite(opts, onProgress) {
     try {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
-        writeFileSync24(
-          join57(outputDir, "extracted", "asset-descriptions.md"),
+        writeFileSync26(
+          join59(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"
         );
@@ -84315,7 +84456,7 @@ async function captureWebsite(opts, onProgress) {
       animationCatalog,
       screenshots.length > 0,
       discoveredLotties.length > 0,
-      existsSync52(join57(outputDir, "extracted", "shaders.json")),
+      existsSync54(join59(outputDir, "extracted", "shaders.json")),
       catalogedAssets,
       progress,
       warnings,
@@ -84494,11 +84635,11 @@ var init_capture2 = __esm({
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           try {
-            const { mkdirSync: mkdirSync31, writeFileSync: writeFileSync25 } = await import("fs");
-            mkdirSync31(outputDir, { recursive: true });
+            const { mkdirSync: mkdirSync33, writeFileSync: writeFileSync27 } = await import("fs");
+            mkdirSync33(outputDir, { recursive: true });
             const isTimeout = /timeout|timed out/i.test(errMsg);
             const reason = isTimeout ? "Page navigation timed out \u2014 the site may be blocking headless browsers or requires authentication." : `Capture failed: ${errMsg}`;
-            writeFileSync25(
+            writeFileSync27(
               `${outputDir}/BLOCKED.md`,
               `# Capture Failed
 
@@ -84661,10 +84802,10 @@ __export(autoUpdate_exports, {
   reportCompletedUpdate: () => reportCompletedUpdate,
   scheduleBackgroundInstall: () => scheduleBackgroundInstall
 });
-import { spawn as spawn12 } from "child_process";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync30, openSync } from "fs";
+import { spawn as spawn13 } from "child_process";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync32, openSync } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join58 } from "path";
+import { join as join60 } from "path";
 import { compareVersions as compareVersions2 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -84679,15 +84820,15 @@ function majorOf(version) {
 }
 function log(line) {
   try {
-    mkdirSync30(CONFIG_DIR2, { recursive: true, mode: 448 });
+    mkdirSync32(CONFIG_DIR2, { recursive: true, mode: 448 });
     appendFileSync2(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `, { mode: 384 });
   } catch {
   }
 }
 function launchDetachedInstall(installCommand, version) {
-  mkdirSync30(CONFIG_DIR2, { recursive: true, mode: 448 });
-  const configFile = join58(CONFIG_DIR2, "config.json");
+  mkdirSync32(CONFIG_DIR2, { recursive: true, mode: 448 });
+  const configFile = join60(CONFIG_DIR2, "config.json");
   const nodeScript = `
     const { exec } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -84712,7 +84853,7 @@ function launchDetachedInstall(installCommand, version) {
     });
   `;
   const out = openSync(LOG_FILE, "a", 384);
-  const child = spawn12(process.execPath, ["-e", nodeScript], {
+  const child = spawn13(process.execPath, ["-e", nodeScript], {
     detached: true,
     stdio: ["ignore", out, out],
     windowsHide: true,
@@ -84806,8 +84947,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 = join60(homedir10(), ".hyperframes");
+    LOG_FILE = join60(CONFIG_DIR2, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });