hyperframes 0.1.9 → 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.9" : "0.0.0-dev";
+    VERSION = true ? "0.1.11" : "0.0.0-dev";
   }
 });
 
@@ -599,6 +599,90 @@ var init_env = __esm({
   }
 });
 
+// src/telemetry/system.ts
+import { cpus, totalmem, platform, release } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statfsSync } from "fs";
+function bytesToMb(bytes) {
+  return Math.trunc(bytes / (1024 * 1024));
+}
+function getSystemMeta() {
+  if (cached) return cached;
+  const cpuInfo = cpus();
+  const firstCpu = cpuInfo[0] ?? null;
+  cached = {
+    os_release: release(),
+    cpu_count: cpuInfo.length,
+    cpu_model: firstCpu?.model?.trim() ?? null,
+    cpu_speed: firstCpu?.speed ?? null,
+    memory_total_mb: bytesToMb(totalmem()),
+    is_docker: detectDocker(),
+    is_ci: detectCI(),
+    ci_name: getCIName(),
+    is_wsl: detectWSL(),
+    is_tty: Boolean(process.stdout?.isTTY)
+  };
+  return cached;
+}
+function detectDocker() {
+  try {
+    if (existsSync2("/.dockerenv")) return true;
+    if (platform() === "linux") {
+      const cgroup = readFileSync2("/proc/1/cgroup", "utf-8");
+      if (cgroup.includes("docker") || cgroup.includes("containerd")) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function detectCI() {
+  return process.env["CI"] === "true" || process.env["CI"] === "1" || process.env["CONTINUOUS_INTEGRATION"] === "true" || process.env["GITHUB_ACTIONS"] === "true" || process.env["GITLAB_CI"] === "true" || process.env["CIRCLECI"] === "true" || process.env["JENKINS_URL"] != null || process.env["BUILDKITE"] === "true" || process.env["TRAVIS"] === "true" || false;
+}
+function getCIName() {
+  if (process.env["GITHUB_ACTIONS"] === "true") return "github_actions";
+  if (process.env["GITLAB_CI"] === "true") return "gitlab_ci";
+  if (process.env["CIRCLECI"] === "true") return "circleci";
+  if (process.env["JENKINS_URL"] != null) return "jenkins";
+  if (process.env["BUILDKITE"] === "true") return "buildkite";
+  if (process.env["TRAVIS"] === "true") return "travis";
+  if (detectCI()) return "unknown";
+  return null;
+}
+function detectWSL() {
+  if (platform() !== "linux") return false;
+  try {
+    const osRelease = release().toLowerCase();
+    if (osRelease.includes("microsoft") || osRelease.includes("wsl")) return true;
+    const procVersion = readFileSync2("/proc/version", "utf-8").toLowerCase();
+    return procVersion.includes("microsoft") || procVersion.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+function getShmSizeMb() {
+  if (platform() !== "linux") return null;
+  try {
+    const stats = statfsSync("/dev/shm");
+    return bytesToMb(stats.bsize * stats.blocks);
+  } catch {
+    return null;
+  }
+}
+function getFreeDiskMb(path = ".") {
+  try {
+    const stats = statfsSync(path);
+    return bytesToMb(stats.bsize * stats.bavail);
+  } catch {
+    return null;
+  }
+}
+var cached;
+var init_system = __esm({
+  "src/telemetry/system.ts"() {
+    "use strict";
+    cached = null;
+  }
+});
+
 // src/telemetry/client.ts
 function shouldTrack() {
   if (telemetryEnabled !== null) return telemetryEnabled;
@@ -624,6 +708,7 @@ function shouldTrack() {
 }
 function trackEvent(event, properties = {}) {
   if (!shouldTrack()) return;
+  const sys = getSystemMeta();
   eventQueue.push({
     event,
     properties: {
@@ -631,7 +716,17 @@ function trackEvent(event, properties = {}) {
       cli_version: VERSION,
       os: process.platform,
       arch: process.arch,
-      node_version: process.version
+      node_version: process.version,
+      os_release: sys.os_release,
+      cpu_count: sys.cpu_count,
+      cpu_model: sys.cpu_model ?? void 0,
+      cpu_speed: sys.cpu_speed ?? void 0,
+      memory_total_mb: sys.memory_total_mb,
+      is_docker: sys.is_docker,
+      is_ci: sys.is_ci,
+      ci_name: sys.ci_name ?? void 0,
+      is_wsl: sys.is_wsl,
+      is_tty: sys.is_tty
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
@@ -655,7 +750,7 @@ async function flush() {
   try {
     await fetch(`${POSTHOG_HOST}/batch/`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", Connection: "close" },
       body: JSON.stringify({ api_key: POSTHOG_API_KEY, batch }),
       signal: controller.signal
     });
@@ -713,6 +808,7 @@ var init_client = __esm({
     init_version();
     init_colors();
     init_env();
+    init_system();
     POSTHOG_API_KEY = "phc_zjjbX0PnWxERXrMHhkEJWj9A9BhGVLRReICgsfTMmpx";
     POSTHOG_HOST = "https://us.i.posthog.com";
     FLUSH_TIMEOUT_MS = 5e3;
@@ -732,14 +828,30 @@ function trackRenderComplete(props) {
     quality: props.quality,
     workers: props.workers,
     docker: props.docker,
-    gpu: props.gpu
+    gpu: props.gpu,
+    composition_duration_ms: props.compositionDurationMs,
+    composition_width: props.compositionWidth,
+    composition_height: props.compositionHeight,
+    total_frames: props.totalFrames,
+    speed_ratio: props.speedRatio,
+    capture_avg_ms: props.captureAvgMs,
+    capture_peak_ms: props.capturePeakMs,
+    peak_memory_mb: props.peakMemoryMb,
+    memory_free_mb: props.memoryFreeMb
   });
 }
 function trackRenderError(props) {
   trackEvent("render_error", {
     fps: props.fps,
     quality: props.quality,
-    docker: props.docker
+    docker: props.docker,
+    workers: props.workers,
+    gpu: props.gpu,
+    failed_stage: props.failedStage,
+    error_message: props.errorMessage,
+    elapsed_ms: props.elapsedMs,
+    peak_memory_mb: props.peakMemoryMb,
+    memory_free_mb: props.memoryFreeMb
   });
 }
 function trackInitTemplate(templateId) {
@@ -772,7 +884,10 @@ async function checkForUpdate(force) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    const res = await fetch(NPM_REGISTRY_URL, { signal: controller.signal });
+    const res = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Connection: "close" }
+    });
     clearTimeout(timeout);
     if (!res.ok) return fallbackResult(config.latestVersion);
     const data = await res.json();
@@ -2536,7 +2651,15 @@ var init_generators = __esm({
       { id: "warm-grain", label: "Warm Grain", hint: "Cream aesthetic with grain texture" },
       { id: "play-mode", label: "Play Mode", hint: "Playful elastic animations" },
       { id: "swiss-grid", label: "Swiss Grid", hint: "Structured grid layout" },
-      { id: "vignelli", label: "Vignelli", hint: "Bold typography with red accents" }
+      { id: "vignelli", label: "Vignelli", hint: "Bold typography with red accents" },
+      { id: "decision-tree", label: "Decision Tree", hint: "Animated flowchart with branching paths" },
+      { id: "kinetic-type", label: "Kinetic Type", hint: "Bold kinetic typography promo" },
+      {
+        id: "product-promo",
+        label: "Product Promo",
+        hint: "Multi-scene product showcase with SVG assets"
+      },
+      { id: "nyt-graph", label: "NYT Graph", hint: "Animated data chart in print editorial style" }
     ];
   }
 });
@@ -2553,13 +2676,13 @@ __export(manager_exports, {
   hasFFmpeg: () => hasFFmpeg
 });
 import { execFileSync } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, createWriteStream, rmSync } from "fs";
-import { homedir as homedir2, platform } from "os";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, createWriteStream, rmSync } from "fs";
+import { homedir as homedir2, platform as platform2 } from "os";
 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) {
@@ -2574,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);
@@ -2597,7 +2720,7 @@ function whichBinary(name) {
 }
 function findFromEnv() {
   const envPath = process.env["HYPERFRAMES_WHISPER_PATH"];
-  if (envPath && existsSync2(envPath)) {
+  if (envPath && existsSync3(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
@@ -2607,9 +2730,9 @@ function findFromSystem() {
     const path = whichBinary(name);
     if (path) return { executablePath: path, source: "system" };
   }
-  if (platform() === "darwin") {
+  if (platform2() === "darwin") {
     for (const p of ["/opt/homebrew/bin/whisper-cli", "/usr/local/bin/whisper-cli"]) {
-      if (existsSync2(p)) return { executablePath: p, source: "system" };
+      if (existsSync3(p)) return { executablePath: p, source: "system" };
     }
   }
   return void 0;
@@ -2619,15 +2742,15 @@ function findBuiltBinary() {
     join2(BUILD_DIR, "build", "bin", "whisper-cli"),
     join2(BUILD_DIR, "build", "whisper-cli")
   ]) {
-    if (existsSync2(p)) return { executablePath: p, source: "build" };
+    if (existsSync3(p)) return { executablePath: p, source: "build" };
   }
   return void 0;
 }
 function buildFromSource(onProgress) {
-  if (existsSync2(BUILD_DIR) && !findBuiltBinary()) {
+  if (existsSync3(BUILD_DIR) && !findBuiltBinary()) {
     rmSync(BUILD_DIR, { recursive: true, force: true });
   }
-  if (!existsSync2(BUILD_DIR)) {
+  if (!existsSync3(BUILD_DIR)) {
     onProgress?.("Downloading whisper.cpp...");
     mkdirSync2(join2(homedir2(), ".cache", "hyperframes", "whisper"), {
       recursive: true
@@ -2670,7 +2793,7 @@ function findWhisper() {
   return findFromEnv() ?? findFromSystem() ?? findBuiltBinary();
 }
 function getInstallInstructions() {
-  if (platform() === "darwin") {
+  if (platform2() === "darwin") {
     return "brew install whisper-cpp";
   }
   return "See https://github.com/ggml-org/whisper.cpp#building";
@@ -2687,7 +2810,7 @@ function hasCmake() {
 async function ensureWhisper(options) {
   const existing = findWhisper();
   if (existing) return existing;
-  if (platform() === "darwin" && hasBrew()) {
+  if (platform2() === "darwin" && hasBrew()) {
     options?.onProgress?.("Installing whisper-cpp via Homebrew...");
     try {
       execFileSync("brew", ["install", "whisper-cpp"], {
@@ -2709,11 +2832,11 @@ async function ensureWhisper(options) {
 }
 async function ensureModel(model = DEFAULT_MODEL, options) {
   const modelPath = join2(MODELS_DIR, `ggml-${model}.bin`);
-  if (existsSync2(modelPath)) return modelPath;
+  if (existsSync3(modelPath)) return modelPath;
   mkdirSync2(MODELS_DIR, { recursive: true });
   options?.onProgress?.(`Downloading model ${model}...`);
   await downloadFile(getModelUrl(model), modelPath);
-  if (!existsSync2(modelPath)) {
+  if (!existsSync3(modelPath)) {
     throw new Error(`Model download failed: ${model}`);
   }
   return modelPath;
@@ -2744,7 +2867,7 @@ __export(install_skills_exports, {
   default: () => install_skills_default,
   installAllSkills: () => installAllSkills
 });
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, rmSync as rmSync2, cpSync } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, rmSync as rmSync2, cpSync } from "fs";
 import { join as join3, dirname } from "path";
 import { homedir as homedir3 } from "os";
 import { execFileSync as execFileSync2 } from "child_process";
@@ -2784,7 +2907,7 @@ function gitClone(repo, dest) {
 }
 function fetchRepo(source) {
   const gitUrl = `https://github.com/${source.repo}.git`;
-  if (existsSync3(source.cache)) {
+  if (existsSync4(source.cache)) {
     try {
       execFileSync2("git", ["pull", "--ff-only"], {
         cwd: source.cache,
@@ -2794,7 +2917,7 @@ function fetchRepo(source) {
       });
     } catch {
       const skillsDir2 = join3(source.cache, source.skillsPath);
-      if (existsSync3(skillsDir2)) return skillsDir2;
+      if (existsSync4(skillsDir2)) return skillsDir2;
       rmSync2(source.cache, { recursive: true, force: true });
       gitClone(gitUrl, source.cache);
     }
@@ -2803,18 +2926,18 @@ function fetchRepo(source) {
     gitClone(gitUrl, source.cache);
   }
   const skillsDir = join3(source.cache, source.skillsPath);
-  return existsSync3(skillsDir) ? skillsDir : void 0;
+  return existsSync4(skillsDir) ? skillsDir : void 0;
 }
 function installSkillsFromDir(sourceDir, targetDir, sourceName) {
   const installed = [];
-  if (!existsSync3(sourceDir)) return installed;
+  if (!existsSync4(sourceDir)) return installed;
   const entries2 = readdirSync(sourceDir, { withFileTypes: true });
   for (const entry of entries2) {
     if (!entry.isDirectory()) continue;
     const skillFile = join3(sourceDir, entry.name, "SKILL.md");
-    if (!existsSync3(skillFile)) continue;
+    if (!existsSync4(skillFile)) continue;
     const destDir = join3(targetDir, entry.name);
-    if (existsSync3(destDir)) rmSync2(destDir, { recursive: true, force: true });
+    if (existsSync4(destDir)) rmSync2(destDir, { recursive: true, force: true });
     mkdirSync3(destDir, { recursive: true });
     cpSync(join3(sourceDir, entry.name), destDir, { recursive: true });
     installed.push({ name: entry.name, source: sourceName });
@@ -3063,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}=["']([^"']+)["']`));
@@ -3199,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);
@@ -3447,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();
@@ -3804,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)
       });
     }
@@ -3844,6 +4518,76 @@ ${right.raw}`)
       });
     }
   }
+  for (const script of scripts) {
+    const templateLiteralSelectorPattern = /(?:querySelector|querySelectorAll)\s*\(\s*`[^`]*\$\{[^}]+\}[^`]*`\s*\)/g;
+    let tlMatch;
+    while ((tlMatch = templateLiteralSelectorPattern.exec(script.content)) !== null) {
+      pushFinding({
+        code: "template_literal_selector",
+        severity: "error",
+        message: "querySelector uses a template literal variable (e.g. `${compId}`). The HTML bundler's CSS parser crashes on these. Use a hardcoded string instead.",
+        file: filePath,
+        fixHint: "Replace the template literal variable with a hardcoded string. The bundler's CSS parser cannot handle interpolated variables in script content.",
+        snippet: truncateSnippet(tlMatch[0])
+      });
+    }
+  }
+  {
+    const cssTranslateSelectors = /* @__PURE__ */ new Map();
+    const cssScaleSelectors = /* @__PURE__ */ new Map();
+    for (const style of styles) {
+      for (const [, selector, body] of style.content.matchAll(
+        /([#.][a-zA-Z0-9_-]+)\s*\{([^}]+)\}/g
+      )) {
+        const tMatch = body?.match(/transform\s*:\s*([^;]+)/);
+        if (!tMatch || !tMatch[1]) continue;
+        const transformVal = tMatch[1].trim();
+        if (/translate/i.test(transformVal)) {
+          cssTranslateSelectors.set((selector ?? "").trim(), transformVal);
+        }
+        if (/scale/i.test(transformVal)) {
+          cssScaleSelectors.set((selector ?? "").trim(), transformVal);
+        }
+      }
+    }
+    if (cssTranslateSelectors.size > 0 || cssScaleSelectors.size > 0) {
+      for (const script of scripts) {
+        if (!/gsap\.timeline/.test(script.content)) continue;
+        const windows = extractGsapWindows(script.content);
+        const conflicts = /* @__PURE__ */ new Map();
+        for (const win of windows) {
+          if (win.method === "fromTo") continue;
+          const sel = win.targetSelector;
+          const cssKey = sel.startsWith("#") || sel.startsWith(".") ? sel : `#${sel}`;
+          const translateProps = win.properties.filter(
+            (p) => ["x", "y", "xPercent", "yPercent"].includes(p)
+          );
+          const scaleProps = win.properties.filter((p) => p === "scale");
+          const cssFromTranslate = translateProps.length > 0 ? cssTranslateSelectors.get(cssKey) : void 0;
+          const cssFromScale = scaleProps.length > 0 ? cssScaleSelectors.get(cssKey) : void 0;
+          if (!cssFromTranslate && !cssFromScale) continue;
+          const existing = conflicts.get(sel) ?? {
+            cssTransform: [cssFromTranslate, cssFromScale].filter(Boolean).join(" "),
+            props: /* @__PURE__ */ new Set(),
+            raw: win.raw
+          };
+          for (const p of [...translateProps, ...scaleProps]) existing.props.add(p);
+          conflicts.set(sel, existing);
+        }
+        for (const [sel, { cssTransform, props, raw }] of conflicts) {
+          const propList = [...props].join("/");
+          pushFinding({
+            code: "gsap_css_transform_conflict",
+            severity: "warning",
+            message: `"${sel}" has CSS \`transform: ${cssTransform}\` and a GSAP tween animates ${propList}. GSAP will overwrite the full CSS transform, discarding any translateX(-50%) centering or CSS scale value.`,
+            selector: sel,
+            fixHint: `Remove the transform from CSS and use tl.fromTo('${sel}', { xPercent: -50, x: -1000 }, { xPercent: -50, x: 0 }) so GSAP owns the full transform state. tl.fromTo is exempt from this rule.`,
+            snippet: truncateSnippet(raw)
+          });
+        }
+      }
+    }
+  }
   const errorCount = findings.filter((finding) => finding.severity === "error").length;
   const warningCount = findings.length - errorCount;
   return {
@@ -3987,6 +4731,7 @@ function extractGsapWindows(script) {
       end: animation.position + meta.effectiveDuration,
       properties: meta.properties.length > 0 ? meta.properties : Object.keys(animation.properties),
       overwriteAuto: meta.overwriteAuto,
+      method: match[1] ?? "to",
       raw
     });
   }
@@ -4127,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"() {
@@ -4172,14 +4983,14 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync2, existsSync as existsSync4 } 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) {
@@ -4235,17 +5046,17 @@ function isRelativeUrl(url) {
   return !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("//") && !url.startsWith("data:") && !isAbsolute(url);
 }
 function safeReadFile(filePath) {
-  if (!existsSync4(filePath)) return null;
+  if (!existsSync10(filePath)) return null;
   try {
-    return readFileSync2(filePath, "utf-8");
+    return readFileSync9(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync4(filePath)) return null;
+  if (!existsSync10(filePath)) return null;
   try {
-    return readFileSync2(filePath);
+    return readFileSync9(filePath);
   } catch {
     return null;
   }
@@ -4432,9 +5243,9 @@ function stripJsCommentsParserSafe(source) {
   }
 }
 async function bundleToSingleHtml(projectDir, options) {
-  const indexPath = join4(projectDir, "index.html");
-  if (!existsSync4(indexPath)) throw new Error("index.html not found in project directory");
-  const rawHtml = readFileSync2(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) {
@@ -4589,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({
@@ -8443,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(
@@ -8484,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);
           }
         });
       }
@@ -16427,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 };
@@ -16692,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();
@@ -17298,8 +18122,8 @@ var init_config2 = __esm({
 });
 
 // ../engine/src/services/browserManager.ts
-import { existsSync as existsSync5, 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;
@@ -17320,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 (!existsSync5(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 (existsSync5(binary)) return binary;
+        if (existsSync11(binary)) return binary;
       }
     }
   } catch {
@@ -17906,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"() {
@@ -18025,9 +18849,9 @@ async function beginFrameCapture(page, options, frameTimeTicks, interval) {
     buffer = Buffer.from(result.screenshotData, "base64");
     lastFrameCache.set(page, buffer);
   } else {
-    const cached = lastFrameCache.get(page);
-    if (cached) {
-      buffer = cached;
+    const cached2 = lastFrameCache.get(page);
+    if (cached2) {
+      buffer = cached2;
     } else {
       const retry = await client.send("HeadlessExperimental.beginFrame", {
         frameTimeTicks: frameTimeTicks + 1e-3,
@@ -18163,10 +18987,10 @@ var init_screenshotService = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync6, 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 (!existsSync6(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;
@@ -18325,13 +19149,13 @@ async function initializeSession(session) {
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
   try {
-    const diagnosticsDir = join6(session.outputDir, "diagnostics");
-    if (!existsSync6(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(
         {
@@ -18425,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) {
@@ -18440,8 +19264,8 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync6(outputDir)) {
-    mkdirSync4(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) {
+    mkdirSync7(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
   session.onBeforeCapture = onBeforeCapture;
@@ -18486,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"]
     });
@@ -18495,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() {
@@ -18540,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 = () => {
@@ -18566,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,
@@ -18576,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,
@@ -18595,8 +19419,8 @@ var init_runFfmpeg = __esm({
 
 // ../engine/src/services/chunkEncoder.ts
 import { spawn as spawn3 } from "child_process";
-import { copyFileSync, existsSync as existsSync7, 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") {
@@ -18677,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 (!existsSync7(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 {
@@ -18695,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 = () => {
@@ -18723,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,
@@ -18734,7 +19558,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       if (code !== 0) {
-        resolve17({
+        resolve20({
           success: false,
           outputPath,
           durationMs,
@@ -18744,13 +19568,13 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync7(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,
@@ -18763,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,
@@ -18776,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 (!existsSync7(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) {
@@ -18793,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),
@@ -18808,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) {
@@ -18834,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",
@@ -18849,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) {
@@ -18873,7 +19697,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync7(outputPath) ? statSync(outputPath).size : 0;
+  const fileSize = existsSync13(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -18883,8 +19707,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   };
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config) {
-  const outputDir = dirname3(outputPath);
-  if (!existsSync7(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) {
@@ -18951,8 +19775,8 @@ var init_chunkEncoder = __esm({
 
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync8, 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 = [];
@@ -18965,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();
     })
   };
@@ -19059,8 +19883,8 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
   return args;
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
-  const outputDir = dirname4(outputPath);
-  if (!existsSync8(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();
@@ -19074,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();
   });
@@ -19118,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;
@@ -19140,7 +19964,7 @@ Process error: ${err.message}`;
           error: `FFmpeg exited with code ${exitCode}`
         };
       }
-      const fileSize = existsSync8(outputPath) ? statSync2(outputPath).size : 0;
+      const fileSize = existsSync14(outputPath) ? statSync4(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -19168,11 +19992,11 @@ function parseFrameRate(frameRateStr) {
   return parseFloat(frameRateStr) || 0;
 }
 async function extractVideoMetadata(filePath) {
-  const cached = videoMetadataCache.get(filePath);
-  if (cached) {
-    return cached;
+  const cached2 = videoMetadataCache.get(filePath);
+  if (cached2) {
+    return cached2;
   }
-  const probePromise = new Promise((resolve17, reject) => {
+  const probePromise = new Promise((resolve20, reject) => {
     const args = [
       "-v",
       "quiet",
@@ -19214,7 +20038,7 @@ async function extractVideoMetadata(filePath) {
           videoCodec: videoStream.codec_name || "unknown",
           hasAudio
         };
-        resolve17(metadata);
+        resolve20(metadata);
       } catch (parseError) {
         reject(
           new Error(
@@ -19240,11 +20064,11 @@ async function extractVideoMetadata(filePath) {
   return probePromise;
 }
 async function extractAudioMetadata(filePath) {
-  const cached = audioMetadataCache.get(filePath);
-  if (cached) {
-    return cached;
+  const cached2 = audioMetadataCache.get(filePath);
+  if (cached2) {
+    return cached2;
   }
-  const probePromise = new Promise((resolve17, reject) => {
+  const probePromise = new Promise((resolve20, reject) => {
     const args = [
       "-v",
       "quiet",
@@ -19283,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(
@@ -19318,9 +20142,9 @@ var init_ffprobe = __esm({
 });
 
 // ../engine/src/utils/urlDownloader.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync9, 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) {
@@ -19331,19 +20155,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync9(cachedPath)) {
+  if (cachedPath && existsSync15(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync9(destDir)) {
-    mkdirSync7(destDir, { recursive: true });
+  if (!existsSync15(destDir)) {
+    mkdirSync10(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join8(destDir, filename);
-  if (existsSync9(localPath)) {
+  const localPath = join13(destDir, filename);
+  if (existsSync15(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -19391,8 +20215,8 @@ var init_urlDownloader = __esm({
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync10, 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);
@@ -19419,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 (!existsSync10(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),
@@ -19438,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 = () => {
@@ -19469,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,
@@ -19508,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 (!existsSync10(videoPath)) {
+        if (!existsSync16(videoPath)) {
           return { error: { videoId: video.id, error: `Video file not found: ${videoPath}` } };
         }
         let videoDuration = video.end - video.start;
@@ -19669,7 +20493,7 @@ var init_videoFrameExtractor = __esm({
       }
       cleanup() {
         for (const video of this.videos.values()) {
-          if (existsSync10(video.extracted.outputDir)) {
+          if (existsSync16(video.extracted.outputDir)) {
             rmSync3(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -19700,10 +20524,10 @@ function createFrameDataUriCache(cacheLimit) {
     return dataUri;
   }
   async function get(framePath) {
-    const cached = cache.get(framePath);
-    if (cached) {
-      remember(framePath, cached);
-      return cached;
+    const cached2 = cache.get(framePath);
+    if (cached2) {
+      remember(framePath, cached2);
+      return cached2;
     }
     const existing = inFlight.get(framePath);
     if (existing) {
@@ -19771,8 +20595,8 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync11, 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);
@@ -19822,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 (!existsSync11(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));
@@ -19849,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 (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -19885,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 (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -19928,8 +20752,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       error: result2.error
     };
   }
-  const outputDir = dirname5(outputPath);
-  if (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const outputDir = dirname6(outputPath);
+  if (!existsSync17(outputDir)) mkdirSync12(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i) => {
@@ -19990,7 +20814,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync11(workDir)) mkdirSync9(workDir, { recursive: true });
+  if (!existsSync17(workDir)) mkdirSync12(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -20000,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 {
@@ -20012,7 +20836,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync11(srcPath)) {
+        if (!existsSync17(srcPath)) {
           errors.push(`Source not found: ${element.id}`);
           return;
         }
@@ -20023,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,
@@ -20040,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,
@@ -20092,10 +20916,10 @@ var init_audioMixer = __esm({
 });
 
 // ../engine/src/services/parallelCoordinator.ts
-import { cpus, freemem, totalmem } from "os";
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readdirSync as readdirSync5 } from "fs";
+import { cpus as cpus2, freemem, totalmem as totalmem2 } from "os";
+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;
@@ -20111,9 +20935,9 @@ function calculateOptimalWorkers(totalFrames, requested, config) {
     return Math.max(MIN_WORKERS, Math.min(effectiveMaxWorkers, requested));
   }
   if (totalFrames < MIN_FRAMES_PER_WORKER * 2) return 1;
-  const cpuCount = cpus().length;
+  const cpuCount = cpus2().length;
   const cpuBasedWorkers = Math.max(1, cpuCount - 2);
-  const totalMemoryMB = Math.round(totalmem() / (1024 * 1024));
+  const totalMemoryMB = Math.round(totalmem2() / (1024 * 1024));
   const memoryBasedWorkers = Math.max(1, Math.floor(totalMemoryMB * 0.5 / MEMORY_PER_WORKER_MB));
   const frameBasedWorkers = Math.floor(totalFrames / MIN_FRAMES_PER_WORKER);
   const optimal = Math.min(cpuBasedWorkers, memoryBasedWorkers, frameBasedWorkers);
@@ -20138,7 +20962,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join11(workDir, `worker-${i}`)
+      outputDir: join16(workDir, `worker-${i}`)
     });
   }
   return tasks;
@@ -20146,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 (!existsSync12(task.outputDir)) mkdirSync10(task.outputDir, { recursive: true });
+  if (!existsSync18(task.outputDir)) mkdirSync13(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -20236,17 +21060,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync12(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 (!existsSync12(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 {
@@ -20273,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 readFileSync3, existsSync as existsSync13, 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";
@@ -20306,8 +21130,8 @@ var init_src2 = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync4 } 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) {
@@ -20319,7 +21143,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate)) {
+    if (existsSync20(candidate)) {
       return candidate;
     }
   }
@@ -20330,12 +21154,12 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync14(manifestPath)) {
+  if (!existsSync20(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync4(manifestPath, "utf8");
+  const manifestRaw = readFileSync11(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -20343,11 +21167,11 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Invalid manifest at ${manifestPath}; missing iife artifact or sha256.`
     );
   }
-  const runtimePath = resolve4(dirname6(manifestPath), runtimeFileName);
-  if (!existsSync14(runtimePath)) {
+  const runtimePath = resolve7(dirname7(manifestPath), runtimeFileName);
+  if (!existsSync20(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync4(runtimePath, "utf8");
+  const runtimeSource = readFileSync11(runtimePath, "utf8");
   const runtimeSha = createHash2("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -20366,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 readFileSync5, existsSync as existsSync15, 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;
@@ -20451,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 && existsSync15(compiledPath) && statSync4(compiledPath).isFile()
+      compiledPath && existsSync21(compiledPath) && statSync6(compiledPath).isFile()
     );
-    const filePath = hasCompiledFile ? compiledPath : join13(projectDir, relativePath);
-    if (!existsSync15(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 = readFileSync5(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 = readFileSync5(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()
@@ -20490,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",
@@ -20924,8 +21748,8 @@ var init_deterministicFonts = __esm({
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync6, existsSync as existsSync16, 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) {
@@ -20936,16 +21760,16 @@ function dedupeElementsById(elements) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync16(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 (!existsSync16(filePath)) {
+  if (!existsSync22(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractVideoMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -21008,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 (!existsSync16(filePath)) {
+    if (!existsSync22(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync6(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 });
@@ -21024,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(
@@ -21208,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 (existsSync16(filePath)) {
-        compHtml = readFileSync6(filePath, "utf-8");
+      const filePath = resolve8(projectDir, srcPath);
+      if (existsSync22(filePath)) {
+        compHtml = readFileSync13(filePath, "utf-8");
       }
     }
     if (!compHtml) {
@@ -21330,7 +22154,7 @@ ${html}
 </html>`;
 }
 async function compileForRender(projectDir, htmlPath, downloadDir) {
-  const rawHtml = readFileSync6(htmlPath, "utf-8");
+  const rawHtml = readFileSync13(htmlPath, "utf-8");
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
@@ -21518,15 +22342,15 @@ var init_logger = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync15,
   rmSync as rmSync5,
-  readFileSync as readFileSync7,
-  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";
@@ -21582,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 = {
@@ -21611,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) {
@@ -21654,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;
@@ -21665,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";
@@ -21683,28 +22507,28 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync17(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 (!existsSync17(htmlPath)) {
+    let htmlPath = join20(projectDir, entryFile);
+    if (!existsSync23(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync7(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 (!existsSync17(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(
-        readFileSync7(projectIndexPath, "utf-8"),
+        readFileSync14(projectIndexPath, "utf-8"),
         entryFile
       );
       if (!standaloneHtml) {
@@ -21712,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
@@ -21721,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));
@@ -21750,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();
@@ -21763,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
@@ -21795,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;
@@ -21892,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();
@@ -21924,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
@@ -21946,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 (!existsSync17(framesDir)) mkdirSync12(framesDir, { recursive: true });
+    const framesDir = join20(workDir, "captured-frames");
+    if (!existsSync23(framesDir)) mkdirSync15(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -21962,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;
@@ -22231,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,
@@ -22240,8 +23064,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync17(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 {
@@ -22317,7 +23141,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync17(workDir)) rmSync5(workDir, { recursive: true, force: true });
+          if (existsSync23(workDir)) rmSync5(workDir, { recursive: true, force: true });
         },
         log
       );
@@ -22370,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 existsSync18, readFileSync as readFileSync8, 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;
@@ -22407,28 +23223,28 @@ function pickEntryFile(files, preferredEntryFile) {
   return null;
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
-  const absProjectDir = resolve7(projectDir);
-  if (!existsSync18(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 (existsSync18(absoluteEntryPath) && statSync5(absoluteEntryPath).isFile()) {
+    if (existsSync24(absoluteEntryPath) && statSync7(absoluteEntryPath).isFile()) {
       return {
         entryFile,
-        html: readFileSync8(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) {
@@ -22470,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 existsSync19,
-  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;
@@ -22516,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 (!existsSync19(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 (!existsSync19(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 } } };
@@ -22552,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: {
@@ -22568,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)
@@ -22673,8 +23490,8 @@ function createRenderHandlers(options = {}) {
       rendersDir,
       log
     );
-    const outputDir = dirname9(absoluteOutputPath);
-    if (!existsSync19(outputDir)) mkdirSync13(outputDir, { recursive: true });
+    const outputDir = dirname10(absoluteOutputPath);
+    if (!existsSync25(outputDir)) mkdirSync16(outputDir, { recursive: true });
     log.info("render started", {
       requestId,
       projectDir: input.projectDir,
@@ -22684,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,
@@ -22699,7 +23517,7 @@ function createRenderHandlers(options = {}) {
           log.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync19(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}`;
@@ -22745,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;
@@ -22781,12 +23599,13 @@ function createRenderHandlers(options = {}) {
         rendersDir,
         log
       );
-      const outputDir = dirname9(absoluteOutputPath);
-      if (!existsSync19(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,
@@ -22816,7 +23635,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync19(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 });
@@ -22874,11 +23693,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync19(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",
@@ -22890,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);
@@ -22932,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({
@@ -23008,9 +23827,9 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync20, 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;
@@ -23028,17 +23847,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync20(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync26(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync20(envPath)) {
+  if (envPath && existsSync26(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync20(CACHE_DIR)) {
+  if (!existsSync26(CACHE_DIR)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR });
@@ -23050,7 +23869,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync20(p)) {
+    if (existsSync26(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -23070,21 +23889,21 @@ async function findBrowser() {
 async function ensureBrowser(options) {
   const existing = await findBrowser();
   if (existing) return existing;
-  const platform2 = detectBrowserPlatform();
-  if (!platform2) {
+  const platform4 = detectBrowserPlatform();
+  if (!platform4) {
     throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`);
   }
   const installed = await install({
     cacheDir: CACHE_DIR,
     browser: Browser.CHROMEHEADLESSSHELL,
     buildId: CHROME_VERSION,
-    platform: platform2,
+    platform: platform4,
     downloadProgressCallback: options?.onProgress
   });
   return { executablePath: installed.executablePath, source: "download" };
 }
 function clearBrowser() {
-  if (!existsSync20(CACHE_DIR)) {
+  if (!existsSync26(CACHE_DIR)) {
     return false;
   }
   rmSync7(CACHE_DIR, { recursive: true, force: true });
@@ -23095,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",
@@ -23110,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 existsSync21, readFileSync as readFileSync9, 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 (existsSync21(resolve10(builtPath, "index.html"))) return builtPath;
-  const devPath = resolve10(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync21(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 (existsSync21(builtPath)) return builtPath;
-  const devPath = resolve10(
+  const builtPath = resolve13(__dirname, "hyperframe-runtime.js");
+  if (existsSync27(builtPath)) return builtPath;
+  const devPath = resolve13(
     __dirname,
     "..",
     "..",
@@ -23133,96 +23952,97 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync21(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 (!existsSync21(filePath) || !statSync7(filePath).isFile()) return null;
-  const mime = getMimeType(filePath);
-  const content = readFileSync9(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) || !existsSync21(compFile) || !statSync7(compFile).isFile()) {
-    return null;
-  }
-  let rawComp = readFileSync9(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 (!existsSync21(nestedFile)) return before2 + srcAttr + after2;
-      const nestedRaw = readFileSync9(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 (!existsSync21(runtimePath)) return c2.text("runtime not built", 404);
-    return c2.body(readFileSync9(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(() => {
         });
@@ -23233,214 +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 (!existsSync21(file)) return c2.text("not found", 404);
-      bundled = readFileSync9(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) || !existsSync21(file) || !statSync7(file).isFile()) {
-      return c2.text("not found", 404);
-    }
-    const mime = getMimeType(file);
-    const content = readFileSync9(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) || !existsSync21(file)) {
-      return c2.text("not found", 404);
-    }
-    const content = readFileSync9(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 (!existsSync21(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 (!existsSync21(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 job = createRenderJob2({ fps: 30, quality: "standard" });
-        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;
-        }
-      } catch (err) {
-        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 || !existsSync21(job.outputPath)) {
-      return c2.json({ error: "not found" }, 404);
-    }
-    const content = readFileSync9(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 (!existsSync21(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(readFileSync9(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();
   }
 });
 
@@ -23450,8 +24105,8 @@ __export(dev_exports, {
   default: () => dev_default
 });
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync22, 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) {
@@ -23489,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 (existsSync22(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 (!existsSync22(symlinkPath)) {
+    if (!existsSync28(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23516,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"]
@@ -23550,18 +24205,18 @@ async function runDevMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync22(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 {
@@ -23569,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 (existsSync22(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 (!existsSync22(symlinkPath)) {
+    if (!existsSync28(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23621,13 +24276,13 @@ async function runLocalStudioMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync22(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) {
@@ -23658,6 +24313,9 @@ async function runEmbeddedMode(dir, startPort) {
   console.log(`  ${c.dim("Project")}   ${c.accent(projectName)}`);
   console.log(`  ${c.dim("Studio")}    ${c.accent(url)}`);
   console.log();
+  console.log(`  ${c.dim("Edit with your AI agent \u2014 it has HyperFrames skills installed.")}`);
+  console.log(`  ${c.dim("Changes reload automatically in the studio.")}`);
+  console.log();
   console.log(`  ${c.dim("Press Ctrl+C to stop")}`);
   console.log();
   import("open").then((mod) => mod.default(`${url}#project/${projectName}`)).catch(() => {
@@ -23680,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);
@@ -23727,17 +24385,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync23, 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 (!existsSync23(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 (!existsSync23(indexPath)) {
+  if (!existsSync29(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -23826,17 +24484,18 @@ var render_exports = {};
 __export(render_exports, {
   default: () => render_default
 });
-import { existsSync as existsSync24, mkdirSync as mkdirSync16, statSync as statSync9 } from "fs";
-import { cpus as cpus2 } from "os";
-import { resolve as resolve13, dirname as dirname12, join as join22 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync18, statSync as statSync11 } from "fs";
+import { cpus as cpus3, freemem as freemem3 } from "os";
+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));
 }
 async function renderDocker(projectDir, outputPath, options) {
   const producer = await loadProducer();
   const startTime = Date.now();
+  let job;
   try {
-    const job = producer.createRenderJob({
+    job = producer.createRenderJob({
       fps: options.fps,
       quality: options.quality,
       format: options.format,
@@ -23845,24 +24504,10 @@ async function renderDocker(projectDir, outputPath, options) {
     });
     await producer.executeRenderJob(job, projectDir, outputPath);
   } catch (error) {
-    trackRenderError({
-      fps: options.fps,
-      quality: options.quality,
-      docker: true
-    });
-    const message = error instanceof Error ? error.message : String(error);
-    errorBox("Render failed", message, "Check Docker is running: docker info");
-    process.exit(1);
+    handleRenderError(error, options, startTime, true, "Check Docker is running: docker info");
   }
   const elapsed = Date.now() - startTime;
-  trackRenderComplete({
-    durationMs: elapsed,
-    fps: options.fps,
-    quality: options.quality,
-    workers: options.workers,
-    docker: true,
-    gpu: options.gpu
-  });
+  trackRenderMetrics(job, elapsed, options, true);
   printRenderComplete(outputPath, elapsed, options.quiet);
 }
 async function renderLocal(projectDir, outputPath, options) {
@@ -23884,31 +24529,59 @@ async function renderLocal(projectDir, outputPath, options) {
   try {
     await producer.executeRenderJob(job, projectDir, outputPath, onProgress);
   } catch (error) {
-    trackRenderError({
-      fps: options.fps,
-      quality: options.quality,
-      docker: false
-    });
-    const message = error instanceof Error ? error.message : String(error);
-    errorBox("Render failed", message, "Try --docker for containerized rendering");
-    process.exit(1);
+    handleRenderError(error, options, startTime, false, "Try --docker for containerized rendering");
   }
   const elapsed = Date.now() - startTime;
+  trackRenderMetrics(job, elapsed, options, false);
+  printRenderComplete(outputPath, elapsed, options.quiet);
+}
+function getMemorySnapshot() {
+  return {
+    peakMemoryMb: bytesToMb(process.memoryUsage.rss()),
+    memoryFreeMb: bytesToMb(freemem3())
+  };
+}
+function handleRenderError(error, options, startTime, docker, hint) {
+  const message = error instanceof Error ? error.message : String(error);
+  trackRenderError({
+    fps: options.fps,
+    quality: options.quality,
+    docker,
+    workers: options.workers,
+    gpu: options.gpu,
+    elapsedMs: Date.now() - startTime,
+    errorMessage: message,
+    ...getMemorySnapshot()
+  });
+  errorBox("Render failed", message, hint);
+  process.exit(1);
+}
+function trackRenderMetrics(job, elapsedMs, options, docker) {
+  const perf = job.perfSummary;
+  const compositionDurationMs = perf ? Math.round(perf.compositionDurationSeconds * 1e3) : void 0;
+  const speedRatio = compositionDurationMs && compositionDurationMs > 0 && elapsedMs > 0 ? Math.round(compositionDurationMs / elapsedMs * 100) / 100 : void 0;
   trackRenderComplete({
-    durationMs: elapsed,
+    durationMs: elapsedMs,
     fps: options.fps,
     quality: options.quality,
     workers: options.workers,
-    docker: false,
-    gpu: options.gpu
+    docker,
+    gpu: options.gpu,
+    compositionDurationMs,
+    compositionWidth: perf?.resolution.width,
+    compositionHeight: perf?.resolution.height,
+    totalFrames: perf?.totalFrames,
+    speedRatio,
+    captureAvgMs: perf?.captureAvgMs,
+    capturePeakMs: perf?.capturePeakMs,
+    ...getMemorySnapshot()
   });
-  printRenderComplete(outputPath, elapsed, options.quiet);
 }
 function printRenderComplete(outputPath, elapsedMs, quiet) {
   if (quiet) return;
   let fileSize = "unknown";
-  if (existsSync24(outputPath)) {
-    const stat = statSync9(outputPath);
+  if (existsSync30(outputPath)) {
+    const stat = statSync11(outputPath);
     fileSize = formatBytes(stat.size);
   }
   const duration = formatDuration(elapsedMs);
@@ -23917,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();
@@ -23927,10 +24600,11 @@ var init_render = __esm({
     init_format();
     init_progress();
     init_events();
+    init_system();
     VALID_FPS = /* @__PURE__ */ new Set([24, 30, 60]);
     VALID_QUALITY = /* @__PURE__ */ new Set(["draft", "standard", "high"]);
     VALID_FORMAT = /* @__PURE__ */ new Set(["mp4", "webm"]);
-    CPU_CORE_COUNT = cpus2().length;
+    CPU_CORE_COUNT = cpus3().length;
     render_default = defineCommand({
       meta: {
         name: "render",
@@ -24012,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;
@@ -24101,17 +24778,17 @@ __export(transcribe_exports, {
   transcribe: () => transcribe
 });
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync10, 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],
@@ -24134,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],
@@ -24154,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);
@@ -24170,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,
     [
@@ -24188,10 +24865,10 @@ async function transcribe(inputPath, outputDir, options) {
     { stdio: "ignore", timeout: 3e5 }
   );
   const transcriptPath = `${outputBase}.json`;
-  if (!existsSync25(transcriptPath)) {
+  if (!existsSync31(transcriptPath)) {
     throw new Error("Whisper did not produce output. Check the input file.");
   }
-  const transcript = JSON.parse(readFileSync10(transcriptPath, "utf-8"));
+  const transcript = JSON.parse(readFileSync17(transcriptPath, "utf-8"));
   const segments = transcript.transcription ?? [];
   let wordCount = 0;
   let maxEnd = 0;
@@ -24204,7 +24881,7 @@ async function transcribe(inputPath, outputDir, options) {
   }
   if (wavPath !== inputPath) {
     try {
-      unlinkSync2(wavPath);
+      unlinkSync3(wavPath);
     } catch {
     }
   }
@@ -24230,15 +24907,15 @@ __export(init_exports, {
   default: () => init_default
 });
 import {
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync20,
   copyFileSync as copyFileSync3,
   cpSync as cpSync2,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync11,
-  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) {
@@ -24359,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 existsSync26(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]);
@@ -24373,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 = readFileSync11(file, "utf-8");
+    let content = readFileSync18(file, "utf-8");
     if (videoFilename) {
       content = content.replaceAll("__VIDEO_SRC__", videoFilename);
     } else {
@@ -24386,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(readFileSync11(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 ?? []) {
@@ -24412,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 = readFileSync11(file, "utf-8");
+    let content = readFileSync18(file, "utf-8");
     const scriptBlocks = content.match(/<script>[\s\S]*?<\/script>/g) ?? [];
     let scriptMatch = null;
     let transcriptMatch = null;
@@ -24426,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");
     }
   }
 }
@@ -24483,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);
@@ -24492,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) {
@@ -24505,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,
@@ -24531,23 +25208,23 @@ function scaffoldProject(destDir, name, templateId, localVideoName, durationSeco
     "utf-8"
   );
   const sharedDir = getSharedTemplateDir();
-  if (existsSync26(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 (existsSync26(skillsSrcDir)) {
-    const projectSkills = ["compose-video", "captions"];
+  if (existsSync32(skillsSrcDir)) {
+    const projectSkills = ["hyperframes-compose", "hyperframes-captions"];
     for (const skill of projectSkills) {
-      const src = join24(skillsSrcDir, skill);
-      if (existsSync26(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 });
       }
     }
@@ -24576,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 {
@@ -24663,18 +25340,18 @@ Examples:
           }
           const templateId2 = resolvedTemplate;
           const name2 = args.name ?? "my-video";
-          const destDir2 = resolve14(name2);
-          if (existsSync26(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 (!existsSync26(videoPath)) {
+            const videoPath = resolve17(videoFlag);
+            if (!existsSync32(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -24687,13 +25364,13 @@ Examples:
             );
           }
           if (audioFlag) {
-            const audioPath = resolve14(audioFlag);
-            if (!existsSync26(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) {
@@ -24714,35 +25391,34 @@ Examples:
           }
           scaffoldProject(destDir2, basename5(destDir2), templateId2, localVideoName2, videoDuration2);
           trackInitTemplate(templateId2);
-          const transcriptFile2 = resolve14(destDir2, "transcript.json");
-          if (existsSync26(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();
-          console.log("Next steps:");
-          console.log(
-            `  ${c.accent(`cd ${name2}`)} && ${c.accent("npx hyperframes dev")}      ${c.dim("# preview in studio")}`
-          );
-          console.log(
-            `  ${c.accent(`cd ${name2}`)} && ${c.accent("npx hyperframes render")}   ${c.dim("# render to MP4")}`
-          );
+          console.log("Get started:");
+          console.log();
+          console.log(`  ${c.accent("1.")} Open this project with your AI coding agent:`);
           console.log(
-            `  ${c.accent("npx hyperframes docs")} ${c.dim("<topic>")}              ${c.dim("# learn composition syntax")}`
+            `     ${c.accent(`cd ${name2}`)} then start ${c.accent("Claude Code")}, ${c.accent("Cursor")}, or your preferred agent`
           );
           console.log(
-            `    ${c.dim("topics: data-attributes, gsap, compositions, rendering, templates, troubleshooting")}`
+            `     ${c.dim("AI skills are installed \u2014 your agent knows how to create and edit compositions.")}`
           );
           console.log();
-          console.log(
-            `  ${c.dim("AI skills installed \u2014 open this folder in your AI coding agent to get started.")}`
-          );
+          console.log(`  ${c.accent("2.")} Preview in the browser:`);
+          console.log(`     ${c.accent(`cd ${name2}`)} && ${c.accent("npx hyperframes dev")}`);
+          console.log();
+          console.log(`  ${c.accent("3.")} Render to MP4 when ready:`);
+          console.log(`     ${c.accent(`cd ${name2}`)} && ${c.accent("npx hyperframes render")}`);
+          console.log();
           console.log(`  ${c.dim("Full docs: hyperframes.heygen.com")}`);
           return;
         }
@@ -24763,8 +25439,8 @@ Examples:
           }
           name = nameResult;
         }
-        const destDir = resolve14(name);
-        if (existsSync26(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
@@ -24779,13 +25455,13 @@ Examples:
         let videoDuration;
         let isAudioOnly = false;
         if (videoFlag) {
-          const videoPath = resolve14(videoFlag);
-          if (!existsSync26(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;
@@ -24815,7 +25491,7 @@ Examples:
               validate(val) {
                 const trimmed = val?.trim();
                 if (!trimmed) return "Please enter a file path";
-                if (!existsSync26(resolve14(trimmed))) return "File not found";
+                if (!existsSync32(resolve17(trimmed))) return "File not found";
                 return void 0;
               }
             });
@@ -24823,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))}`);
             }
           }
@@ -24900,15 +25576,19 @@ Examples:
         }
         scaffoldProject(destDir, name, templateId, localVideoName, videoDuration);
         trackInitTemplate(templateId);
-        const transcriptFile = resolve14(destDir, "transcript.json");
-        if (existsSync26(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.
+${c.dim("     AI skills are installed \u2014 your agent knows how to create and edit compositions.")}`
+        );
         await nextStepLoop(destDir);
       }
     });
@@ -24916,17 +25596,17 @@ Examples:
 });
 
 // src/commands/lint.ts
-var lint_exports = {};
-__export(lint_exports, {
+var lint_exports2 = {};
+__export(lint_exports2, {
   default: () => lint_default
 });
-import { readFileSync as readFileSync12 } 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();
@@ -24938,7 +25618,7 @@ var init_lint2 = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync12(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));
@@ -24987,16 +25667,16 @@ var info_exports = {};
 __export(info_exports, {
   default: () => info_default
 });
-import { readFileSync as readFileSync13, 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;
@@ -25020,7 +25700,7 @@ var init_info = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync13(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));
@@ -25071,7 +25751,7 @@ var compositions_exports = {};
 __export(compositions_exports, {
   default: () => compositions_default
 });
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 function parseCompositions(html) {
   const parser = new DOMParser();
   const doc = parser.parseFromString(html, "text/html");
@@ -25128,7 +25808,7 @@ var init_compositions = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync14(project.indexPath, "utf-8");
+        const html = readFileSync21(project.indexPath, "utf-8");
         ensureDOMParser();
         const compositions = parseCompositions(html);
         if (compositions.length === 0) {
@@ -25164,8 +25844,8 @@ var benchmark_exports = {};
 __export(benchmark_exports, {
   default: () => benchmark_default
 });
-import { existsSync as existsSync27, 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"() {
@@ -25202,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();
@@ -25235,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`
             );
@@ -25249,8 +25929,8 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync27(outputPath)) {
-                const stat = statSync11(outputPath);
+              if (existsSync33(outputPath)) {
+                const stat = statSync13(outputPath);
                 fileSize = stat.size;
               }
               runs.push({ elapsedMs, fileSize });
@@ -25458,15 +26138,15 @@ var docs_exports = {};
 __export(docs_exports, {
   default: () => docs_default
 });
-import { readFileSync as readFileSync15, existsSync as existsSync28 } 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 existsSync28(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));
@@ -25557,12 +26237,12 @@ var init_docs = __esm({
           }
           process.exit(1);
         }
-        const filePath = join27(docsDir(), entry.file);
-        if (!existsSync28(filePath)) {
+        const filePath = join32(docsDir(), entry.file);
+        if (!existsSync34(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
-        const content = readFileSync15(filePath, "utf-8");
+        const content = readFileSync22(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -25576,6 +26256,7 @@ __export(doctor_exports, {
   default: () => doctor_default
 });
 import { execSync as execSync3 } from "child_process";
+import { freemem as freemem4, platform as platform3 } from "os";
 function checkFFmpeg() {
   const path = findFFmpeg();
   if (path) {
@@ -25653,6 +26334,67 @@ function checkVersion() {
 function checkNode() {
   return { ok: true, detail: `${process.version} (${process.platform} ${process.arch})` };
 }
+function checkCPU() {
+  const sys = getSystemMeta();
+  const model = sys.cpu_model ?? "Unknown";
+  const speedStr = sys.cpu_speed ? ` @ ${sys.cpu_speed}MHz` : "";
+  return { ok: true, detail: `${sys.cpu_count} cores \xB7 ${model}${speedStr}` };
+}
+function checkMemory() {
+  const sys = getSystemMeta();
+  const freeMb = bytesToMb(freemem4());
+  const totalGb = (sys.memory_total_mb / 1024).toFixed(1);
+  const freeGb = (freeMb / 1024).toFixed(1);
+  if (freeMb < 2048) {
+    return {
+      ok: false,
+      detail: `${totalGb} GB total \xB7 ${freeGb} GB free`,
+      hint: "Low memory \u2014 renders may fail. Close other apps or increase RAM."
+    };
+  }
+  return { ok: true, detail: `${totalGb} GB total \xB7 ${freeGb} GB free` };
+}
+function checkShm() {
+  const shmMb = getShmSizeMb();
+  if (shmMb === null) {
+    return { ok: true, detail: "N/A (non-Linux)" };
+  }
+  if (shmMb < 256) {
+    return {
+      ok: false,
+      detail: `${shmMb} MB`,
+      hint: "Chrome needs \u2265256 MB. Use: docker run --shm-size=512m"
+    };
+  }
+  return { ok: true, detail: `${shmMb} MB` };
+}
+function checkDisk() {
+  const freeMb = getFreeDiskMb(".");
+  if (freeMb === null) {
+    return { ok: true, detail: "Unable to check" };
+  }
+  const freeGb = (freeMb / 1024).toFixed(1);
+  if (freeMb < 1024) {
+    return {
+      ok: false,
+      detail: `${freeGb} GB free`,
+      hint: "Low disk space \u2014 renders produce large temp files."
+    };
+  }
+  return { ok: true, detail: `${freeGb} GB free` };
+}
+function checkEnvironment() {
+  const sys = getSystemMeta();
+  const parts = [];
+  if (sys.is_docker) parts.push("Docker");
+  if (sys.is_wsl) parts.push("WSL");
+  if (sys.is_ci) parts.push(`CI (${sys.ci_name ?? "detected"})`);
+  if (!sys.is_tty) parts.push("non-TTY");
+  if (parts.length === 0) {
+    return { ok: true, detail: "Native terminal" };
+  }
+  return { ok: true, detail: parts.join(" \xB7 ") };
+}
 var doctor_default;
 var init_doctor = __esm({
   "src/commands/doctor.ts"() {
@@ -25663,6 +26405,7 @@ var init_doctor = __esm({
     init_ffmpeg();
     init_version();
     init_updateCheck();
+    init_system();
     doctor_default = defineCommand({
       meta: { name: "doctor", description: "Check system dependencies and environment" },
       args: {},
@@ -25673,12 +26416,21 @@ var init_doctor = __esm({
         const checks = [
           { name: "Version", run: checkVersion },
           { name: "Node.js", run: checkNode },
+          { name: "CPU", run: checkCPU },
+          { name: "Memory", run: checkMemory },
+          { name: "Disk", run: checkDisk }
+        ];
+        if (platform3() === "linux") {
+          checks.push({ name: "/dev/shm", run: checkShm });
+        }
+        checks.push(
+          { name: "Environment", run: checkEnvironment },
           { name: "FFmpeg", run: checkFFmpeg },
           { name: "FFprobe", run: checkFFprobe },
           { name: "Chrome", run: checkChrome },
           { name: "Docker", run: checkDocker },
           { name: "Docker running", run: checkDockerRunning }
-        ];
+        );
         let allOk = true;
         for (const check of checks) {
           const result = await check.run();
@@ -25877,14 +26629,15 @@ init_version();
 init_config();
 init_client();
 init_events();
+init_system();
 
 // src/cli.ts
 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),