hyperframes 0.1.10 → 0.1.11

package/dist/cli.js

@@ -422,7 +422,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.1.10" : "0.0.0-dev";
+    VERSION = true ? "0.1.11" : "0.0.0-dev";
   }
 });
 
@@ -600,13 +600,6 @@ var init_env = __esm({
 });
 
 // src/telemetry/system.ts
-var system_exports = {};
-__export(system_exports, {
-  bytesToMb: () => bytesToMb,
-  getFreeDiskMb: () => getFreeDiskMb,
-  getShmSizeMb: () => getShmSizeMb,
-  getSystemMeta: () => getSystemMeta
-});
 import { cpus, totalmem, platform, release } from "os";
 import { existsSync as existsSync2, readFileSync as readFileSync2, statfsSync } from "fs";
 function bytesToMb(bytes) {
@@ -825,14 +818,6 @@ var init_client = __esm({
 });
 
 // src/telemetry/events.ts
-var events_exports = {};
-__export(events_exports, {
-  trackBrowserInstall: () => trackBrowserInstall,
-  trackCommand: () => trackCommand,
-  trackInitTemplate: () => trackInitTemplate,
-  trackRenderComplete: () => trackRenderComplete,
-  trackRenderError: () => trackRenderError
-});
 function trackCommand(command2) {
   trackEvent("cli_command", { command: command2 });
 }
@@ -2697,7 +2682,7 @@ import { join as join2 } from "path";
 import { get as httpsGet } from "https";
 import { pipeline } from "stream/promises";
 function downloadFile(url, dest) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve20, reject) => {
     const follow = (u) => {
       httpsGet(u, (res) => {
         if (res.statusCode === 301 || res.statusCode === 302) {
@@ -2712,7 +2697,7 @@ function downloadFile(url, dest) {
           return;
         }
         const file = createWriteStream(dest);
-        pipeline(res, file).then(resolve17).catch(reject);
+        pipeline(res, file).then(resolve20).catch(reject);
       }).on("error", reject);
     };
     follow(url);
@@ -3201,6 +3186,553 @@ var init_fileWatcher = __esm({
   }
 });
 
+// ../core/src/studio-api/helpers/safePath.ts
+import { resolve, sep, join as join4 } from "path";
+import { readdirSync as readdirSync2 } from "fs";
+function isSafePath(base, resolved) {
+  const norm = resolve(base) + sep;
+  return resolved.startsWith(norm) || resolved === resolve(base);
+}
+function walkDir(dir, prefix = "") {
+  const files = [];
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...walkDir(join4(dir, entry.name), rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+var IGNORE_DIRS;
+var init_safePath = __esm({
+  "../core/src/studio-api/helpers/safePath.ts"() {
+    "use strict";
+    IGNORE_DIRS = /* @__PURE__ */ new Set([".thumbnails", "node_modules", ".git"]);
+  }
+});
+
+// ../core/src/studio-api/routes/projects.ts
+function registerProjectRoutes(api, adapter2) {
+  api.get("/projects", async (c2) => {
+    const projects = await adapter2.listProjects();
+    return c2.json({ projects });
+  });
+  api.get("/resolve-session/:sessionId", async (c2) => {
+    if (!adapter2.resolveSession) {
+      return c2.json({ error: "not available" }, 404);
+    }
+    const { sessionId } = c2.req.param();
+    const result = await adapter2.resolveSession(sessionId);
+    if (!result) return c2.json({ error: "Session not found" }, 404);
+    return c2.json(result);
+  });
+  api.get("/projects/:id", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const files = walkDir(project.dir);
+    return c2.json({ id: project.id, files });
+  });
+}
+var init_projects = __esm({
+  "../core/src/studio-api/routes/projects.ts"() {
+    "use strict";
+    init_safePath();
+  }
+});
+
+// ../core/src/studio-api/routes/files.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+function registerFileRoutes(api, adapter2) {
+  api.get("/projects/:id/files/*", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const filePath = decodeURIComponent(c2.req.path.replace(`/projects/${project.id}/files/`, ""));
+    const file = resolve2(project.dir, filePath);
+    if (!isSafePath(project.dir, file) || !existsSync5(file)) {
+      return c2.text("not found", 404);
+    }
+    const content = readFileSync3(file, "utf-8");
+    return c2.json({ filename: filePath, content });
+  });
+  api.put("/projects/:id/files/*", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const filePath = decodeURIComponent(c2.req.path.replace(`/projects/${project.id}/files/`, ""));
+    const file = resolve2(project.dir, filePath);
+    if (!isSafePath(project.dir, file)) {
+      return c2.json({ error: "forbidden" }, 403);
+    }
+    const dir = dirname2(file);
+    if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
+    const body = await c2.req.text();
+    writeFileSync2(file, body, "utf-8");
+    return c2.json({ ok: true });
+  });
+}
+var init_files = __esm({
+  "../core/src/studio-api/routes/files.ts"() {
+    "use strict";
+    init_safePath();
+  }
+});
+
+// ../core/src/studio-api/helpers/mime.ts
+function getMimeType(path) {
+  const ext = path.slice(path.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+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",
+      ".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 existsSync6, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref) {
+  const compFile = join5(projectDir, compPath);
+  if (!existsSync6(compFile)) return null;
+  const rawComp = readFileSync4(compFile, "utf-8");
+  const templateMatch = rawComp.match(/<template[^>]*>([\s\S]*)<\/template>/i);
+  const content = templateMatch?.[1] ?? rawComp;
+  const indexPath = join5(projectDir, "index.html");
+  let headContent = "";
+  if (existsSync6(indexPath)) {
+    const indexHtml = readFileSync4(indexPath, "utf-8");
+    const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    headContent = headMatch?.[1] ?? "";
+  }
+  if (baseHref && !headContent.includes("<base")) {
+    headContent = `<base href="${baseHref}">
+${headContent}`;
+  }
+  if (!headContent.includes("hyperframe.runtime") && !headContent.includes("hyperframes-preview-runtime")) {
+    headContent += `
+<script data-hyperframes-preview-runtime="1" src="${runtimeUrl}"></script>`;
+  }
+  if (!headContent.includes("gsap")) {
+    headContent += `
+<script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js"></script>`;
+  }
+  return `<!DOCTYPE html>
+<html>
+<head>
+${headContent}
+</head>
+<body>
+<script>window.__timelines=window.__timelines||{};</script>
+${content}
+</body>
+</html>`;
+}
+var init_subComposition = __esm({
+  "../core/src/studio-api/helpers/subComposition.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/studio-api/routes/preview.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, statSync } from "fs";
+import { resolve as resolve3 } from "path";
+function registerPreviewRoutes(api, adapter2) {
+  api.get("/projects/:id/preview", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    try {
+      let bundled = await adapter2.bundle(project.dir);
+      if (!bundled) {
+        const indexPath = resolve3(project.dir, "index.html");
+        if (!existsSync7(indexPath)) return c2.text("not found", 404);
+        bundled = readFileSync5(indexPath, "utf-8");
+      }
+      if (!bundled.includes("hyperframe.runtime") && !bundled.includes("hyperframes-preview-runtime")) {
+        const runtimeTag = `<script src="${adapter2.runtimeUrl}"></script>`;
+        bundled = bundled.includes("</body>") ? bundled.replace("</body>", `${runtimeTag}
+</body>`) : bundled + `
+${runtimeTag}`;
+      }
+      const baseHref = `/api/projects/${project.id}/preview/`;
+      if (!bundled.includes("<base")) {
+        bundled = bundled.replace(/<head>/i, `<head><base href="${baseHref}">`);
+      }
+      return c2.html(bundled);
+    } catch {
+      const file = resolve3(project.dir, "index.html");
+      if (existsSync7(file)) return c2.html(readFileSync5(file, "utf-8"));
+      return c2.text("not found", 404);
+    }
+  });
+  api.get("/projects/:id/preview/comp/*", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const compPath = decodeURIComponent(
+      c2.req.path.replace(`/projects/${project.id}/preview/comp/`, "").split("?")[0] ?? ""
+    );
+    const compFile = resolve3(project.dir, compPath);
+    if (!isSafePath(project.dir, compFile) || !existsSync7(compFile) || !statSync(compFile).isFile()) {
+      return c2.text("not found", 404);
+    }
+    const baseHref = `/api/projects/${project.id}/preview/`;
+    const html = buildSubCompositionHtml(project.dir, compPath, adapter2.runtimeUrl, baseHref);
+    if (!html) return c2.text("not found", 404);
+    return c2.html(html);
+  });
+  api.get("/projects/:id/preview/*", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const subPath = decodeURIComponent(
+      c2.req.path.replace(`/projects/${project.id}/preview/`, "").split("?")[0] ?? ""
+    );
+    const file = resolve3(project.dir, subPath);
+    if (!isSafePath(project.dir, file) || !existsSync7(file) || !statSync(file).isFile()) {
+      return c2.text("not found", 404);
+    }
+    const contentType = getMimeType(subPath);
+    const isText2 = /\.(html|css|js|json|svg|txt|md)$/i.test(subPath);
+    const content = readFileSync5(file, isText2 ? "utf-8" : void 0);
+    return new Response(content, {
+      headers: { "Content-Type": contentType }
+    });
+  });
+}
+var init_preview = __esm({
+  "../core/src/studio-api/routes/preview.ts"() {
+    "use strict";
+    init_safePath();
+    init_mime();
+    init_subComposition();
+  }
+});
+
+// ../core/src/studio-api/routes/lint.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+function registerLintRoutes(api, adapter2) {
+  api.get("/projects/:id/lint", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    try {
+      const htmlFiles = walkDir(project.dir).filter((f) => f.endsWith(".html"));
+      const allFindings = [];
+      for (const file of htmlFiles) {
+        const content = readFileSync6(join6(project.dir, file), "utf-8");
+        const result = await adapter2.lint(content, { filePath: file });
+        if (result?.findings) {
+          for (const f of result.findings) {
+            allFindings.push({ ...f, file });
+          }
+        }
+      }
+      return c2.json({ findings: allFindings });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c2.json({ error: `Lint failed: ${msg}` }, 500);
+    }
+  });
+}
+var init_lint = __esm({
+  "../core/src/studio-api/routes/lint.ts"() {
+    "use strict";
+    init_safePath();
+  }
+});
+
+// ../core/src/studio-api/routes/render.ts
+import { streamSSE } from "hono/streaming";
+import { existsSync as existsSync8, readFileSync as readFileSync7, mkdirSync as mkdirSync5, unlinkSync, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
+function registerRenderRoutes(api, adapter2) {
+  const renderJobs = /* @__PURE__ */ new Map();
+  const TTL_MS = 3e5;
+  const CLEANUP_INTERVAL_MS = 6e4;
+  let cleanupTimer = null;
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "production" && !process.argv.includes("build")) {
+    cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [key2, job] of renderJobs) {
+        if ((job.status === "complete" || job.status === "failed") && now - job.createdAt > TTL_MS) {
+          renderJobs.delete(key2);
+        }
+      }
+      if (renderJobs.size === 0 && cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+      }
+    }, CLEANUP_INTERVAL_MS);
+    if (cleanupTimer && typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+      cleanupTimer.unref();
+    }
+  }
+  api.post("/projects/:id/render", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const body = await c2.req.json().catch(() => ({}));
+    const format = body.format === "webm" ? "webm" : "mp4";
+    const fps = body.fps === 24 || body.fps === 60 ? body.fps : 30;
+    const quality = ["draft", "standard", "high"].includes(body.quality ?? "") ? body.quality : "standard";
+    const now = /* @__PURE__ */ new Date();
+    const datePart = now.toISOString().slice(0, 10);
+    const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
+    const jobId = `${project.id}_${datePart}_${timePart}`;
+    const rendersDir = adapter2.rendersDir(project);
+    if (!existsSync8(rendersDir)) mkdirSync5(rendersDir, { recursive: true });
+    const ext = format === "webm" ? ".webm" : ".mp4";
+    const outputPath = join7(rendersDir, `${jobId}${ext}`);
+    const jobState = adapter2.startRender({
+      project,
+      outputPath,
+      format,
+      fps,
+      quality,
+      jobId
+    });
+    renderJobs.set(jobId, { ...jobState, createdAt: Date.now() });
+    if (!cleanupTimer && typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+      cleanupTimer = setInterval(() => {
+        const now2 = Date.now();
+        for (const [key2, job] of renderJobs) {
+          if ((job.status === "complete" || job.status === "failed") && now2 - job.createdAt > TTL_MS) {
+            renderJobs.delete(key2);
+          }
+        }
+        if (renderJobs.size === 0 && cleanupTimer) {
+          clearInterval(cleanupTimer);
+          cleanupTimer = null;
+        }
+      }, CLEANUP_INTERVAL_MS);
+      if (cleanupTimer && typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+        cleanupTimer.unref();
+      }
+    }
+    return c2.json({ jobId, status: "rendering" });
+  });
+  api.get("/render/:jobId/progress", (c2) => {
+    const { jobId } = c2.req.param();
+    const job = renderJobs.get(jobId);
+    if (!job) return c2.json({ error: "not found" }, 404);
+    return streamSSE(c2, async (stream) => {
+      while (true) {
+        const current = renderJobs.get(jobId);
+        if (!current) break;
+        await stream.writeSSE({
+          event: "progress",
+          data: JSON.stringify({
+            progress: current.progress,
+            status: current.status,
+            stage: current.stage,
+            error: current.error
+          })
+        });
+        if (current.status === "complete" || current.status === "failed") break;
+        await stream.sleep(500);
+      }
+    });
+  });
+  api.get("/render/:jobId/download", (c2) => {
+    const { jobId } = c2.req.param();
+    const job = renderJobs.get(jobId);
+    if (!job?.outputPath || !existsSync8(job.outputPath)) {
+      return c2.json({ error: "not found" }, 404);
+    }
+    const isWebm = job.outputPath.endsWith(".webm");
+    const contentType = isWebm ? "video/webm" : "video/mp4";
+    const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
+    const content = readFileSync7(job.outputPath);
+    return new Response(content, {
+      headers: {
+        "Content-Type": contentType,
+        "Content-Disposition": `attachment; filename="${filename}"`
+      }
+    });
+  });
+  api.delete("/render/:jobId", (c2) => {
+    const { jobId } = c2.req.param();
+    for (const [, state] of renderJobs) {
+      if (state.id === jobId && state.outputPath) {
+        const dir = state.outputPath.replace(/\/[^/]+$/, "");
+        for (const ext of [".mp4", ".webm", ".meta.json"]) {
+          const fp = join7(dir, `${jobId}${ext}`);
+          if (existsSync8(fp)) unlinkSync(fp);
+        }
+        break;
+      }
+    }
+    renderJobs.delete(jobId);
+    return c2.json({ deleted: true });
+  });
+  api.get("/projects/:id/renders", async (c2) => {
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    const rendersDir = adapter2.rendersDir(project);
+    if (!existsSync8(rendersDir)) return c2.json({ renders: [] });
+    const files = readdirSync3(rendersDir).filter((f) => f.endsWith(".mp4") || f.endsWith(".webm")).map((f) => {
+      const fp = join7(rendersDir, f);
+      const stat = statSync2(fp);
+      const rid = f.replace(/\.(mp4|webm)$/, "");
+      const metaPath = join7(rendersDir, `${rid}.meta.json`);
+      let status = "complete";
+      let durationMs;
+      if (existsSync8(metaPath)) {
+        try {
+          const meta = JSON.parse(readFileSync7(metaPath, "utf-8"));
+          if (meta.status === "failed") status = "failed";
+          if (meta.durationMs) durationMs = meta.durationMs;
+        } catch {
+        }
+      }
+      return {
+        id: rid,
+        filename: f,
+        size: stat.size,
+        createdAt: stat.mtimeMs,
+        status,
+        durationMs
+      };
+    }).sort((a, b) => b.createdAt - a.createdAt);
+    return c2.json({ renders: files });
+  });
+}
+var init_render = __esm({
+  "../core/src/studio-api/routes/render.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/studio-api/routes/thumbnail.ts
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8 } from "path";
+function registerThumbnailRoutes(api, adapter2) {
+  api.get("/projects/:id/thumbnail/*", async (c2) => {
+    if (!adapter2.generateThumbnail) {
+      return c2.json({ error: "Thumbnails not available" }, 501);
+    }
+    const project = await adapter2.resolveProject(c2.req.param("id"));
+    if (!project) return c2.json({ error: "not found" }, 404);
+    let compPath = decodeURIComponent(
+      c2.req.path.replace(`/projects/${project.id}/thumbnail/`, "").split("?")[0] ?? ""
+    );
+    if (compPath && !compPath.includes(".")) compPath += ".html";
+    const url = new URL(c2.req.url, `http://${c2.req.header("host") || "localhost"}`);
+    const seekTime = parseFloat(url.searchParams.get("t") || "0.5") || 0.5;
+    const vpWidth = parseInt(url.searchParams.get("w") || "0") || 0;
+    const vpHeight = parseInt(url.searchParams.get("h") || "0") || 0;
+    let compW = vpWidth || 1920;
+    let compH = vpHeight || 1080;
+    if (!vpWidth) {
+      const htmlFile = join8(project.dir, compPath);
+      if (existsSync9(htmlFile)) {
+        const html = readFileSync8(htmlFile, "utf-8");
+        const wMatch = html.match(/data-width=["'](\d+)["']/);
+        const hMatch = html.match(/data-height=["'](\d+)["']/);
+        if (wMatch?.[1]) compW = parseInt(wMatch[1]);
+        if (hMatch?.[1]) compH = parseInt(hMatch[1]);
+      }
+    }
+    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 = join8(project.dir, ".thumbnails");
+    const cacheKey = `${compPath.replace(/\//g, "_")}_${seekTime.toFixed(2)}.jpg`;
+    const cachePath = join8(cacheDir, cacheKey);
+    if (existsSync9(cachePath)) {
+      return new Response(new Uint8Array(readFileSync8(cachePath)), {
+        headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
+      });
+    }
+    try {
+      const buffer = await adapter2.generateThumbnail({
+        project,
+        compPath,
+        seekTime,
+        width: compW,
+        height: compH,
+        previewUrl
+      });
+      if (!buffer) {
+        return c2.json({ error: "Thumbnail generation returned null" }, 500);
+      }
+      if (!existsSync9(cacheDir)) mkdirSync6(cacheDir, { recursive: true });
+      writeFileSync3(cachePath, buffer);
+      return new Response(new Uint8Array(buffer), {
+        headers: { "Content-Type": "image/jpeg", "Cache-Control": "public, max-age=60" }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c2.json({ error: `Thumbnail generation failed: ${msg}` }, 500);
+    }
+  });
+}
+var init_thumbnail = __esm({
+  "../core/src/studio-api/routes/thumbnail.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/studio-api/createStudioApi.ts
+import { Hono } from "hono";
+function createStudioApi(adapter2) {
+  const api = new Hono();
+  registerProjectRoutes(api, adapter2);
+  registerFileRoutes(api, adapter2);
+  registerPreviewRoutes(api, adapter2);
+  registerLintRoutes(api, adapter2);
+  registerRenderRoutes(api, adapter2);
+  registerThumbnailRoutes(api, adapter2);
+  return api;
+}
+var init_createStudioApi = __esm({
+  "../core/src/studio-api/createStudioApi.ts"() {
+    "use strict";
+    init_projects();
+    init_files();
+    init_preview();
+    init_lint();
+    init_render();
+    init_thumbnail();
+  }
+});
+
+// ../core/src/studio-api/index.ts
+var init_studio_api = __esm({
+  "../core/src/studio-api/index.ts"() {
+    "use strict";
+    init_createStudioApi();
+    init_safePath();
+    init_mime();
+    init_subComposition();
+  }
+});
+
 // ../core/src/compiler/timingCompiler.ts
 function getAttr(tag, attr) {
   const match = tag.match(new RegExp(`${attr}=["']([^"']+)["']`));
@@ -3337,9 +3869,9 @@ var init_timingCompiler = __esm({
 });
 
 // ../core/src/compiler/htmlCompiler.ts
-import { resolve } from "path";
+import { resolve as resolve4 } from "path";
 function resolveMediaSrc(src, projectDir) {
-  return src.startsWith("http://") || src.startsWith("https://") ? src : resolve(projectDir, src);
+  return src.startsWith("http://") || src.startsWith("https://") ? src : resolve4(projectDir, src);
 }
 async function compileHtml(rawHtml, projectDir, probeMediaDuration) {
   const { html: staticCompiled, unresolved } = compileTimingAttrs(rawHtml);
@@ -3585,7 +4117,9 @@ var init_gsapParser = __esm({
 
 // ../core/src/lint/hyperframeLinter.ts
 function lintHyperframeHtml(html, options = {}) {
-  const source = html || "";
+  let source = html || "";
+  const templateMatch = source.match(/<template[^>]*>([\s\S]*)<\/template>/i);
+  if (templateMatch?.[1]) source = templateMatch[1];
   const filePath = options.filePath;
   const findings = [];
   const seen = /* @__PURE__ */ new Set();
@@ -3942,18 +4476,20 @@ ${right.raw}`)
   for (const tag of tags) {
     if (tag.name === "audio" || tag.name === "script" || tag.name === "style") continue;
     if (!readAttr(tag.raw, "data-start")) continue;
+    if (readAttr(tag.raw, "data-composition-id")) continue;
+    if (readAttr(tag.raw, "data-composition-src")) continue;
     const classAttr = readAttr(tag.raw, "class") || "";
     const styleAttr = readAttr(tag.raw, "style") || "";
     const hasClip = classAttr.split(/\s+/).includes("clip");
-    const hasHiddenStyle = /visibility\s*:\s*hidden/i.test(styleAttr);
+    const hasHiddenStyle = /visibility\s*:\s*hidden/i.test(styleAttr) || /opacity\s*:\s*0/i.test(styleAttr);
     if (!hasClip && !hasHiddenStyle) {
       const elementId = readAttr(tag.raw, "id") || void 0;
       pushFinding({
         code: "timed_element_missing_visibility_hidden",
-        severity: "warning",
-        message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> has data-start but no class="clip" or visibility:hidden. The framework needs elements to start hidden so it can manage their lifecycle.`,
+        severity: "info",
+        message: `<${tag.name}${elementId ? ` id="${elementId}"` : ""}> has data-start but no class="clip", visibility:hidden, or opacity:0. Consider adding initial hidden state if the element should not be visible before its start time.`,
         elementId,
-        fixHint: 'Add class="clip" to the element (with CSS: .clip { visibility: hidden; }).',
+        fixHint: 'Add class="clip" (with CSS: .clip { visibility: hidden; }) or style="opacity:0" if the element should start hidden.',
         snippet: truncateSnippet(tag.raw)
       });
     }
@@ -4336,6 +4872,72 @@ function truncateSnippet(value, maxLength = 220) {
   }
   return `${normalized.slice(0, maxLength - 3)}...`;
 }
+function extractMediaUrls(html) {
+  const results = [];
+  const tagRe = /<(video|audio|img|source)\b[^>]*>/gi;
+  let match;
+  while ((match = tagRe.exec(html)) !== null) {
+    const tagName19 = (match[1] ?? "").toLowerCase();
+    const raw = match[0];
+    const src = readAttr(raw, "src");
+    if (!src) continue;
+    if (/^https?:\/\//i.test(src)) {
+      results.push({
+        url: src,
+        tagName: tagName19,
+        elementId: readAttr(raw, "id") || void 0,
+        snippet: raw.length > 120 ? raw.slice(0, 117) + "..." : raw
+      });
+    }
+  }
+  return results;
+}
+async function lintMediaUrls(html, options = {}) {
+  const urls = extractMediaUrls(html);
+  if (urls.length === 0) return [];
+  const timeout = options.timeoutMs ?? 8e3;
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unique = urls.filter((u) => {
+    if (seen.has(u.url)) return false;
+    seen.add(u.url);
+    return true;
+  });
+  const checks = unique.map(async ({ url, tagName: tagName19, elementId, snippet }) => {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const resp = await fetch(url, {
+        method: "HEAD",
+        signal: controller.signal,
+        redirect: "follow"
+      });
+      clearTimeout(timer);
+      if (!resp.ok) {
+        findings.push({
+          code: "inaccessible_media_url",
+          severity: "error",
+          message: `<${tagName19}${elementId ? ` id="${elementId}"` : ""}> references a URL that returned HTTP ${resp.status}: ${url.slice(0, 100)}`,
+          elementId,
+          fixHint: "This URL is not accessible. Replace with a valid, reachable media URL.",
+          snippet
+        });
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.name : "unknown";
+      findings.push({
+        code: "inaccessible_media_url",
+        severity: "error",
+        message: `<${tagName19}${elementId ? ` id="${elementId}"` : ""}> references an unreachable URL (${reason}): ${url.slice(0, 100)}`,
+        elementId,
+        fixHint: "This URL is not accessible. Replace with a valid, reachable media URL.",
+        snippet
+      });
+    }
+  });
+  await Promise.all(checks);
+  return findings;
+}
 var TAG_PATTERN, STYLE_BLOCK_PATTERN, SCRIPT_BLOCK_PATTERN, COMPOSITION_ID_IN_CSS_PATTERN, TIMELINE_REGISTRY_INIT_PATTERN, TIMELINE_REGISTRY_ASSIGN_PATTERN, INVALID_SCRIPT_CLOSE_PATTERN, WINDOW_TIMELINE_ASSIGN_PATTERN, META_GSAP_KEYS;
 var init_hyperframeLinter = __esm({
   "../core/src/lint/hyperframeLinter.ts"() {
@@ -4381,14 +4983,14 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
-import { join as join4, resolve as resolve2, isAbsolute, sep } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+import { join as join9, resolve as resolve5, isAbsolute, sep as sep2 } from "path";
 import * as cheerio from "cheerio";
 import { transformSync } from "esbuild";
 function safePath(projectDir, relativePath) {
-  const resolved = resolve2(projectDir, relativePath);
-  const normalizedBase = resolve2(projectDir) + sep;
-  if (!resolved.startsWith(normalizedBase) && resolved !== resolve2(projectDir)) return null;
+  const resolved = resolve5(projectDir, relativePath);
+  const normalizedBase = resolve5(projectDir) + sep2;
+  if (!resolved.startsWith(normalizedBase) && resolved !== resolve5(projectDir)) return null;
   return resolved;
 }
 function stripEmbeddedRuntimeScripts(html) {
@@ -4444,17 +5046,17 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync5(filePath)) return null;
+  if (!existsSync10(filePath)) return null;
   try {
-    return readFileSync3(filePath, "utf-8");
+    return readFileSync9(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync5(filePath)) return null;
+  if (!existsSync10(filePath)) return null;
   try {
-    return readFileSync3(filePath);
+    return readFileSync9(filePath);
   } catch {
     return null;
   }
@@ -4641,9 +5243,9 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join4(projectDir, "index.html");
-  if (!existsSync5(indexPath)) throw new Error("index.html not found in project directory");
-  const rawHtml = readFileSync3(indexPath, "utf-8");
+  const indexPath = join9(projectDir, "index.html");
+  if (!existsSync10(indexPath)) throw new Error("index.html not found in project directory");
+  const rawHtml = readFileSync9(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
   if (!staticGuard.isValid) {
@@ -4798,6 +5400,19 @@ var init_compiler = __esm({
   }
 });
 
+// ../core/src/lint/index.ts
+var lint_exports = {};
+__export(lint_exports, {
+  lintHyperframeHtml: () => lintHyperframeHtml,
+  lintMediaUrls: () => lintMediaUrls
+});
+var init_lint2 = __esm({
+  "../core/src/lint/index.ts"() {
+    "use strict";
+    init_hyperframeLinter();
+  }
+});
+
 // ../../node_modules/.bun/linkedom@0.18.12/node_modules/linkedom/esm/shared/symbols.js
 var CHANGED, CLASS_LIST, CUSTOM_ELEMENTS, CONTENT, DATASET, DOCTYPE, DOM_PARSER, END, EVENT_TARGET, GLOBALS, IMAGE, MIME, MUTATION_OBSERVER, NEXT, OWNER_ELEMENT, PREV, PRIVATE, SHEET, START, STYLE, UPGRADE, VALUE;
 var init_symbols = __esm({
@@ -8652,8 +9267,8 @@ var init_custom_element_registry = __esm({
         } : (element) => element.localName === localName;
         registry.set(localName, { Class, check });
         if (waiting.has(localName)) {
-          for (const resolve17 of waiting.get(localName))
-            resolve17(Class);
+          for (const resolve20 of waiting.get(localName))
+            resolve20(Class);
           waiting.delete(localName);
         }
         ownerDocument.querySelectorAll(
@@ -8693,13 +9308,13 @@ var init_custom_element_registry = __esm({
        */
       whenDefined(localName) {
         const { registry, waiting } = this;
-        return new Promise((resolve17) => {
+        return new Promise((resolve20) => {
           if (registry.has(localName))
-            resolve17(registry.get(localName).Class);
+            resolve20(registry.get(localName).Class);
           else {
             if (!waiting.has(localName))
               waiting.set(localName, []);
-            waiting.get(localName).push(resolve17);
+            waiting.get(localName).push(resolve20);
           }
         });
       }
@@ -16636,7 +17251,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 };
@@ -16901,7 +17516,7 @@ var init_document = __esm({
     init_symbols();
     init_facades();
     init_html_classes();
-    init_mime();
+    init_mime2();
     init_utils();
     init_object();
     init_non_element_parent_node();
@@ -17507,8 +18122,8 @@ var init_config2 = __esm({
 });
 
 // ../engine/src/services/browserManager.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir4 } from "os";
 async function getPuppeteer() {
   if (_puppeteer) return _puppeteer;
@@ -17529,19 +18144,19 @@ function resolveHeadlessShellPath(config) {
   if (process.env.PRODUCER_HEADLESS_SHELL_PATH) {
     return process.env.PRODUCER_HEADLESS_SHELL_PATH;
   }
-  const baseDir = join5(homedir4(), ".cache", "puppeteer", "chrome-headless-shell");
-  if (!existsSync6(baseDir)) return void 0;
+  const baseDir = join10(homedir4(), ".cache", "puppeteer", "chrome-headless-shell");
+  if (!existsSync11(baseDir)) return void 0;
   try {
-    const versions = readdirSync2(baseDir).sort().reverse();
+    const versions = readdirSync4(baseDir).sort().reverse();
     for (const version of versions) {
       const candidates = [
-        join5(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
-        join5(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
-        join5(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
-        join5(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
+        join10(baseDir, version, "chrome-headless-shell-linux64", "chrome-headless-shell"),
+        join10(baseDir, version, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"),
+        join10(baseDir, version, "chrome-headless-shell-mac-x64", "chrome-headless-shell"),
+        join10(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
       ];
       for (const binary of candidates) {
-        if (existsSync6(binary)) return binary;
+        if (existsSync11(binary)) return binary;
       }
     }
   } catch {
@@ -18115,7 +18730,7 @@ var init_hyperframes = __esm({
 
 // ../core/src/inline-scripts/hyperframesRuntime.engine.ts
 import { buildSync } from "esbuild";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { dirname as dirname3, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
 var init_hyperframesRuntime_engine = __esm({
   "../core/src/inline-scripts/hyperframesRuntime.engine.ts"() {
@@ -18372,10 +18987,10 @@ var init_screenshotService = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync7(outputDir)) mkdirSync4(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -18534,13 +19149,13 @@ async function initializeSession(session) {
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
   try {
-    const diagnosticsDir = join6(session.outputDir, "diagnostics");
-    if (!existsSync7(diagnosticsDir)) mkdirSync4(diagnosticsDir, { recursive: true });
-    const base = join6(diagnosticsDir, `frame-error-${frameIndex}`);
+    const diagnosticsDir = join11(session.outputDir, "diagnostics");
+    if (!existsSync12(diagnosticsDir)) mkdirSync7(diagnosticsDir, { recursive: true });
+    const base = join11(diagnosticsDir, `frame-error-${frameIndex}`);
     await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
     const html = await session.page.content();
-    writeFileSync2(`${base}.html`, html, "utf-8");
-    writeFileSync2(
+    writeFileSync4(`${base}.html`, html, "utf-8");
+    writeFileSync4(
       `${base}.json`,
       JSON.stringify(
         {
@@ -18634,8 +19249,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 = join6(outputDir, frameName);
-  writeFileSync2(framePath, buffer);
+  const framePath = join11(outputDir, frameName);
+  writeFileSync4(framePath, buffer);
   return { frameIndex, time: quantizedTime, path: framePath, captureTimeMs };
 }
 async function captureFrameToBuffer(session, frameIndex, time) {
@@ -18649,8 +19264,8 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync7(outputDir)) {
-    mkdirSync4(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) {
+    mkdirSync7(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
   session.onBeforeCapture = onBeforeCapture;
@@ -18695,7 +19310,7 @@ var init_frameCapture = __esm({
 // ../engine/src/utils/gpuEncoder.ts
 import { spawn } from "child_process";
 async function detectGpuEncoder() {
-  return new Promise((resolve17) => {
+  return new Promise((resolve20) => {
     const ffmpeg = spawn("ffmpeg", ["-encoders"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -18704,13 +19319,13 @@ async function detectGpuEncoder() {
       stdout2 += data.toString();
     });
     ffmpeg.on("close", () => {
-      if (stdout2.includes("h264_nvenc")) resolve17("nvenc");
-      else if (stdout2.includes("h264_videotoolbox")) resolve17("videotoolbox");
-      else if (stdout2.includes("h264_vaapi")) resolve17("vaapi");
-      else if (stdout2.includes("h264_qsv")) resolve17("qsv");
-      else resolve17(null);
+      if (stdout2.includes("h264_nvenc")) resolve20("nvenc");
+      else if (stdout2.includes("h264_videotoolbox")) resolve20("videotoolbox");
+      else if (stdout2.includes("h264_vaapi")) resolve20("vaapi");
+      else if (stdout2.includes("h264_qsv")) resolve20("qsv");
+      else resolve20(null);
     });
-    ffmpeg.on("error", () => resolve17(null));
+    ffmpeg.on("error", () => resolve20(null));
   });
 }
 async function getCachedGpuEncoder() {
@@ -18749,7 +19364,7 @@ async function runFfmpeg(args, opts) {
   const signal = opts?.signal;
   const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
   const onStderr = opts?.onStderr;
-  return new Promise((resolve17) => {
+  return new Promise((resolve20) => {
     const ffmpeg = spawn2("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -18775,7 +19390,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("close", (code) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve17({
+      resolve20({
         success: !signal?.aborted && code === 0,
         exitCode: code,
         stderr,
@@ -18785,7 +19400,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve17({
+      resolve20({
         success: false,
         exitCode: null,
         stderr: err.message,
@@ -18804,8 +19419,8 @@ var init_runFfmpeg = __esm({
 
 // ../engine/src/services/chunkEncoder.ts
 import { spawn as spawn3 } from "child_process";
-import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { copyFileSync, existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync5, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12, dirname as dirname4 } from "path";
 function getEncoderPreset(quality, format = "mp4") {
   const base = ENCODER_PRESETS[quality];
   if (format === "webm") {
@@ -18886,9 +19501,9 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
 }
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config) {
   const startTime = Date.now();
-  const outputDir = dirname3(outputPath);
-  if (!existsSync8(outputDir)) mkdirSync5(outputDir, { recursive: true });
-  const files = readdirSync3(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i));
+  const outputDir = dirname4(outputPath);
+  if (!existsSync13(outputDir)) mkdirSync8(outputDir, { recursive: true });
+  const files = readdirSync5(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
     return {
@@ -18904,10 +19519,10 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
-  const inputPath = join7(framesDir, framePattern);
+  const inputPath = join12(framesDir, framePattern);
   const inputArgs = ["-framerate", String(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
-  return new Promise((resolve17) => {
+  return new Promise((resolve20) => {
     const ffmpeg = spawn3("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -18932,7 +19547,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       if (signal) signal.removeEventListener("abort", onAbort);
       const durationMs = Date.now() - startTime;
       if (signal?.aborted) {
-        resolve17({
+        resolve20({
           success: false,
           outputPath,
           durationMs,
@@ -18943,7 +19558,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       if (code !== 0) {
-        resolve17({
+        resolve20({
           success: false,
           outputPath,
           durationMs,
@@ -18953,13 +19568,13 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync8(outputPath) ? statSync(outputPath).size : 0;
-      resolve17({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
+      const fileSize = existsSync13(outputPath) ? statSync3(outputPath).size : 0;
+      resolve20({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve17({
+      resolve20({
         success: false,
         outputPath,
         durationMs: Date.now() - startTime,
@@ -18972,7 +19587,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
 }
 async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, options, chunkSizeFrames, signal) {
   const start = Date.now();
-  const files = readdirSync3(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i)).sort();
+  const files = readdirSync5(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i)).sort();
   if (files.length === 0) {
     return {
       success: false,
@@ -18985,8 +19600,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 = join7(dirname3(outputPath), "chunk-encode");
-  if (!existsSync8(chunkDir)) mkdirSync5(chunkDir, { recursive: true });
+  const chunkDir = join12(dirname4(outputPath), "chunk-encode");
+  if (!existsSync13(chunkDir)) mkdirSync8(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i = 0; i < chunkCount; i++) {
     if (signal?.aborted) {
@@ -19002,8 +19617,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     const startNumber = i * chunkSize;
     const framesInChunk = Math.min(chunkSize, files.length - startNumber);
     const ext = outputPath.endsWith(".webm") ? ".webm" : ".mp4";
-    const chunkPath = join7(chunkDir, `chunk_${String(i).padStart(4, "0")}${ext}`);
-    const inputPath = join7(framesDir, framePattern);
+    const chunkPath = join12(chunkDir, `chunk_${String(i).padStart(4, "0")}${ext}`);
+    const inputPath = join12(framesDir, framePattern);
     const inputArgs = [
       "-framerate",
       String(options.fps),
@@ -19017,18 +19632,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     let gpuEncoder = null;
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
-    const chunkResult = await new Promise((resolve17) => {
+    const chunkResult = await new Promise((resolve20) => {
       const ffmpeg = spawn3("ffmpeg", args);
       let stderr = "";
       ffmpeg.stderr.on("data", (d) => {
         stderr += d.toString();
       });
       ffmpeg.on("close", (code) => {
-        if (code === 0) resolve17({ success: true });
-        else resolve17({ success: false, error: `Chunk ${i} encode failed: ${stderr.slice(-400)}` });
+        if (code === 0) resolve20({ success: true });
+        else resolve20({ success: false, error: `Chunk ${i} encode failed: ${stderr.slice(-400)}` });
       });
       ffmpeg.on("error", (err) => {
-        resolve17({ success: false, error: `Chunk ${i} encode error: ${err.message}` });
+        resolve20({ success: false, error: `Chunk ${i} encode error: ${err.message}` });
       });
     });
     if (!chunkResult.success) {
@@ -19043,9 +19658,9 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     }
     chunkPaths.push(chunkPath);
   }
-  const concatListPath = join7(chunkDir, "concat-list.txt");
+  const concatListPath = join12(chunkDir, "concat-list.txt");
   const concatInput = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync3(concatListPath, concatInput, "utf-8");
+  writeFileSync5(concatListPath, concatInput, "utf-8");
   const concatArgs = [
     "-f",
     "concat",
@@ -19058,18 +19673,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     "-y",
     outputPath
   ];
-  const concatResult = await new Promise((resolve17) => {
+  const concatResult = await new Promise((resolve20) => {
     const ffmpeg = spawn3("ffmpeg", concatArgs);
     let stderr = "";
     ffmpeg.stderr.on("data", (d) => {
       stderr += d.toString();
     });
     ffmpeg.on("close", (code) => {
-      if (code === 0) resolve17({ success: true });
-      else resolve17({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
+      if (code === 0) resolve20({ success: true });
+      else resolve20({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
     });
     ffmpeg.on("error", (err) => {
-      resolve17({ success: false, error: `Chunk concat error: ${err.message}` });
+      resolve20({ success: false, error: `Chunk concat error: ${err.message}` });
     });
   });
   if (!concatResult.success) {
@@ -19082,7 +19697,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync8(outputPath) ? statSync(outputPath).size : 0;
+  const fileSize = existsSync13(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -19092,8 +19707,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   };
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config) {
-  const outputDir = dirname3(outputPath);
-  if (!existsSync8(outputDir)) mkdirSync5(outputDir, { recursive: true });
+  const outputDir = dirname4(outputPath);
+  if (!existsSync13(outputDir)) mkdirSync8(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
   if (isWebm) {
@@ -19160,8 +19775,8 @@ var init_chunkEncoder = __esm({
 
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, statSync as statSync2 } from "fs";
-import { dirname as dirname4 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, statSync as statSync4 } from "fs";
+import { dirname as dirname5 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let nextFrame = startFrame;
   let waiters = [];
@@ -19174,16 +19789,16 @@ function createFrameReorderBuffer(startFrame, endFrame) {
     }
   };
   return {
-    waitForFrame: (frame) => new Promise((resolve17) => {
-      waiters.push({ frame, resolve: resolve17 });
+    waitForFrame: (frame) => new Promise((resolve20) => {
+      waiters.push({ frame, resolve: resolve20 });
       resolveWaiters();
     }),
     advanceTo: (frame) => {
       nextFrame = frame;
       resolveWaiters();
     },
-    waitForAllDone: () => new Promise((resolve17) => {
-      waiters.push({ frame: endFrame, resolve: resolve17 });
+    waitForAllDone: () => new Promise((resolve20) => {
+      waiters.push({ frame: endFrame, resolve: resolve20 });
       resolveWaiters();
     })
   };
@@ -19268,8 +19883,8 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
   return args;
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
-  const outputDir = dirname4(outputPath);
-  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  const outputDir = dirname5(outputPath);
+  if (!existsSync14(outputDir)) mkdirSync9(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
@@ -19283,7 +19898,7 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
   let stderr = "";
   let exitCode = null;
   let exitPromiseResolve = null;
-  const exitPromise = new Promise((resolve17) => exitPromiseResolve = resolve17);
+  const exitPromise = new Promise((resolve20) => exitPromiseResolve = resolve20);
   ffmpeg.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
@@ -19327,8 +19942,8 @@ Process error: ${err.message}`;
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
       if (ffmpeg.stdin && !ffmpeg.stdin.destroyed) {
-        await new Promise((resolve17) => {
-          ffmpeg.stdin.end(() => resolve17());
+        await new Promise((resolve20) => {
+          ffmpeg.stdin.end(() => resolve20());
         });
       }
       await exitPromise;
@@ -19349,7 +19964,7 @@ Process error: ${err.message}`;
           error: `FFmpeg exited with code ${exitCode}`
         };
       }
-      const fileSize = existsSync9(outputPath) ? statSync2(outputPath).size : 0;
+      const fileSize = existsSync14(outputPath) ? statSync4(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -19381,7 +19996,7 @@ async function extractVideoMetadata(filePath) {
   if (cached2) {
     return cached2;
   }
-  const probePromise = new Promise((resolve17, reject) => {
+  const probePromise = new Promise((resolve20, reject) => {
     const args = [
       "-v",
       "quiet",
@@ -19423,7 +20038,7 @@ async function extractVideoMetadata(filePath) {
           videoCodec: videoStream.codec_name || "unknown",
           hasAudio
         };
-        resolve17(metadata);
+        resolve20(metadata);
       } catch (parseError) {
         reject(
           new Error(
@@ -19453,7 +20068,7 @@ async function extractAudioMetadata(filePath) {
   if (cached2) {
     return cached2;
   }
-  const probePromise = new Promise((resolve17, reject) => {
+  const probePromise = new Promise((resolve20, reject) => {
     const args = [
       "-v",
       "quiet",
@@ -19492,7 +20107,7 @@ async function extractAudioMetadata(filePath) {
           audioCodec: audioStream.codec_name || "unknown",
           bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0
         };
-        resolve17(metadata);
+        resolve20(metadata);
       } catch (parseError) {
         reject(
           new Error(
@@ -19527,9 +20142,9 @@ var init_ffprobe = __esm({
 });
 
 // ../engine/src/utils/urlDownloader.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { createWriteStream as createWriteStream2, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
 import { createHash } from "crypto";
-import { join as join8, extname } from "path";
+import { join as join13, extname } from "path";
 import { Readable } from "stream";
 import { finished } from "stream/promises";
 function getFilenameFromUrl(url) {
@@ -19540,19 +20155,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync10(cachedPath)) {
+  if (cachedPath && existsSync15(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync10(destDir)) {
-    mkdirSync7(destDir, { recursive: true });
+  if (!existsSync15(destDir)) {
+    mkdirSync10(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join8(destDir, filename);
-  if (existsSync10(localPath)) {
+  const localPath = join13(destDir, filename);
+  if (existsSync15(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -19600,8 +20215,8 @@ var init_urlDownloader = __esm({
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync4, rmSync as rmSync3 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
+import { join as join14 } from "path";
 function parseVideoElements(html) {
   const videos = [];
   const { document: document2 } = parseHTML(html);
@@ -19628,11 +20243,11 @@ function parseVideoElements(html) {
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const { fps, outputDir, quality = 95, format = "jpg" } = options;
-  const videoOutputDir = join9(outputDir, videoId);
-  if (!existsSync11(videoOutputDir)) mkdirSync8(videoOutputDir, { recursive: true });
+  const videoOutputDir = join14(outputDir, videoId);
+  if (!existsSync16(videoOutputDir)) mkdirSync11(videoOutputDir, { recursive: true });
   const metadata = await extractVideoMetadata(videoPath);
   const framePattern = `frame_%05d.${format}`;
-  const outputPattern = join9(videoOutputDir, framePattern);
+  const outputPattern = join14(videoOutputDir, framePattern);
   const args = [
     "-ss",
     String(startTime),
@@ -19647,7 +20262,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   ];
   if (format === "png") args.push("-compression_level", "6");
   args.push("-y", outputPattern);
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve20, reject) => {
     const ffmpeg = spawn6("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -19678,11 +20293,11 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
         return;
       }
       const framePaths = /* @__PURE__ */ new Map();
-      const files = readdirSync4(videoOutputDir).filter((f) => f.startsWith("frame_") && f.endsWith(`.${format}`)).sort();
+      const files = readdirSync6(videoOutputDir).filter((f) => f.startsWith("frame_") && f.endsWith(`.${format}`)).sort();
       files.forEach((file, index) => {
-        framePaths.set(index, join9(videoOutputDir, file));
+        framePaths.set(index, join14(videoOutputDir, file));
       });
-      resolve17({
+      resolve20({
         videoId,
         srcPath: videoPath,
         outputDir: videoOutputDir,
@@ -19717,14 +20332,14 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config) {
       try {
         let videoPath = video.src;
         if (!videoPath.startsWith("/") && !isHttpUrl(videoPath)) {
-          videoPath = join9(baseDir, videoPath);
+          videoPath = join14(baseDir, videoPath);
         }
         if (isHttpUrl(videoPath)) {
-          const downloadDir = join9(options.outputDir, "_downloads");
-          mkdirSync8(downloadDir, { recursive: true });
+          const downloadDir = join14(options.outputDir, "_downloads");
+          mkdirSync11(downloadDir, { recursive: true });
           videoPath = await downloadToTemp(videoPath, downloadDir);
         }
-        if (!existsSync11(videoPath)) {
+        if (!existsSync16(videoPath)) {
           return { error: { videoId: video.id, error: `Video file not found: ${videoPath}` } };
         }
         let videoDuration = video.end - video.start;
@@ -19878,7 +20493,7 @@ var init_videoFrameExtractor = __esm({
       }
       cleanup() {
         for (const video of this.videos.values()) {
-          if (existsSync11(video.extracted.outputDir)) {
+          if (existsSync16(video.extracted.outputDir)) {
             rmSync3(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -19980,8 +20595,8 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, rmSync as rmSync4 } from "fs";
-import { join as join10, dirname as dirname5 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, rmSync as rmSync4 } from "fs";
+import { join as join15, dirname as dirname6 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(html);
@@ -20031,8 +20646,8 @@ function parseAudioElements(html) {
 }
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
-  const outputDir = dirname5(outputPath);
-  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(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));
@@ -20058,8 +20673,8 @@ 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 = dirname5(outputPath);
-  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -20094,8 +20709,8 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, sign
 }
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
-  const outputDir = dirname5(outputPath);
-  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -20137,8 +20752,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       error: result2.error
     };
   }
-  const outputDir = dirname5(outputPath);
-  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i) => {
@@ -20199,7 +20814,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync12(workDir)) mkdirSync9(workDir, { recursive: true });
+  if (!existsSync17(workDir)) mkdirSync12(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -20209,7 +20824,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!srcPath.startsWith("/") && !isHttpUrl(srcPath)) {
-          srcPath = join10(baseDir, srcPath);
+          srcPath = join15(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -20221,7 +20836,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync12(srcPath)) {
+        if (!existsSync17(srcPath)) {
           errors.push(`Source not found: ${element.id}`);
           return;
         }
@@ -20232,7 +20847,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join10(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join15(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -20249,7 +20864,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join10(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join15(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -20302,9 +20917,9 @@ var init_audioMixer = __esm({
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus2, freemem, totalmem as totalmem2 } from "os";
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readdirSync as readdirSync7 } from "fs";
 import { copyFile, rename } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join16 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
   const effectiveMaxWorkers = (() => {
     const concurrency = config?.concurrency ?? DEFAULT_CONFIG2.concurrency;
@@ -20347,7 +20962,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join11(workDir, `worker-${i}`)
+      outputDir: join16(workDir, `worker-${i}`)
     });
   }
   return tasks;
@@ -20355,7 +20970,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 (!existsSync13(task.outputDir)) mkdirSync10(task.outputDir, { recursive: true });
+  if (!existsSync18(task.outputDir)) mkdirSync13(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -20445,17 +21060,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync13(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  if (!existsSync18(outputDir)) mkdirSync13(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync13(task.outputDir)) {
+    if (!existsSync18(task.outputDir)) {
       continue;
     }
-    const files = readdirSync5(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
+    const files = readdirSync7(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join11(task.outputDir, file);
-      const targetPath = join11(outputDir, file);
+      const sourcePath = join16(task.outputDir, file);
+      const targetPath = join16(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -20482,10 +21097,10 @@ var init_parallelCoordinator = __esm({
 });
 
 // ../engine/src/services/fileServer.ts
-import { Hono } from "hono";
+import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync4, existsSync as existsSync14, statSync as statSync3 } from "fs";
-import { join as join12, extname as extname2 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync19, statSync as statSync5 } from "fs";
+import { join as join17, extname as extname2 } from "path";
 var init_fileServer = __esm({
   "../engine/src/services/fileServer.ts"() {
     "use strict";
@@ -20515,8 +21130,8 @@ var init_src2 = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname6, resolve as resolve4 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname7, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
   if (process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH) {
@@ -20528,7 +21143,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync15(candidate)) {
+    if (existsSync20(candidate)) {
       return candidate;
     }
   }
@@ -20539,12 +21154,12 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync15(manifestPath)) {
+  if (!existsSync20(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync5(manifestPath, "utf8");
+  const manifestRaw = readFileSync11(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -20552,11 +21167,11 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Invalid manifest at ${manifestPath}; missing iife artifact or sha256.`
     );
   }
-  const runtimePath = resolve4(dirname6(manifestPath), runtimeFileName);
-  if (!existsSync15(runtimePath)) {
+  const runtimePath = resolve7(dirname7(manifestPath), runtimeFileName);
+  if (!existsSync20(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync5(runtimePath, "utf8");
+  const runtimeSource = readFileSync11(runtimePath, "utf8");
   const runtimeSha = createHash2("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -20575,28 +21190,28 @@ var PRODUCER_DIR, SIBLING_MANIFEST_PATH, MODULE_RELATIVE_MANIFEST_PATH, CWD_RELA
 var init_hyperframeRuntimeLoader = __esm({
   "../producer/src/services/hyperframeRuntimeLoader.ts"() {
     "use strict";
-    PRODUCER_DIR = dirname6(fileURLToPath2(import.meta.url));
-    SIBLING_MANIFEST_PATH = resolve4(PRODUCER_DIR, "hyperframe.manifest.json");
-    MODULE_RELATIVE_MANIFEST_PATH = resolve4(
+    PRODUCER_DIR = dirname7(fileURLToPath2(import.meta.url));
+    SIBLING_MANIFEST_PATH = resolve7(PRODUCER_DIR, "hyperframe.manifest.json");
+    MODULE_RELATIVE_MANIFEST_PATH = resolve7(
       PRODUCER_DIR,
       "../../../core/dist/hyperframe.manifest.json"
     );
     CWD_RELATIVE_MANIFEST_PATHS = [
       // When bundled to a single file (dist/public-server.js), the manifest
       // is copied as a sibling by build.mjs
-      resolve4(PRODUCER_DIR, "hyperframe.manifest.json"),
-      resolve4(process.cwd(), "packages/core/dist/hyperframe.manifest.json"),
-      resolve4(process.cwd(), "../core/dist/hyperframe.manifest.json"),
-      resolve4(process.cwd(), "core/dist/hyperframe.manifest.json")
+      resolve7(PRODUCER_DIR, "hyperframe.manifest.json"),
+      resolve7(process.cwd(), "packages/core/dist/hyperframe.manifest.json"),
+      resolve7(process.cwd(), "../core/dist/hyperframe.manifest.json"),
+      resolve7(process.cwd(), "core/dist/hyperframe.manifest.json")
     ];
   }
 });
 
 // ../producer/src/services/fileServer.ts
-import { Hono as Hono2 } from "hono";
+import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { readFileSync as readFileSync6, existsSync as existsSync16, statSync as statSync4 } from "fs";
-import { join as join13, extname as extname3 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync21, statSync as statSync6 } from "fs";
+import { join as join18, extname as extname3 } from "path";
 function stripEmbeddedRuntimeScripts2(html) {
   if (!html) return html;
   const scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
@@ -20660,38 +21275,38 @@ function createFileServer2(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
   const headScripts = options.headScripts ?? [getVerifiedHyperframeRuntimeSource()];
   const bodyScripts = options.bodyScripts ?? [RENDER_MODE_SCRIPT, HF_BRIDGE_SCRIPT];
-  const app = new Hono2();
+  const app = new Hono3();
   app.get("/*", (c2) => {
     let requestPath = c2.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join13(compiledDir, relativePath) : null;
+    const compiledPath = compiledDir ? join18(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync16(compiledPath) && statSync4(compiledPath).isFile()
+      compiledPath && existsSync21(compiledPath) && statSync6(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join13(projectDir, relativePath);
-    if (!existsSync16(filePath) || !statSync4(filePath).isFile()) {
+    const filePath = hasCompiledFile ? compiledPath : join18(projectDir, relativePath);
+    if (!existsSync21(filePath) || !statSync6(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname3(filePath).toLowerCase();
-    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    const contentType = MIME_TYPES2[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync6(filePath, "utf-8");
+      const rawHtml = readFileSync12(filePath, "utf-8");
       const isIndex = relativePath === "index.html";
       const html = isIndex ? injectScriptsIntoHtml(rawHtml, headScripts, bodyScripts, stripEmbeddedRuntime) : rawHtml;
       return c2.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync6(filePath);
+    const content = readFileSync12(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve17) => {
+  return new Promise((resolve20) => {
     const server = serve2({ fetch: app.fetch, port }, (info) => {
       const actualPort = info.port;
       const url = `http://localhost:${actualPort}`;
-      resolve17({
+      resolve20({
         url,
         port: actualPort,
         close: () => server.close()
@@ -20699,12 +21314,12 @@ function createFileServer2(options) {
     });
   });
 }
-var MIME_TYPES, RENDER_SEEK_MODE, RENDER_SEEK_DIAGNOSTICS, RENDER_SEEK_STEP, RENDER_SEEK_OFFSET_FRACTION, RENDER_MODE_SCRIPT, HF_BRIDGE_SCRIPT;
+var MIME_TYPES2, RENDER_SEEK_MODE, RENDER_SEEK_DIAGNOSTICS, RENDER_SEEK_STEP, RENDER_SEEK_OFFSET_FRACTION, RENDER_MODE_SCRIPT, HF_BRIDGE_SCRIPT;
 var init_fileServer2 = __esm({
   "../producer/src/services/fileServer.ts"() {
     "use strict";
     init_hyperframeRuntimeLoader();
-    MIME_TYPES = {
+    MIME_TYPES2 = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
       ".js": "application/javascript; charset=utf-8",
@@ -21133,8 +21748,8 @@ var init_deterministicFonts = __esm({
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync7, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
-import { join as join14, dirname as dirname7, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync22, mkdirSync as mkdirSync14 } from "fs";
+import { join as join19, dirname as dirname8, resolve as resolve8 } from "path";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
   for (const element of elements) {
@@ -21145,16 +21760,16 @@ function dedupeElementsById(elements) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync17(downloadDir)) mkdirSync11(downloadDir, { recursive: true });
+    if (!existsSync22(downloadDir)) mkdirSync14(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join14(baseDir, filePath);
+    filePath = join19(baseDir, filePath);
   }
-  if (!existsSync17(filePath)) {
+  if (!existsSync22(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractVideoMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -21217,14 +21832,14 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     const elEnd = elEndRaw ? parseFloat(elEndRaw) : Infinity;
     const absoluteStart = parentOffset + elStart;
     const absoluteEnd = Math.min(parentEnd, isFinite(elEnd) ? parentOffset + elEnd : Infinity);
-    const filePath = resolve5(projectDir, srcPath);
+    const filePath = resolve8(projectDir, srcPath);
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync17(filePath)) {
+    if (!existsSync22(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync7(filePath, "utf-8");
+    const rawSubHtml = readFileSync13(filePath, "utf-8");
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, absoluteStart, absoluteEnd, filePath, rawSubHtml, nestedVisited });
@@ -21233,7 +21848,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         item.rawSubHtml,
-        dirname7(item.filePath),
+        dirname8(item.filePath),
         downloadDir
       );
       const nested = await parseSubCompositions(
@@ -21417,9 +22032,9 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     if (!srcPath) continue;
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
-      const filePath = resolve5(projectDir, srcPath);
-      if (existsSync17(filePath)) {
-        compHtml = readFileSync7(filePath, "utf-8");
+      const filePath = resolve8(projectDir, srcPath);
+      if (existsSync22(filePath)) {
+        compHtml = readFileSync13(filePath, "utf-8");
       }
     }
     if (!compHtml) {
@@ -21539,7 +22154,7 @@ ${html}
 </html>`;
 }
 async function compileForRender(projectDir, htmlPath, downloadDir) {
-  const rawHtml = readFileSync7(htmlPath, "utf-8");
+  const rawHtml = readFileSync13(htmlPath, "utf-8");
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
@@ -21727,15 +22342,15 @@ var init_logger = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync15,
   rmSync as rmSync5,
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync6,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
-import { join as join15, dirname as dirname8, resolve as resolve6 } from "path";
+import { join as join20, dirname as dirname9, resolve as resolve9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -21791,13 +22406,13 @@ function installDebugLogger(logPath, log = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join15(workDir, "compiled");
-  mkdirSync12(compileDir, { recursive: true });
-  writeFileSync4(join15(compileDir, "index.html"), compiled.html, "utf-8");
+  const compileDir = join20(workDir, "compiled");
+  mkdirSync15(compileDir, { recursive: true });
+  writeFileSync6(join20(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join15(compileDir, srcPath);
-    mkdirSync12(dirname8(outPath), { recursive: true });
-    writeFileSync4(outPath, html, "utf-8");
+    const outPath = join20(compileDir, srcPath);
+    mkdirSync15(dirname9(outPath), { recursive: true });
+    writeFileSync6(outPath, html, "utf-8");
   }
   if (includeSummary) {
     const summary = {
@@ -21820,7 +22435,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       })),
       subCompositions: Array.from(compiled.subCompositions.keys())
     };
-    writeFileSync4(join15(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync6(join20(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function createRenderJob(config) {
@@ -21863,10 +22478,10 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
   return document2.toString();
 }
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
-  const moduleDir = dirname8(fileURLToPath3(import.meta.url));
-  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve6(process.env.PRODUCER_RENDERS_DIR, "..") : resolve6(moduleDir, "../..");
-  const debugDir = join15(producerRoot, ".debug");
-  const workDir = job.config.debug ? join15(debugDir, job.id) : join15(dirname8(outputPath), `work-${job.id}`);
+  const moduleDir = dirname9(fileURLToPath3(import.meta.url));
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve9(process.env.PRODUCER_RENDERS_DIR, "..") : resolve9(moduleDir, "../..");
+  const debugDir = join20(producerRoot, ".debug");
+  const workDir = job.config.debug ? join20(debugDir, job.id) : join20(dirname9(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -21874,7 +22489,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
   let lastBrowserConsole = [];
   let restoreLogger = null;
   const perfStages = {};
-  const perfOutputPath = join15(workDir, "perf-summary.json");
+  const perfOutputPath = join20(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -21892,28 +22507,28 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync18(workDir)) mkdirSync12(workDir, { recursive: true });
+    if (!existsSync23(workDir)) mkdirSync15(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join15(workDir, "render.log");
+      const logPath = join20(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join15(projectDir, entryFile);
-    if (!existsSync18(htmlPath)) {
+    let htmlPath = join20(projectDir, entryFile);
+    if (!existsSync23(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync8(htmlPath, "utf-8");
+    const rawEntry = readFileSync14(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join15(workDir, "standalone-entry.html");
-      const projectIndexPath = join15(projectDir, "index.html");
-      if (!existsSync18(projectIndexPath)) {
+      const wrapperPath = join20(workDir, "standalone-entry.html");
+      const projectIndexPath = join20(projectDir, "index.html");
+      if (!existsSync23(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync8(projectIndexPath, "utf-8"),
+        readFileSync14(projectIndexPath, "utf-8"),
         entryFile
       );
       if (!standaloneHtml) {
@@ -21921,7 +22536,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.`
         );
       }
-      writeFileSync4(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync6(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -21930,7 +22545,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, join15(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join20(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     writeCompiledArtifacts(compiled, workDir, Boolean(job.config.debug));
@@ -21959,7 +22574,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join15(workDir, "compiled"),
+        compiledDir: join20(workDir, "compiled"),
         port: 0
       });
       assertNotAborted();
@@ -21972,7 +22587,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join15(workDir, "probe"),
+        join20(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -22004,7 +22619,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join15(workDir, "downloads")
+            join20(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -22101,7 +22716,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       const extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join15(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join20(workDir, "video-frames") },
         abortSignal
       );
       assertNotAborted();
@@ -22133,13 +22748,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join15(workDir, "audio.aac");
+    const audioOutputPath = join20(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join15(workDir, "audio-work"),
+        join20(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal
@@ -22155,13 +22770,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join15(workDir, "compiled"),
+        compiledDir: join20(workDir, "compiled"),
         port: 0
       });
       assertNotAborted();
     }
-    const framesDir = join15(workDir, "captured-frames");
-    if (!existsSync18(framesDir)) mkdirSync12(framesDir, { recursive: true });
+    const framesDir = join20(workDir, "captured-frames");
+    if (!existsSync23(framesDir)) mkdirSync15(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -22171,7 +22786,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     const workerCount = calculateOptimalWorkers(job.totalFrames, job.config.workers, cfg);
     const videoExt = isWebm ? ".webm" : ".mp4";
-    const videoOnlyPath = join15(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join20(workDir, `video-only${videoExt}`);
     const preset = getEncoderPreset(job.config.quality, outputFormat);
     job.framesRendered = 0;
     let streamingEncoder = null;
@@ -22440,7 +23055,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync4(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync6(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -22449,8 +23064,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync18(outputPath)) {
-        const debugOutput = join15(workDir, isWebm ? "output.webm" : "output.mp4");
+      if (existsSync23(outputPath)) {
+        const debugOutput = join20(workDir, isWebm ? "output.webm" : "output.mp4");
         copyFileSync2(outputPath, debugOutput);
       }
     } else {
@@ -22526,7 +23141,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync18(workDir)) rmSync5(workDir, { recursive: true, force: true });
+          if (existsSync23(workDir)) rmSync5(workDir, { recursive: true, force: true });
         },
         log
       );
@@ -22579,17 +23194,9 @@ var init_config3 = __esm({
   }
 });
 
-// ../core/src/lint/index.ts
-var init_lint = __esm({
-  "../core/src/lint/index.ts"() {
-    "use strict";
-    init_hyperframeLinter();
-  }
-});
-
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync19, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
-import { resolve as resolve7, join as join16 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync15, statSync as statSync7 } from "fs";
+import { resolve as resolve10, join as join21 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -22616,28 +23223,28 @@ function pickEntryFile(files, preferredEntryFile) {
   return null;
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
-  const absProjectDir = resolve7(projectDir);
-  if (!existsSync19(absProjectDir) || !statSync5(absProjectDir).isDirectory()) {
+  const absProjectDir = resolve10(projectDir);
+  if (!existsSync24(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
     (value) => typeof value === "string" && value.trim().length > 0
   );
   for (const entryFile of entryCandidates) {
-    const absoluteEntryPath = resolve7(absProjectDir, entryFile);
+    const absoluteEntryPath = resolve10(absProjectDir, entryFile);
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync19(absoluteEntryPath) && statSync5(absoluteEntryPath).isFile()) {
+    if (existsSync24(absoluteEntryPath) && statSync7(absoluteEntryPath).isFile()) {
       return {
         entryFile,
-        html: readFileSync9(absoluteEntryPath, "utf-8"),
+        html: readFileSync15(absoluteEntryPath, "utf-8"),
         source: "projectDir"
       };
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join16(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join21(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -22679,43 +23286,43 @@ function runHyperframeLint(prepared) {
 var init_hyperframeLint = __esm({
   "../producer/src/services/hyperframeLint.ts"() {
     "use strict";
-    init_lint();
+    init_lint2();
   }
 });
 
 // ../producer/src/utils/paths.ts
-import { resolve as resolve8, basename, join as join17 } from "path";
+import { resolve as resolve11, basename, join as join22 } from "path";
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
-  const absoluteProjectDir = resolve8(projectDir);
+  const absoluteProjectDir = resolve11(projectDir);
   const projectName = basename(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join17(rendersDir, `${projectName}.mp4`);
-  const absoluteOutputPath = resolve8(resolvedOutputPath);
+  const resolvedOutputPath = outputPath ?? join22(rendersDir, `${projectName}.mp4`);
+  const absoluteOutputPath = resolve11(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
 var DEFAULT_RENDERS_DIR;
 var init_paths = __esm({
   "../producer/src/utils/paths.ts"() {
     "use strict";
-    DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve8(new URL(import.meta.url).pathname, "../../..", "renders");
+    DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve11(new URL(import.meta.url).pathname, "../../..", "renders");
   }
 });
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync13,
-  statSync as statSync6,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync16,
+  statSync as statSync8,
   mkdtempSync,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync7,
   rmSync as rmSync6,
   createReadStream
 } from "fs";
-import { resolve as resolve9, dirname as dirname9, join as join18 } from "path";
+import { resolve as resolve12, dirname as dirname10, join as join23 } from "path";
 import { tmpdir } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto from "crypto";
-import { Hono as Hono3 } from "hono";
-import { streamSSE } from "hono/streaming";
+import { Hono as Hono4 } from "hono";
+import { streamSSE as streamSSE2 } from "hono/streaming";
 import { serve as serve3 } from "@hono/node-server";
 function parseRenderOptions(body) {
   const fps = [24, 30, 60].includes(body.fps) ? body.fps : 30;
@@ -22725,18 +23332,19 @@ function parseRenderOptions(body) {
   const debug = body.debug === true;
   const outputPath = typeof body.outputPath === "string" && body.outputPath.trim().length > 0 ? body.outputPath : typeof body.output === "string" && body.output.trim().length > 0 ? body.output : null;
   const entryFile = typeof body.entryFile === "string" && body.entryFile.trim().length > 0 ? body.entryFile.trim() : void 0;
-  return { outputPath, fps, quality, workers, useGpu, debug, entryFile };
+  const format = ["mp4", "webm"].includes(body.format) ? body.format : void 0;
+  return { outputPath, fps, quality, workers, useGpu, debug, entryFile, format };
 }
 async function prepareRenderBody(body) {
   const options = parseRenderOptions(body);
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
-    const absProjectDir = resolve9(projectDir);
-    if (!existsSync20(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
+    const absProjectDir = resolve12(projectDir);
+    if (!existsSync25(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync20(resolve9(absProjectDir, entry))) {
+    if (!existsSync25(resolve12(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -22761,8 +23369,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir();
-  const tempProjectDir = mkdtempSync(join18(tempRoot, "producer-project-"));
-  writeFileSync5(join18(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync(join23(tempRoot, "producer-project-"));
+  writeFileSync7(join23(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -22777,7 +23385,7 @@ function resolveOutputPath(projectDir, outputCandidate, rendersDir, log) {
   try {
     return resolveRenderPaths(projectDir, outputCandidate, rendersDir).absoluteOutputPath;
   } catch (error) {
-    const fallbackPath = resolve9(rendersDir, `producer-fallback-${Date.now()}.mp4`);
+    const fallbackPath = resolve12(rendersDir, `producer-fallback-${Date.now()}.mp4`);
     log.warn("Failed to resolve output path, using fallback", {
       fallback: fallbackPath,
       error: error instanceof Error ? error.message : String(error)
@@ -22882,8 +23490,8 @@ function createRenderHandlers(options = {}) {
       rendersDir,
       log
     );
-    const outputDir = dirname9(absoluteOutputPath);
-    if (!existsSync20(outputDir)) mkdirSync13(outputDir, { recursive: true });
+    const outputDir = dirname10(absoluteOutputPath);
+    if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
     log.info("render started", {
       requestId,
       projectDir: input.projectDir,
@@ -22893,6 +23501,7 @@ function createRenderHandlers(options = {}) {
     const job = createRenderJob({
       fps: input.fps,
       quality: input.quality,
+      format: input.format,
       workers: input.workers,
       useGpu: input.useGpu,
       debug: input.debug,
@@ -22908,7 +23517,7 @@ function createRenderHandlers(options = {}) {
           log.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync20(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
+      const fileSize = existsSync25(absoluteOutputPath) ? statSync8(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -22954,7 +23563,7 @@ function createRenderHandlers(options = {}) {
     }
   };
   const renderStream = (c2) => {
-    return streamSSE(c2, async (stream) => {
+    return streamSSE2(c2, async (stream) => {
       const requestId = getRequestId(c2);
       const t0 = Date.now();
       let body;
@@ -22990,12 +23599,13 @@ function createRenderHandlers(options = {}) {
         rendersDir,
         log
       );
-      const outputDir = dirname9(absoluteOutputPath);
-      if (!existsSync20(outputDir)) mkdirSync13(outputDir, { recursive: true });
+      const outputDir = dirname10(absoluteOutputPath);
+      if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
       log.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
         quality: input.quality,
+        format: input.format,
         workers: input.workers,
         useGpu: input.useGpu,
         debug: input.debug,
@@ -23025,7 +23635,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync20(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
+        const fileSize = existsSync25(absoluteOutputPath) ? statSync8(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -23083,11 +23693,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync20(artifact.path)) {
+    if (!existsSync25(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync6(artifact.path);
+    const stats = statSync8(artifact.path);
     return new Response(createReadStream(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -23099,7 +23709,7 @@ function createRenderHandlers(options = {}) {
   return { render: render2, renderStream, lint, health, outputs };
 }
 function createProducerApp(options = {}) {
-  const app = new Hono3();
+  const app = new Hono4();
   const handlers = createRenderHandlers(options);
   app.get("/health", handlers.health);
   app.post("/render", handlers.render);
@@ -23141,7 +23751,7 @@ var init_server = __esm({
     init_hyperframeLint();
     init_paths();
     init_logger();
-    entryScript = process.argv[1] ? resolve9(process.argv[1]) : "";
+    entryScript = process.argv[1] ? resolve12(process.argv[1]) : "";
     isPublicServerEntry = entryScript.endsWith("/public-server.js") || entryScript.endsWith("/src/server.ts");
     if (isPublicServerEntry) {
       const { values } = parseArgs2({
@@ -23217,9 +23827,9 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync21, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync26, rmSync as rmSync7 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join19 } from "path";
+import { join as join24 } from "path";
 import { Browser, detectBrowserPlatform, getInstalledBrowsers, install } from "@puppeteer/browsers";
 function setBrowserPath(path) {
   _browserPathOverride = path;
@@ -23237,17 +23847,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync21(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync26(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync21(envPath)) {
+  if (envPath && existsSync26(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync21(CACHE_DIR)) {
+  if (!existsSync26(CACHE_DIR)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR });
@@ -23259,7 +23869,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync21(p)) {
+    if (existsSync26(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -23293,7 +23903,7 @@ async function ensureBrowser(options) {
   return { executablePath: installed.executablePath, source: "download" };
 }
 function clearBrowser() {
-  if (!existsSync21(CACHE_DIR)) {
+  if (!existsSync26(CACHE_DIR)) {
     return false;
   }
   rmSync7(CACHE_DIR, { recursive: true, force: true });
@@ -23304,7 +23914,7 @@ var init_manager2 = __esm({
   "src/browser/manager.ts"() {
     "use strict";
     CHROME_VERSION = "131.0.6778.85";
-    CACHE_DIR = join19(homedir5(), ".cache", "hyperframes", "chrome");
+    CACHE_DIR = join24(homedir5(), ".cache", "hyperframes", "chrome");
     SYSTEM_CHROME_PATHS = process.platform === "darwin" ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"] : [
       "/usr/bin/google-chrome",
       "/usr/bin/google-chrome-stable",
@@ -23319,21 +23929,21 @@ var studioServer_exports = {};
 __export(studioServer_exports, {
   createStudioServer: () => createStudioServer
 });
-import { Hono as Hono4 } from "hono";
-import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync22, readFileSync as readFileSync10, readdirSync as readdirSync6, statSync as statSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync14 } from "fs";
-import { resolve as resolve10, join as join20, sep as sep2, basename as basename2, dirname as dirname10, extname as extname4 } from "path";
+import { Hono as Hono5 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+import { existsSync as existsSync27, readFileSync as readFileSync16, writeFileSync as writeFileSync8, statSync as statSync9 } from "fs";
+import { resolve as resolve13, join as join25, basename as basename2 } from "path";
 function resolveDistDir() {
-  const builtPath = resolve10(__dirname, "studio");
-  if (existsSync22(resolve10(builtPath, "index.html"))) return builtPath;
-  const devPath = resolve10(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync22(resolve10(devPath, "index.html"))) return devPath;
+  const builtPath = resolve13(__dirname, "studio");
+  if (existsSync27(resolve13(builtPath, "index.html"))) return builtPath;
+  const devPath = resolve13(__dirname, "..", "..", "..", "studio", "dist");
+  if (existsSync27(resolve13(devPath, "index.html"))) return devPath;
   return builtPath;
 }
 function resolveRuntimePath() {
-  const builtPath = resolve10(__dirname, "hyperframe-runtime.js");
-  if (existsSync22(builtPath)) return builtPath;
-  const devPath = resolve10(
+  const builtPath = resolve13(__dirname, "hyperframe-runtime.js");
+  if (existsSync27(builtPath)) return builtPath;
+  const devPath = resolve13(
     __dirname,
     "..",
     "..",
@@ -23342,96 +23952,97 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync22(devPath)) return devPath;
+  if (existsSync27(devPath)) return devPath;
   return builtPath;
 }
-function isSafePath(base, resolved) {
-  const norm = resolve10(base) + sep2;
-  return resolved.startsWith(norm) || resolved === resolve10(base);
-}
-function getMimeType(filePath) {
-  const ext = extname4(filePath).toLowerCase();
-  return MIME_TYPES2[ext] ?? "application/octet-stream";
-}
-function walkDir(dir, prefix = "") {
-  const files = [];
-  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      files.push(...walkDir(join20(dir, entry.name), rel));
-    } else {
-      files.push(rel);
-    }
-  }
-  return files;
-}
-function serveStaticFile(filePath) {
-  if (!existsSync22(filePath) || !statSync7(filePath).isFile()) return null;
-  const mime = getMimeType(filePath);
-  const content = readFileSync10(filePath);
-  return new Response(content, {
-    headers: { "Content-Type": mime, "Cache-Control": "no-store" }
-  });
-}
-function buildSubCompositionHtml(projectDir, compPath, runtimeUrl) {
-  const compFile = resolve10(projectDir, compPath);
-  if (!isSafePath(projectDir, compFile) || !existsSync22(compFile) || !statSync7(compFile).isFile()) {
-    return null;
-  }
-  let rawComp = readFileSync10(compFile, "utf-8");
-  const templateMatch = rawComp.match(/<template>([\s\S]*)<\/template>/i);
-  let content = (templateMatch ? templateMatch[1] : rawComp) ?? rawComp;
-  content = content.replace(
-    /(<[^>]*?)(data-composition-src=["']([^"']+)["'])([^>]*>)/g,
-    (_match, before2, srcAttr, src, after2) => {
-      const nestedFile = join20(projectDir, src);
-      if (!existsSync22(nestedFile)) return before2 + srcAttr + after2;
-      const nestedRaw = readFileSync10(nestedFile, "utf-8");
-      const nestedTemplate = nestedRaw.match(/<template>([\s\S]*)<\/template>/i);
-      const nestedContent = (nestedTemplate ? nestedTemplate[1] : nestedRaw) ?? nestedRaw;
-      const styles = [];
-      const scripts = [];
-      let body = nestedContent.replace(/<style[^>]*>([\s\S]*?)<\/style>/gi, (_2, css) => {
-        styles.push(css);
-        return "";
-      }).replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, (_2, js) => {
-        scripts.push(js);
-        return "";
-      });
-      const innerRootMatch = body.match(
-        /<([a-z][a-z0-9]*)\b[^>]*data-composition-id[^>]*>([\s\S]*)<\/\1>/i
-      );
-      const innerHTML = innerRootMatch ? innerRootMatch[2] : body;
-      return before2 + srcAttr + after2.replace(/>$/, ">") + innerHTML + (styles.length ? `<style>${styles.join("\n")}</style>` : "") + (scripts.length ? `<script>${scripts.map((s) => `(function(){try{${s}}catch(e){}})();`).join("\n")}</script>` : "");
-    }
-  );
-  return `<!DOCTYPE html>
-<html>
-<head>
-<script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js"></script>
-<script data-hyperframes-preview-runtime="1" src="${runtimeUrl}"></script>
-</head>
-<body>
-${content}
-</body>
-</html>`;
-}
 function createStudioServer(options) {
   const { projectDir } = options;
   const projectId = basename2(projectDir);
   const studioDir = resolveDistDir();
   const runtimePath = resolveRuntimePath();
   const watcher = createProjectWatcher(projectDir);
-  const app = new Hono4();
+  const project = { id: projectId, dir: projectDir, title: projectId };
+  const adapter2 = {
+    listProjects: () => [project],
+    resolveProject: (id) => id === projectId ? project : null,
+    async bundle(dir) {
+      try {
+        const { bundleToSingleHtml: bundleToSingleHtml2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
+        let html = await bundleToSingleHtml2(dir);
+        html = html.replace(
+          'data-hyperframes-preview-runtime="1" src=""',
+          'data-hyperframes-preview-runtime="1" src="/api/runtime.js"'
+        );
+        return html;
+      } catch {
+        return null;
+      }
+    },
+    async lint(html, opts) {
+      const { lintHyperframeHtml: lintHyperframeHtml2 } = await Promise.resolve().then(() => (init_lint2(), lint_exports));
+      return lintHyperframeHtml2(html, opts);
+    },
+    runtimeUrl: "/api/runtime.js",
+    rendersDir: () => join25(projectDir, "renders"),
+    startRender(opts) {
+      const state = {
+        id: opts.jobId,
+        status: "rendering",
+        progress: 0,
+        outputPath: opts.outputPath
+      };
+      (async () => {
+        try {
+          const { createRenderJob: createRenderJob2, executeRenderJob: executeRenderJob2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
+          const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
+          try {
+            const browser = await ensureBrowser2();
+            if (browser.executablePath && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
+              process.env.PRODUCER_HEADLESS_SHELL_PATH = browser.executablePath;
+            }
+          } catch {
+          }
+          const job = createRenderJob2({
+            fps: opts.fps,
+            quality: opts.quality,
+            format: opts.format
+          });
+          const startTime = Date.now();
+          const onProgress = (j2) => {
+            state.progress = j2.progress;
+            if (j2.currentStage) state.stage = j2.currentStage;
+          };
+          await executeRenderJob2(job, opts.project.dir, opts.outputPath, onProgress);
+          state.status = "complete";
+          state.progress = 100;
+          const metaPath = opts.outputPath.replace(/\.(mp4|webm)$/, ".meta.json");
+          writeFileSync8(
+            metaPath,
+            JSON.stringify({ status: "complete", durationMs: Date.now() - startTime })
+          );
+        } catch (err) {
+          state.status = "failed";
+          state.error = err instanceof Error ? err.message : String(err);
+          try {
+            const metaPath = opts.outputPath.replace(/\.(mp4|webm)$/, ".meta.json");
+            writeFileSync8(metaPath, JSON.stringify({ status: "failed" }));
+          } catch {
+          }
+        }
+      })();
+      return state;
+    }
+  };
+  const app = new Hono5();
   app.get("/api/runtime.js", (c2) => {
-    if (!existsSync22(runtimePath)) return c2.text("runtime not built", 404);
-    return c2.body(readFileSync10(runtimePath, "utf-8"), 200, {
+    if (!existsSync27(runtimePath)) return c2.text("runtime not built", 404);
+    return c2.body(readFileSync16(runtimePath, "utf-8"), 200, {
       "Content-Type": "text/javascript",
       "Cache-Control": "no-store"
     });
   });
   app.get("/api/events", (c2) => {
-    return streamSSE2(c2, async (stream) => {
+    return streamSSE3(c2, async (stream) => {
       const listener = () => {
         stream.writeSSE({ event: "file-change", data: "{}" }).catch(() => {
         });
@@ -23442,252 +24053,49 @@ function createStudioServer(options) {
       }
     });
   });
-  app.get("/api/projects", (c2) => {
-    return c2.json({ projects: [{ id: projectId, title: projectId }] });
-  });
-  app.get("/api/projects/:id", (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const files = walkDir(projectDir);
-    return c2.json({ id: projectId, files });
-  });
-  app.get("/api/projects/:id/preview", async (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    let bundled;
-    try {
-      const { bundleToSingleHtml: bundleToSingleHtml2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
-      bundled = await bundleToSingleHtml2(projectDir);
-    } catch {
-      const file = join20(projectDir, "index.html");
-      if (!existsSync22(file)) return c2.text("not found", 404);
-      bundled = readFileSync10(file, "utf-8");
-    }
-    const baseTag = `<base href="/api/projects/${projectId}/preview/">`;
-    if (bundled.includes("<head>")) {
-      bundled = bundled.replace("<head>", `<head>${baseTag}`);
-    } else {
-      bundled = baseTag + bundled;
-    }
-    bundled = bundled.replace(
-      'data-hyperframes-preview-runtime="1" src=""',
-      'data-hyperframes-preview-runtime="1" src="/api/runtime.js"'
-    );
-    return c2.html(bundled);
-  });
-  app.get("/api/projects/:id/preview/comp/*", (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const compPath = c2.req.path.replace(`/api/projects/${id}/preview/comp/`, "");
-    const html = buildSubCompositionHtml(
-      projectDir,
-      decodeURIComponent(compPath),
-      "/api/runtime.js"
-    );
-    if (!html) return c2.text("not found", 404);
-    return c2.html(html);
-  });
-  app.get("/api/projects/:id/preview/*", (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const subPath = decodeURIComponent(
-      c2.req.path.replace(`/api/projects/${id}/preview/`, "").split("?")[0] ?? ""
-    );
-    const file = resolve10(projectDir, subPath);
-    if (!isSafePath(projectDir, file) || !existsSync22(file) || !statSync7(file).isFile()) {
-      return c2.text("not found", 404);
-    }
-    const mime = getMimeType(file);
-    const content = readFileSync10(file);
-    return new Response(content, {
-      headers: { "Content-Type": mime, "Cache-Control": "no-store" }
-    });
-  });
-  app.get("/api/projects/:id/files/*", (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const filePath = decodeURIComponent(c2.req.path.replace(`/api/projects/${id}/files/`, ""));
-    const file = resolve10(projectDir, filePath);
-    if (!isSafePath(projectDir, file) || !existsSync22(file)) {
-      return c2.text("not found", 404);
-    }
-    const content = readFileSync10(file, "utf-8");
-    return c2.json({ filename: filePath, content });
-  });
-  app.put("/api/projects/:id/files/*", async (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const filePath = decodeURIComponent(c2.req.path.replace(`/api/projects/${id}/files/`, ""));
-    const file = resolve10(projectDir, filePath);
-    if (!isSafePath(projectDir, file)) {
-      return c2.json({ error: "forbidden" }, 403);
-    }
-    const dir = dirname10(file);
-    if (!existsSync22(dir)) mkdirSync14(dir, { recursive: true });
-    const body = await c2.req.text();
-    writeFileSync6(file, body, "utf-8");
-    return c2.json({ ok: true });
-  });
-  app.get("/api/resolve-session/:id", (c2) => c2.json({ error: "not available" }, 404));
-  const renderJobs = /* @__PURE__ */ new Map();
-  app.post("/api/projects/:id/render", async (c2) => {
-    const id = c2.req.param("id");
-    if (id !== projectId) return c2.json({ error: "not found" }, 404);
-    const jobId = Math.random().toString(36).slice(2, 10);
-    const outputDir = join20(projectDir, "renders");
-    if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
-    const outputPath = join20(outputDir, `${projectId}.mp4`);
-    renderJobs.set(jobId, { status: "rendering", progress: 0, outputPath });
-    (async () => {
-      try {
-        const { createRenderJob: createRenderJob2, executeRenderJob: executeRenderJob2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
-        const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
-        try {
-          const browser = await ensureBrowser2();
-          if (browser.executablePath && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
-            process.env.PRODUCER_HEADLESS_SHELL_PATH = browser.executablePath;
-          }
-        } catch {
-        }
-        const { trackRenderComplete: trackRenderComplete2 } = await Promise.resolve().then(() => (init_events(), events_exports));
-        const { bytesToMb: bytesToMb2 } = await Promise.resolve().then(() => (init_system(), system_exports));
-        const { freemem: freemem5 } = await import("os");
-        const job = createRenderJob2({ fps: 30, quality: "standard" });
-        const startTime = Date.now();
-        const onProgress = (j2) => {
-          const entry2 = renderJobs.get(jobId);
-          if (entry2) entry2.progress = j2.progress;
-        };
-        await executeRenderJob2(job, projectDir, outputPath, onProgress);
-        const entry = renderJobs.get(jobId);
-        if (entry) {
-          entry.status = "complete";
-          entry.progress = 100;
-        }
-        const elapsed = Date.now() - startTime;
-        const perf = job.perfSummary;
-        const compositionDurationMs = perf ? Math.round(perf.compositionDurationSeconds * 1e3) : void 0;
-        trackRenderComplete2({
-          durationMs: elapsed,
-          fps: 30,
-          quality: "standard",
-          workers: perf?.workers ?? 1,
-          docker: false,
-          gpu: false,
-          compositionDurationMs,
-          compositionWidth: perf?.resolution.width,
-          compositionHeight: perf?.resolution.height,
-          totalFrames: perf?.totalFrames,
-          speedRatio: compositionDurationMs && compositionDurationMs > 0 && elapsed > 0 ? Math.round(compositionDurationMs / elapsed * 100) / 100 : void 0,
-          captureAvgMs: perf?.captureAvgMs,
-          capturePeakMs: perf?.capturePeakMs,
-          peakMemoryMb: bytesToMb2(process.memoryUsage.rss()),
-          memoryFreeMb: bytesToMb2(freemem5())
-        });
-      } catch (err) {
-        try {
-          const { trackRenderError: trackRenderError2 } = await Promise.resolve().then(() => (init_events(), events_exports));
-          const { bytesToMb: bytesToMb2 } = await Promise.resolve().then(() => (init_system(), system_exports));
-          const { freemem: freemem5 } = await import("os");
-          trackRenderError2({
-            fps: 30,
-            quality: "standard",
-            docker: false,
-            errorMessage: err instanceof Error ? err.message : String(err),
-            peakMemoryMb: bytesToMb2(process.memoryUsage.rss()),
-            memoryFreeMb: bytesToMb2(freemem5())
-          });
-        } catch {
-        }
-        const entry = renderJobs.get(jobId);
-        if (entry) {
-          entry.status = "failed";
-          entry.error = err instanceof Error ? err.message : String(err);
-        }
-      }
-    })();
-    return c2.json({ jobId });
-  });
-  app.get("/api/render/:jobId/progress", (c2) => {
-    const { jobId } = c2.req.param();
-    const job = renderJobs.get(jobId);
-    if (!job) return c2.json({ error: "not found" }, 404);
-    return streamSSE2(c2, async (stream) => {
-      while (true) {
-        const current = renderJobs.get(jobId);
-        if (!current) break;
-        await stream.writeSSE({
-          event: "progress",
-          data: JSON.stringify({
-            progress: current.progress,
-            status: current.status,
-            error: current.error
-          })
-        });
-        if (current.status === "complete" || current.status === "failed") break;
-        await stream.sleep(500);
-      }
+  const api = createStudioApi(adapter2);
+  app.all("/api/*", async (c2) => {
+    const url = new URL(c2.req.url);
+    url.pathname = url.pathname.slice(4);
+    const forwardReq = new Request(url.toString(), {
+      method: c2.req.method,
+      headers: c2.req.raw.headers,
+      body: c2.req.raw.body,
+      // @ts-expect-error -- Node needs duplex for streaming bodies
+      duplex: "half"
     });
+    return api.fetch(forwardReq);
   });
-  app.get("/api/render/:jobId/download", (c2) => {
-    const { jobId } = c2.req.param();
-    const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync22(job.outputPath)) {
-      return c2.json({ error: "not found" }, 404);
-    }
-    const content = readFileSync10(job.outputPath);
+  app.get("/assets/*", (c2) => {
+    const filePath = resolve13(studioDir, c2.req.path.slice(1));
+    if (!existsSync27(filePath) || !statSync9(filePath).isFile()) return c2.text("not found", 404);
+    const content = readFileSync16(filePath);
     return new Response(content, {
-      headers: {
-        "Content-Type": "video/mp4",
-        "Content-Disposition": `attachment; filename="${projectId}.mp4"`
-      }
+      headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
     });
   });
-  app.get("/assets/*", (c2) => {
-    const filePath = resolve10(studioDir, c2.req.path.slice(1));
-    const resp = serveStaticFile(filePath);
-    return resp ?? c2.text("not found", 404);
-  });
   app.get("/icons/*", (c2) => {
-    const filePath = resolve10(studioDir, c2.req.path.slice(1));
-    const resp = serveStaticFile(filePath);
-    return resp ?? c2.text("not found", 404);
+    const filePath = resolve13(studioDir, c2.req.path.slice(1));
+    if (!existsSync27(filePath) || !statSync9(filePath).isFile()) return c2.text("not found", 404);
+    const content = readFileSync16(filePath);
+    return new Response(content, {
+      headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
+    });
   });
   app.get("*", (c2) => {
-    const indexPath = resolve10(studioDir, "index.html");
-    if (!existsSync22(indexPath)) {
+    const indexPath = resolve13(studioDir, "index.html");
+    if (!existsSync27(indexPath)) {
       return c2.text("Studio not found. Rebuild with: pnpm run build", 500);
     }
-    return c2.html(readFileSync10(indexPath, "utf-8"));
+    return c2.html(readFileSync16(indexPath, "utf-8"));
   });
   return { app, watcher };
 }
-var MIME_TYPES2;
 var init_studioServer = __esm({
   "src/server/studioServer.ts"() {
     "use strict";
     init_fileWatcher();
-    MIME_TYPES2 = {
-      ".html": "text/html",
-      ".js": "text/javascript",
-      ".css": "text/css",
-      ".json": "application/json",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".webp": "image/webp",
-      ".gif": "image/gif",
-      ".mp4": "video/mp4",
-      ".webm": "video/webm",
-      ".mp3": "audio/mpeg",
-      ".wav": "audio/wav",
-      ".m4a": "audio/mp4",
-      ".ogg": "audio/ogg",
-      ".woff2": "font/woff2",
-      ".woff": "font/woff",
-      ".ttf": "font/ttf"
-    };
+    init_studio_api();
   }
 });
 
@@ -23697,8 +24105,8 @@ __export(dev_exports, {
   default: () => dev_default
 });
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync23, lstatSync, symlinkSync, unlinkSync, readlinkSync, mkdirSync as mkdirSync15 } from "fs";
-import { resolve as resolve11, dirname as dirname11, basename as basename3, join as join21 } from "path";
+import { existsSync as existsSync28, lstatSync, symlinkSync, unlinkSync as unlinkSync2, readlinkSync, mkdirSync as mkdirSync17 } from "fs";
+import { resolve as resolve14, dirname as dirname11, basename as basename3, join as join26 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire } from "module";
 async function serveWithPortFallback(fetch3, startPort, maxAttempts = 10) {
@@ -23736,26 +24144,26 @@ async function serveWithPortFallback(fetch3, startPort, maxAttempts = 10) {
 }
 async function runDevMode(dir) {
   const thisFile = fileURLToPath4(import.meta.url);
-  const repoRoot = resolve11(dirname11(thisFile), "..", "..", "..", "..");
-  const projectsDir = join21(repoRoot, "packages", "studio", "data", "projects");
+  const repoRoot = resolve14(dirname11(thisFile), "..", "..", "..", "..");
+  const projectsDir = join26(repoRoot, "packages", "studio", "data", "projects");
   const projectName = basename3(dir);
-  const symlinkPath = join21(projectsDir, projectName);
-  mkdirSync15(projectsDir, { recursive: true });
+  const symlinkPath = join26(projectsDir, projectName);
+  mkdirSync17(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync23(symlinkPath)) {
+    if (existsSync28(symlinkPath)) {
       try {
         const stat = lstatSync(symlinkPath);
         if (stat.isSymbolicLink()) {
           const target = readlinkSync(symlinkPath);
-          if (resolve11(target) !== resolve11(dir)) {
-            unlinkSync(symlinkPath);
+          if (resolve14(target) !== resolve14(dir)) {
+            unlinkSync2(symlinkPath);
           }
         }
       } catch {
       }
     }
-    if (!existsSync23(symlinkPath)) {
+    if (!existsSync28(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23763,7 +24171,7 @@ async function runDevMode(dir) {
   Wt2(c.bold("hyperframes dev"));
   const s = be();
   s.start("Starting studio...");
-  const studioPkgDir = join21(repoRoot, "packages", "studio");
+  const studioPkgDir = join26(repoRoot, "packages", "studio");
   const child = spawn7("pnpm", ["exec", "vite"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -23797,18 +24205,18 @@ async function runDevMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync23(symlinkPath)) unlinkSync(symlinkPath);
+        if (existsSync28(symlinkPath)) unlinkSync2(symlinkPath);
       } catch {
       }
     });
   }
-  return new Promise((resolve17) => {
-    child.on("close", () => resolve17());
+  return new Promise((resolve20) => {
+    child.on("close", () => resolve20());
   });
 }
 function hasLocalStudio(dir) {
   try {
-    const req = createRequire(join21(dir, "package.json"));
+    const req = createRequire(join26(dir, "package.json"));
     req.resolve("@hyperframes/studio/package.json");
     return true;
   } catch {
@@ -23816,20 +24224,20 @@ function hasLocalStudio(dir) {
   }
 }
 async function runLocalStudioMode(dir) {
-  const req = createRequire(join21(dir, "package.json"));
+  const req = createRequire(join26(dir, "package.json"));
   const studioPkgPath = dirname11(req.resolve("@hyperframes/studio/package.json"));
   const projectName = basename3(dir);
-  const projectsDir = join21(studioPkgPath, "data", "projects");
-  const symlinkPath = join21(projectsDir, projectName);
-  mkdirSync15(projectsDir, { recursive: true });
+  const projectsDir = join26(studioPkgPath, "data", "projects");
+  const symlinkPath = join26(projectsDir, projectName);
+  mkdirSync17(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync23(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
-      if (resolve11(readlinkSync(symlinkPath)) !== resolve11(dir)) {
-        unlinkSync(symlinkPath);
+    if (existsSync28(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+      if (resolve14(readlinkSync(symlinkPath)) !== resolve14(dir)) {
+        unlinkSync2(symlinkPath);
       }
     }
-    if (!existsSync23(symlinkPath)) {
+    if (!existsSync28(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23868,13 +24276,13 @@ async function runLocalStudioMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync23(symlinkPath)) unlinkSync(symlinkPath);
+        if (existsSync28(symlinkPath)) unlinkSync2(symlinkPath);
       } catch {
       }
     });
   }
-  return new Promise((resolve17) => {
-    child.on("close", () => resolve17());
+  return new Promise((resolve20) => {
+    child.on("close", () => resolve20());
   });
 }
 async function runEmbeddedMode(dir, startPort) {
@@ -23930,7 +24338,7 @@ var init_dev = __esm({
         port: { type: "string", description: "Port to run the dev server on", default: "3002" }
       },
       async run({ args }) {
-        const dir = resolve11(args.dir ?? ".");
+        const dir = resolve14(args.dir ?? ".");
         const startPort = parseInt(args.port ?? "3002", 10);
         if (isDevMode()) {
           return runDevMode(dir);
@@ -23977,17 +24385,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync24, statSync as statSync8 } from "fs";
-import { resolve as resolve12, basename as basename4 } from "path";
+import { existsSync as existsSync29, statSync as statSync10 } from "fs";
+import { resolve as resolve15, basename as basename4 } from "path";
 function resolveProject(dirArg) {
-  const dir = resolve12(dirArg ?? ".");
+  const dir = resolve15(dirArg ?? ".");
   const name = basename4(dir);
-  const indexPath = resolve12(dir, "index.html");
-  if (!existsSync24(dir) || !statSync8(dir).isDirectory()) {
+  const indexPath = resolve15(dir, "index.html");
+  if (!existsSync29(dir) || !statSync10(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync24(indexPath)) {
+  if (!existsSync29(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -24076,9 +24484,9 @@ var render_exports = {};
 __export(render_exports, {
   default: () => render_default
 });
-import { existsSync as existsSync25, mkdirSync as mkdirSync16, statSync as statSync9 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync18, statSync as statSync11 } from "fs";
 import { cpus as cpus3, freemem as freemem3 } from "os";
-import { resolve as resolve13, dirname as dirname12, join as join22 } from "path";
+import { resolve as resolve16, dirname as dirname12, join as join27 } from "path";
 function defaultWorkerCount() {
   return Math.max(1, Math.min(Math.floor(CPU_CORE_COUNT / 2), 4));
 }
@@ -24172,8 +24580,8 @@ function trackRenderMetrics(job, elapsedMs, options, docker) {
 function printRenderComplete(outputPath, elapsedMs, quiet) {
   if (quiet) return;
   let fileSize = "unknown";
-  if (existsSync25(outputPath)) {
-    const stat = statSync9(outputPath);
+  if (existsSync30(outputPath)) {
+    const stat = statSync11(outputPath);
     fileSize = formatBytes(stat.size);
   }
   const duration = formatDuration(elapsedMs);
@@ -24182,7 +24590,7 @@ function printRenderComplete(outputPath, elapsedMs, quiet) {
   console.log("   " + c.bold(fileSize) + c.dim(" \xB7 " + duration + " \xB7 completed"));
 }
 var VALID_FPS, VALID_QUALITY, VALID_FORMAT, CPU_CORE_COUNT, render_default;
-var init_render = __esm({
+var init_render2 = __esm({
   "src/commands/render.ts"() {
     "use strict";
     init_dist();
@@ -24278,10 +24686,13 @@ Examples:
           }
           workers = parsed;
         }
-        const rendersDir = resolve13("renders");
+        const rendersDir = resolve16("renders");
         const ext = format === "webm" ? ".webm" : ".mp4";
-        const outputPath = args.output ? resolve13(args.output) : join22(rendersDir, `${project.name}${ext}`);
-        mkdirSync16(dirname12(outputPath), { recursive: true });
+        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 ? resolve16(args.output) : join27(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
+        mkdirSync18(dirname12(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
         const quiet = args.quiet ?? false;
@@ -24367,17 +24778,17 @@ __export(transcribe_exports, {
   transcribe: () => transcribe
 });
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync11, mkdirSync as mkdirSync17, unlinkSync as unlinkSync2 } from "fs";
-import { join as join23, extname as extname5 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync17, mkdirSync as mkdirSync19, unlinkSync as unlinkSync3 } from "fs";
+import { join as join28, extname as extname4 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function isAudioFile(filePath) {
-  return AUDIO_EXTENSIONS.has(extname5(filePath).toLowerCase());
+  return AUDIO_EXTENSIONS.has(extname4(filePath).toLowerCase());
 }
 function isVideoFile(filePath) {
-  return VIDEO_EXTENSIONS.has(extname5(filePath).toLowerCase());
+  return VIDEO_EXTENSIONS.has(extname4(filePath).toLowerCase());
 }
 function extractAudio(videoPath) {
-  const wavPath = join23(tmpdir2(), `hyperframes-audio-${Date.now()}.wav`);
+  const wavPath = join28(tmpdir2(), `hyperframes-audio-${Date.now()}.wav`);
   execFileSync3(
     "ffmpeg",
     ["-i", videoPath, "-vn", "-ar", "16000", "-ac", "1", "-f", "wav", "-y", wavPath],
@@ -24400,10 +24811,10 @@ function isWav16kMono(filePath) {
   }
 }
 function prepareAudio(audioPath) {
-  if (extname5(audioPath).toLowerCase() === ".wav" && isWav16kMono(audioPath)) {
+  if (extname4(audioPath).toLowerCase() === ".wav" && isWav16kMono(audioPath)) {
     return audioPath;
   }
-  const wavPath = join23(tmpdir2(), `hyperframes-audio-${Date.now()}.wav`);
+  const wavPath = join28(tmpdir2(), `hyperframes-audio-${Date.now()}.wav`);
   execFileSync3(
     "ffmpeg",
     ["-i", audioPath, "-ar", "16000", "-ac", "1", "-f", "wav", "-y", wavPath],
@@ -24420,7 +24831,7 @@ async function transcribe(inputPath, outputDir, options) {
     onProgress: options?.onProgress
   });
   let wavPath;
-  const ext = extname5(inputPath).toLowerCase();
+  const ext = extname4(inputPath).toLowerCase();
   if (isAudioFile(inputPath)) {
     options?.onProgress?.("Preparing audio...");
     wavPath = prepareAudio(inputPath);
@@ -24436,8 +24847,8 @@ async function transcribe(inputPath, outputDir, options) {
     throw new Error(`Unsupported file type: ${ext}`);
   }
   options?.onProgress?.("Transcribing...");
-  const outputBase = join23(outputDir, "transcript");
-  mkdirSync17(outputDir, { recursive: true });
+  const outputBase = join28(outputDir, "transcript");
+  mkdirSync19(outputDir, { recursive: true });
   execFileSync3(
     whisper.executablePath,
     [
@@ -24454,10 +24865,10 @@ async function transcribe(inputPath, outputDir, options) {
     { stdio: "ignore", timeout: 3e5 }
   );
   const transcriptPath = `${outputBase}.json`;
-  if (!existsSync26(transcriptPath)) {
+  if (!existsSync31(transcriptPath)) {
     throw new Error("Whisper did not produce output. Check the input file.");
   }
-  const transcript = JSON.parse(readFileSync11(transcriptPath, "utf-8"));
+  const transcript = JSON.parse(readFileSync17(transcriptPath, "utf-8"));
   const segments = transcript.transcription ?? [];
   let wordCount = 0;
   let maxEnd = 0;
@@ -24470,7 +24881,7 @@ async function transcribe(inputPath, outputDir, options) {
   }
   if (wavPath !== inputPath) {
     try {
-      unlinkSync2(wavPath);
+      unlinkSync3(wavPath);
     } catch {
     }
   }
@@ -24496,15 +24907,15 @@ __export(init_exports, {
   default: () => init_default
 });
 import {
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync20,
   copyFileSync as copyFileSync3,
   cpSync as cpSync2,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync12,
-  readdirSync as readdirSync7
+  writeFileSync as writeFileSync9,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync8
 } from "fs";
-import { resolve as resolve14, basename as basename5, join as join24, dirname as dirname13 } from "path";
+import { resolve as resolve17, basename as basename5, join as join29, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { execFileSync as execFileSync4, spawn as spawn8 } from "child_process";
 async function installSkills(interactive) {
@@ -24625,9 +25036,9 @@ function transcodeToMp4(inputPath, outputPath) {
 }
 function resolveAssetDir(devSegments, builtSegments) {
   const base = dirname13(fileURLToPath5(import.meta.url));
-  const devPath = resolve14(base, ...devSegments);
-  const builtPath = resolve14(base, ...builtSegments);
-  return existsSync27(devPath) ? devPath : builtPath;
+  const devPath = resolve17(base, ...devSegments);
+  const builtPath = resolve17(base, ...builtSegments);
+  return existsSync32(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -24639,9 +25050,9 @@ function getBundledSkillsDir() {
   return resolveAssetDir(["..", "..", "..", "..", "skills"], ["skills"]);
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
-  const htmlFiles = readdirSync7(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && e.name.endsWith(".html")).map((e) => join24(e.parentPath ?? e.path, e.name));
+  const htmlFiles = readdirSync8(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && e.name.endsWith(".html")).map((e) => join29(e.parentPath ?? e.path, e.name));
   for (const file of htmlFiles) {
-    let content = readFileSync12(file, "utf-8");
+    let content = readFileSync18(file, "utf-8");
     if (videoFilename) {
       content = content.replaceAll("__VIDEO_SRC__", videoFilename);
     } else {
@@ -24652,11 +25063,11 @@ function patchVideoSrc(dir, videoFilename, durationSeconds) {
     }
     const dur = durationSeconds ? String(Math.round(durationSeconds * 100) / 100) : "10";
     content = content.replaceAll("__VIDEO_DURATION__", dur);
-    writeFileSync7(file, content, "utf-8");
+    writeFileSync9(file, content, "utf-8");
   }
 }
 function patchTranscript(dir, transcriptPath) {
-  const raw = JSON.parse(readFileSync12(transcriptPath, "utf-8"));
+  const raw = JSON.parse(readFileSync18(transcriptPath, "utf-8"));
   const words = [];
   for (const seg of raw.transcription ?? []) {
     for (const token of seg.tokens ?? []) {
@@ -24678,9 +25089,9 @@ function patchTranscript(dir, transcriptPath) {
   }
   if (words.length === 0) return;
   const wordsJson = JSON.stringify(words, null, 10).replace(/^\[/, "[").replace(/\n {10}/g, "\n          ");
-  const htmlFiles = readdirSync7(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && e.name.endsWith(".html")).map((e) => join24(e.parentPath ?? e.path, e.name));
+  const htmlFiles = readdirSync8(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && e.name.endsWith(".html")).map((e) => join29(e.parentPath ?? e.path, e.name));
   for (const file of htmlFiles) {
-    let content = readFileSync12(file, "utf-8");
+    let content = readFileSync18(file, "utf-8");
     const scriptBlocks = content.match(/<script>[\s\S]*?<\/script>/g) ?? [];
     let scriptMatch = null;
     let transcriptMatch = null;
@@ -24692,7 +25103,7 @@ function patchTranscript(dir, transcriptPath) {
     if (match) {
       const varName = scriptMatch ? "script" : "TRANSCRIPT";
       content = content.replace(match[0], `const ${varName} = ${wordsJson};`);
-      writeFileSync7(file, content, "utf-8");
+      writeFileSync9(file, content, "utf-8");
     }
   }
 }
@@ -24749,7 +25160,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
       }
       if (shouldTranscode) {
         const mp4Name = localVideoName.replace(/\.[^.]+$/, ".mp4");
-        const mp4Path = resolve14(destDir, mp4Name);
+        const mp4Path = resolve17(destDir, mp4Name);
         const spin = be();
         spin.start("Transcoding to H.264 MP4...");
         const ok = await transcodeToMp4(videoPath, mp4Path);
@@ -24758,10 +25169,10 @@ async function handleVideoFile(videoPath, destDir, interactive) {
           localVideoName = mp4Name;
         } else {
           spin.stop(c.warn("Transcode failed \u2014 copying original file"));
-          copyFileSync3(videoPath, resolve14(destDir, localVideoName));
+          copyFileSync3(videoPath, resolve17(destDir, localVideoName));
         }
       } else {
-        copyFileSync3(videoPath, resolve14(destDir, localVideoName));
+        copyFileSync3(videoPath, resolve17(destDir, localVideoName));
       }
     } else {
       if (interactive) {
@@ -24771,20 +25182,20 @@ async function handleVideoFile(videoPath, destDir, interactive) {
         console.log(c.warn("ffmpeg not installed \u2014 cannot transcode. Copying original."));
         console.log(c.dim("Install: ") + c.accent("brew install ffmpeg"));
       }
-      copyFileSync3(videoPath, resolve14(destDir, localVideoName));
+      copyFileSync3(videoPath, resolve17(destDir, localVideoName));
     }
   } else {
-    copyFileSync3(videoPath, resolve14(destDir, localVideoName));
+    copyFileSync3(videoPath, resolve17(destDir, localVideoName));
   }
   return { meta, localVideoName };
 }
 function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds) {
-  mkdirSync18(destDir, { recursive: true });
+  mkdirSync20(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
   cpSync2(templateDir, destDir, { recursive: true });
   patchVideoSrc(destDir, localVideoName, durationSeconds);
-  writeFileSync7(
-    resolve14(destDir, "meta.json"),
+  writeFileSync9(
+    resolve17(destDir, "meta.json"),
     JSON.stringify(
       {
         id: name,
@@ -24797,23 +25208,23 @@ function scaffoldProject(destDir, name, templateId, localVideoName, durationSeco
     "utf-8"
   );
   const sharedDir = getSharedTemplateDir();
-  if (existsSync27(sharedDir)) {
-    for (const entry of readdirSync7(sharedDir, { withFileTypes: true })) {
-      const src = join24(sharedDir, entry.name);
-      const dest = resolve14(destDir, entry.name);
+  if (existsSync32(sharedDir)) {
+    for (const entry of readdirSync8(sharedDir, { withFileTypes: true })) {
+      const src = join29(sharedDir, entry.name);
+      const dest = resolve17(destDir, entry.name);
       if (entry.isFile() || entry.isSymbolicLink()) {
         copyFileSync3(src, dest);
       }
     }
   }
   const skillsSrcDir = getBundledSkillsDir();
-  if (existsSync27(skillsSrcDir)) {
+  if (existsSync32(skillsSrcDir)) {
     const projectSkills = ["hyperframes-compose", "hyperframes-captions"];
     for (const skill of projectSkills) {
-      const src = join24(skillsSrcDir, skill);
-      if (existsSync27(src)) {
-        const dest = resolve14(destDir, ".claude", "skills", skill);
-        mkdirSync18(dest, { recursive: true });
+      const src = join29(skillsSrcDir, skill);
+      if (existsSync32(src)) {
+        const dest = resolve17(destDir, ".claude", "skills", skill);
+        mkdirSync20(dest, { recursive: true });
         cpSync2(src, dest, { recursive: true });
       }
     }
@@ -24842,7 +25253,7 @@ async function nextStepLoop(destDir) {
         const devCmd = await Promise.resolve().then(() => (init_dev(), dev_exports)).then((m) => m.default);
         await runCommand(devCmd, { rawArgs: [destDir] });
       } else if (next === "render") {
-        const renderCmd = await Promise.resolve().then(() => (init_render(), render_exports)).then((m) => m.default);
+        const renderCmd = await Promise.resolve().then(() => (init_render2(), render_exports)).then((m) => m.default);
         await runCommand(renderCmd, { rawArgs: [destDir] });
       }
     } catch {
@@ -24929,18 +25340,18 @@ Examples:
           }
           const templateId2 = resolvedTemplate;
           const name2 = args.name ?? "my-video";
-          const destDir2 = resolve14(name2);
-          if (existsSync27(destDir2) && readdirSync7(destDir2).length > 0) {
+          const destDir2 = resolve17(name2);
+          if (existsSync32(destDir2) && readdirSync8(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
-          mkdirSync18(destDir2, { recursive: true });
+          mkdirSync20(destDir2, { recursive: true });
           let localVideoName2;
           let videoDuration2;
           let sourceFilePath2;
           if (videoFlag) {
-            const videoPath = resolve14(videoFlag);
-            if (!existsSync27(videoPath)) {
+            const videoPath = resolve17(videoFlag);
+            if (!existsSync32(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -24953,13 +25364,13 @@ Examples:
             );
           }
           if (audioFlag) {
-            const audioPath = resolve14(audioFlag);
-            if (!existsSync27(audioPath)) {
+            const audioPath = resolve17(audioFlag);
+            if (!existsSync32(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
             sourceFilePath2 = audioPath;
-            copyFileSync3(audioPath, resolve14(destDir2, basename5(audioPath)));
+            copyFileSync3(audioPath, resolve17(destDir2, basename5(audioPath)));
             console.log(`Audio: ${basename5(audioPath)}`);
           }
           if (sourceFilePath2 && !skipTranscribe) {
@@ -24980,15 +25391,15 @@ Examples:
           }
           scaffoldProject(destDir2, basename5(destDir2), templateId2, localVideoName2, videoDuration2);
           trackInitTemplate(templateId2);
-          const transcriptFile2 = resolve14(destDir2, "transcript.json");
-          if (existsSync27(transcriptFile2)) {
+          const transcriptFile2 = resolve17(destDir2, "transcript.json");
+          if (existsSync32(transcriptFile2)) {
             patchTranscript(destDir2, transcriptFile2);
           }
           if (!skipSkills) {
             await installSkills(false);
           }
           console.log(c.success(`Created ${c.accent(name2 + "/")}`));
-          for (const f of readdirSync7(destDir2).filter((f2) => !f2.startsWith("."))) {
+          for (const f of readdirSync8(destDir2).filter((f2) => !f2.startsWith("."))) {
             console.log(`  ${c.accent(f)}`);
           }
           console.log();
@@ -25028,8 +25439,8 @@ Examples:
           }
           name = nameResult;
         }
-        const destDir = resolve14(name);
-        if (existsSync27(destDir) && readdirSync7(destDir).length > 0) {
+        const destDir = resolve17(name);
+        if (existsSync32(destDir) && readdirSync8(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -25044,13 +25455,13 @@ Examples:
         let videoDuration;
         let isAudioOnly = false;
         if (videoFlag) {
-          const videoPath = resolve14(videoFlag);
-          if (!existsSync27(videoPath)) {
+          const videoPath = resolve17(videoFlag);
+          if (!existsSync32(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
           }
-          mkdirSync18(destDir, { recursive: true });
+          mkdirSync20(destDir, { recursive: true });
           sourceFilePath = videoPath;
           const result = await handleVideoFile(videoPath, destDir, true);
           localVideoName = result.localVideoName;
@@ -25080,7 +25491,7 @@ Examples:
               validate(val) {
                 const trimmed = val?.trim();
                 if (!trimmed) return "Please enter a file path";
-                if (!existsSync27(resolve14(trimmed))) return "File not found";
+                if (!existsSync32(resolve17(trimmed))) return "File not found";
                 return void 0;
               }
             });
@@ -25088,16 +25499,16 @@ Examples:
               Nt("Setup cancelled.");
               process.exit(0);
             }
-            const filePath = resolve14(String(pathResult).trim());
+            const filePath = resolve17(String(pathResult).trim());
             sourceFilePath = filePath;
-            mkdirSync18(destDir, { recursive: true });
+            mkdirSync20(destDir, { recursive: true });
             if (mediaChoice === "video") {
               const result = await handleVideoFile(filePath, destDir, true);
               localVideoName = result.localVideoName;
               videoDuration = result.meta.durationSeconds;
             } else {
               isAudioOnly = true;
-              copyFileSync3(filePath, resolve14(destDir, basename5(filePath)));
+              copyFileSync3(filePath, resolve17(destDir, basename5(filePath)));
               R2.info(`Audio copied to ${c.accent(basename5(filePath))}`);
             }
           }
@@ -25165,14 +25576,14 @@ Examples:
         }
         scaffoldProject(destDir, name, templateId, localVideoName, videoDuration);
         trackInitTemplate(templateId);
-        const transcriptFile = resolve14(destDir, "transcript.json");
-        if (existsSync27(transcriptFile)) {
+        const transcriptFile = resolve17(destDir, "transcript.json");
+        if (existsSync32(transcriptFile)) {
           patchTranscript(destDir, transcriptFile);
         }
         if (!skipSkills) {
           await installSkills(true);
         }
-        const files = readdirSync7(destDir);
+        const files = readdirSync8(destDir);
         Vt2(files.map((f) => c.accent(f)).join("\n"), c.success(`Created ${name}/`));
         R2.message(
           `${c.dim("Tip:")} Open this project with ${c.accent("Claude Code")}, ${c.accent("Cursor")}, or your preferred AI agent.
@@ -25185,17 +25596,17 @@ ${c.dim("     AI skills are installed \u2014 your agent knows how to create and
 });
 
 // src/commands/lint.ts
-var lint_exports = {};
-__export(lint_exports, {
+var lint_exports2 = {};
+__export(lint_exports2, {
   default: () => lint_default
 });
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 var lint_default;
-var init_lint2 = __esm({
+var init_lint3 = __esm({
   "src/commands/lint.ts"() {
     "use strict";
     init_dist();
-    init_lint();
+    init_lint2();
     init_colors();
     init_project();
     init_updateCheck();
@@ -25207,7 +25618,7 @@ var init_lint2 = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync13(project.indexPath, "utf-8");
+        const html = readFileSync19(project.indexPath, "utf-8");
         const result = lintHyperframeHtml(html, { filePath: project.indexPath });
         if (args.json) {
           console.log(JSON.stringify(withMeta(result), null, 2));
@@ -25256,16 +25667,16 @@ var info_exports = {};
 __export(info_exports, {
   default: () => info_default
 });
-import { readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync10 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync12 } from "fs";
+import { join as join30 } from "path";
 function totalSize(dir) {
   let total = 0;
-  for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-    const path = join25(dir, entry.name);
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
+    const path = join30(dir, entry.name);
     if (entry.isDirectory()) {
       total += totalSize(path);
     } else {
-      total += statSync10(path).size;
+      total += statSync12(path).size;
     }
   }
   return total;
@@ -25289,7 +25700,7 @@ var init_info = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync14(project.indexPath, "utf-8");
+        const html = readFileSync20(project.indexPath, "utf-8");
         ensureDOMParser();
         const parsed = parseHtml(html);
         const tracks = new Set(parsed.elements.map((el) => el.zIndex));
@@ -25340,7 +25751,7 @@ var compositions_exports = {};
 __export(compositions_exports, {
   default: () => compositions_default
 });
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 function parseCompositions(html) {
   const parser = new DOMParser();
   const doc = parser.parseFromString(html, "text/html");
@@ -25397,7 +25808,7 @@ var init_compositions = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync15(project.indexPath, "utf-8");
+        const html = readFileSync21(project.indexPath, "utf-8");
         ensureDOMParser();
         const compositions = parseCompositions(html);
         if (compositions.length === 0) {
@@ -25433,8 +25844,8 @@ var benchmark_exports = {};
 __export(benchmark_exports, {
   default: () => benchmark_default
 });
-import { existsSync as existsSync28, statSync as statSync11 } from "fs";
-import { resolve as resolve15, join as join26 } from "path";
+import { existsSync as existsSync33, statSync as statSync13 } from "fs";
+import { resolve as resolve18, join as join31 } from "path";
 var DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
   "src/commands/benchmark.ts"() {
@@ -25471,7 +25882,7 @@ var init_benchmark = __esm({
           process.exit(1);
         }
         const jsonOutput = args.json ?? false;
-        const benchDir = resolve15("renders", ".benchmark");
+        const benchDir = resolve18("renders", ".benchmark");
         let producer = null;
         try {
           producer = await loadProducer();
@@ -25504,7 +25915,7 @@ var init_benchmark = __esm({
           s?.start(`Benchmarking ${config.label}...`);
           for (let i = 0; i < runsPerConfig; i++) {
             s?.message(`${config.label} \u2014 run ${i + 1}/${runsPerConfig}`);
-            const outputPath = join26(
+            const outputPath = join31(
               benchDir,
               `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i}.mp4`
             );
@@ -25518,8 +25929,8 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync28(outputPath)) {
-                const stat = statSync11(outputPath);
+              if (existsSync33(outputPath)) {
+                const stat = statSync13(outputPath);
                 fileSize = stat.size;
               }
               runs.push({ elapsedMs, fileSize });
@@ -25727,15 +26138,15 @@ var docs_exports = {};
 __export(docs_exports, {
   default: () => docs_default
 });
-import { readFileSync as readFileSync16, existsSync as existsSync29 } from "fs";
-import { resolve as resolve16, dirname as dirname14, join as join27 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync34 } from "fs";
+import { resolve as resolve19, dirname as dirname14, join as join32 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath6(import.meta.url);
   const dir = dirname14(thisFile);
-  const devPath = resolve16(dir, "..", "docs");
-  const builtPath = resolve16(dir, "docs");
-  return existsSync29(devPath) ? devPath : builtPath;
+  const devPath = resolve19(dir, "..", "docs");
+  const builtPath = resolve19(dir, "docs");
+  return existsSync34(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -25826,12 +26237,12 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join27(docsDir(), entry.file);
-        if (!existsSync29(filePath)) {
+        const filePath = join32(docsDir(), entry.file);
+        if (!existsSync34(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
-        const content = readFileSync16(filePath, "utf-8");
+        const content = readFileSync22(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -26225,8 +26636,8 @@ init_updateCheck();
 var subCommands = {
   init: () => Promise.resolve().then(() => (init_init(), init_exports)).then((m) => m.default),
   dev: () => Promise.resolve().then(() => (init_dev(), dev_exports)).then((m) => m.default),
-  render: () => Promise.resolve().then(() => (init_render(), render_exports)).then((m) => m.default),
-  lint: () => Promise.resolve().then(() => (init_lint2(), lint_exports)).then((m) => m.default),
+  render: () => Promise.resolve().then(() => (init_render2(), render_exports)).then((m) => m.default),
+  lint: () => Promise.resolve().then(() => (init_lint3(), lint_exports2)).then((m) => m.default),
   info: () => Promise.resolve().then(() => (init_info(), info_exports)).then((m) => m.default),
   compositions: () => Promise.resolve().then(() => (init_compositions(), compositions_exports)).then((m) => m.default),
   benchmark: () => Promise.resolve().then(() => (init_benchmark(), benchmark_exports)).then((m) => m.default),