hyperframes 0.1.8 → 0.1.10

package/dist/cli.js

@@ -422,7 +422,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.1.8" : "0.0.0-dev";
+    VERSION = true ? "0.1.10" : "0.0.0-dev";
   }
 });
 
@@ -599,6 +599,97 @@ var init_env = __esm({
   }
 });
 
+// src/telemetry/system.ts
+var system_exports = {};
+__export(system_exports, {
+  bytesToMb: () => bytesToMb,
+  getFreeDiskMb: () => getFreeDiskMb,
+  getShmSizeMb: () => getShmSizeMb,
+  getSystemMeta: () => getSystemMeta
+});
+import { cpus, totalmem, platform, release } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statfsSync } from "fs";
+function bytesToMb(bytes) {
+  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 +715,7 @@ function shouldTrack() {
 }
 function trackEvent(event, properties = {}) {
   if (!shouldTrack()) return;
+  const sys = getSystemMeta();
   eventQueue.push({
     event,
     properties: {
@@ -631,7 +723,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 +757,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 +815,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;
@@ -722,6 +825,14 @@ var init_client = __esm({
 });
 
 // src/telemetry/events.ts
+var events_exports = {};
+__export(events_exports, {
+  trackBrowserInstall: () => trackBrowserInstall,
+  trackCommand: () => trackCommand,
+  trackInitTemplate: () => trackInitTemplate,
+  trackRenderComplete: () => trackRenderComplete,
+  trackRenderError: () => trackRenderError
+});
 function trackCommand(command2) {
   trackEvent("cli_command", { command: command2 });
 }
@@ -732,14 +843,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 +899,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 +2666,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,8 +2691,8 @@ __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";
@@ -2597,7 +2735,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 +2745,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 +2757,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 +2808,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 +2825,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 +2847,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 +2882,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 +2922,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 +2932,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 +2941,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 });
@@ -3844,6 +3982,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 +4195,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
     });
   }
@@ -4172,7 +4381,7 @@ var init_staticGuard = __esm({
 });
 
 // ../core/src/compiler/htmlBundler.ts
-import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
 import { join as join4, resolve as resolve2, isAbsolute, sep } from "path";
 import * as cheerio from "cheerio";
 import { transformSync } from "esbuild";
@@ -4235,17 +4444,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 (!existsSync5(filePath)) return null;
   try {
-    return readFileSync2(filePath, "utf-8");
+    return readFileSync3(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function safeReadFileBuffer(filePath) {
-  if (!existsSync4(filePath)) return null;
+  if (!existsSync5(filePath)) return null;
   try {
-    return readFileSync2(filePath);
+    return readFileSync3(filePath);
   } catch {
     return null;
   }
@@ -4433,8 +4642,8 @@ 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");
+  if (!existsSync5(indexPath)) throw new Error("index.html not found in project directory");
+  const rawHtml = readFileSync3(indexPath, "utf-8");
   const compiled = await compileHtml(rawHtml, projectDir, options?.probeMediaDuration);
   const staticGuard = validateHyperframeHtmlContract(compiled);
   if (!staticGuard.isValid) {
@@ -17298,7 +17507,7 @@ var init_config2 = __esm({
 });
 
 // ../engine/src/services/browserManager.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
 async function getPuppeteer() {
@@ -17321,7 +17530,7 @@ function resolveHeadlessShellPath(config) {
     return process.env.PRODUCER_HEADLESS_SHELL_PATH;
   }
   const baseDir = join5(homedir4(), ".cache", "puppeteer", "chrome-headless-shell");
-  if (!existsSync5(baseDir)) return void 0;
+  if (!existsSync6(baseDir)) return void 0;
   try {
     const versions = readdirSync2(baseDir).sort().reverse();
     for (const version of versions) {
@@ -17332,7 +17541,7 @@ function resolveHeadlessShellPath(config) {
         join5(baseDir, version, "chrome-headless-shell-win64", "chrome-headless-shell.exe")
       ];
       for (const binary of candidates) {
-        if (existsSync5(binary)) return binary;
+        if (existsSync6(binary)) return binary;
       }
     }
   } catch {
@@ -18025,9 +18234,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 +18372,10 @@ var init_screenshotService = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
 import { join as join6 } from "path";
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync6(outputDir)) mkdirSync4(outputDir, { recursive: true });
+  if (!existsSync7(outputDir)) mkdirSync4(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -18326,7 +18535,7 @@ 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 });
+    if (!existsSync7(diagnosticsDir)) mkdirSync4(diagnosticsDir, { recursive: true });
     const base = join6(diagnosticsDir, `frame-error-${frameIndex}`);
     await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
     const html = await session.page.content();
@@ -18440,7 +18649,7 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync6(outputDir)) {
+  if (!existsSync7(outputDir)) {
     mkdirSync4(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
@@ -18595,7 +18804,7 @@ 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 { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7, dirname as dirname3 } from "path";
 function getEncoderPreset(quality, format = "mp4") {
   const base = ENCODER_PRESETS[quality];
@@ -18678,7 +18887,7 @@ 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 });
+  if (!existsSync8(outputDir)) mkdirSync5(outputDir, { recursive: true });
   const files = readdirSync3(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
@@ -18744,7 +18953,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         });
         return;
       }
-      const fileSize = existsSync7(outputPath) ? statSync(outputPath).size : 0;
+      const fileSize = existsSync8(outputPath) ? statSync(outputPath).size : 0;
       resolve17({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
@@ -18777,7 +18986,7 @@ 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 });
+  if (!existsSync8(chunkDir)) mkdirSync5(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i = 0; i < chunkCount; i++) {
     if (signal?.aborted) {
@@ -18873,7 +19082,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync7(outputPath) ? statSync(outputPath).size : 0;
+  const fileSize = existsSync8(outputPath) ? statSync(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -18884,7 +19093,7 @@ 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 });
+  if (!existsSync8(outputDir)) mkdirSync5(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
   if (isWebm) {
@@ -18951,7 +19160,7 @@ 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 { existsSync as existsSync9, mkdirSync as mkdirSync6, statSync as statSync2 } from "fs";
 import { dirname as dirname4 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let nextFrame = startFrame;
@@ -19060,7 +19269,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
   const outputDir = dirname4(outputPath);
-  if (!existsSync8(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
@@ -19140,7 +19349,7 @@ Process error: ${err.message}`;
           error: `FFmpeg exited with code ${exitCode}`
         };
       }
-      const fileSize = existsSync8(outputPath) ? statSync2(outputPath).size : 0;
+      const fileSize = existsSync9(outputPath) ? statSync2(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus
@@ -19168,9 +19377,9 @@ 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 args = [
@@ -19240,9 +19449,9 @@ 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 args = [
@@ -19318,7 +19527,7 @@ 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 existsSync10, mkdirSync as mkdirSync7 } from "fs";
 import { createHash } from "crypto";
 import { join as join8, extname } from "path";
 import { Readable } from "stream";
@@ -19331,19 +19540,19 @@ function getFilenameFromUrl(url) {
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
   const cachedPath = downloadPathCache.get(url);
-  if (cachedPath && existsSync9(cachedPath)) {
+  if (cachedPath && existsSync10(cachedPath)) {
     return cachedPath;
   }
   const inFlight = inFlightDownloads.get(url);
   if (inFlight) {
     return inFlight;
   }
-  if (!existsSync9(destDir)) {
+  if (!existsSync10(destDir)) {
     mkdirSync7(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
   const localPath = join8(destDir, filename);
-  if (existsSync9(localPath)) {
+  if (existsSync10(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
   }
@@ -19391,7 +19600,7 @@ 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 { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync4, rmSync as rmSync3 } from "fs";
 import { join as join9 } from "path";
 function parseVideoElements(html) {
   const videos = [];
@@ -19420,7 +19629,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   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 });
+  if (!existsSync11(videoOutputDir)) mkdirSync8(videoOutputDir, { recursive: true });
   const metadata = await extractVideoMetadata(videoPath);
   const framePattern = `frame_%05d.${format}`;
   const outputPattern = join9(videoOutputDir, framePattern);
@@ -19515,7 +19724,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config) {
           mkdirSync8(downloadDir, { recursive: true });
           videoPath = await downloadToTemp(videoPath, downloadDir);
         }
-        if (!existsSync10(videoPath)) {
+        if (!existsSync11(videoPath)) {
           return { error: { videoId: video.id, error: `Video file not found: ${videoPath}` } };
         }
         let videoDuration = video.end - video.start;
@@ -19669,7 +19878,7 @@ var init_videoFrameExtractor = __esm({
       }
       cleanup() {
         for (const video of this.videos.values()) {
-          if (existsSync10(video.extracted.outputDir)) {
+          if (existsSync11(video.extracted.outputDir)) {
             rmSync3(video.extracted.outputDir, { recursive: true, force: true });
           }
         }
@@ -19700,10 +19909,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,7 +19980,7 @@ var init_videoFrameInjector = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, rmSync as rmSync4 } from "fs";
 import { join as join10, dirname as dirname5 } from "path";
 function parseAudioElements(html) {
   const elements = [];
@@ -19823,7 +20032,7 @@ 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 });
+  if (!existsSync12(outputDir)) mkdirSync9(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));
@@ -19850,7 +20059,7 @@ async function extractAudioFromVideo(videoPath, outputPath, options, signal, con
 async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname5(outputPath);
-  if (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -19886,7 +20095,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, sign
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
   const outputDir = dirname5(outputPath);
-  if (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -19929,7 +20138,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     };
   }
   const outputDir = dirname5(outputPath);
-  if (!existsSync11(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync9(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i) => {
@@ -19990,7 +20199,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 (!existsSync12(workDir)) mkdirSync9(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -20012,7 +20221,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync11(srcPath)) {
+        if (!existsSync12(srcPath)) {
           errors.push(`Source not found: ${element.id}`);
           return;
         }
@@ -20092,8 +20301,8 @@ 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 existsSync13, mkdirSync as mkdirSync10, readdirSync as readdirSync5 } from "fs";
 import { copyFile, rename } from "fs/promises";
 import { join as join11 } from "path";
 function calculateOptimalWorkers(totalFrames, requested, config) {
@@ -20111,9 +20320,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);
@@ -20146,7 +20355,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 (!existsSync13(task.outputDir)) mkdirSync10(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -20236,11 +20445,11 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync12(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  if (!existsSync13(outputDir)) mkdirSync10(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 (!existsSync13(task.outputDir)) {
       continue;
     }
     const files = readdirSync5(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
@@ -20275,7 +20484,7 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync3, existsSync as existsSync13, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync14, statSync as statSync3 } from "fs";
 import { join as join12, extname as extname2 } from "path";
 var init_fileServer = __esm({
   "../engine/src/services/fileServer.ts"() {
@@ -20306,7 +20515,7 @@ 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 { existsSync as existsSync15, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -20319,7 +20528,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate)) {
+    if (existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -20330,12 +20539,12 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync14(manifestPath)) {
+  if (!existsSync15(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync4(manifestPath, "utf8");
+  const manifestRaw = readFileSync5(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -20344,10 +20553,10 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve4(dirname6(manifestPath), runtimeFileName);
-  if (!existsSync14(runtimePath)) {
+  if (!existsSync15(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync4(runtimePath, "utf8");
+  const runtimeSource = readFileSync5(runtimePath, "utf8");
   const runtimeSha = createHash2("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -20386,7 +20595,7 @@ var init_hyperframeRuntimeLoader = __esm({
 // ../producer/src/services/fileServer.ts
 import { Hono as Hono2 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { readFileSync as readFileSync5, existsSync as existsSync15, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync16, statSync as statSync4 } from "fs";
 import { join as join13, extname as extname3 } from "path";
 function stripEmbeddedRuntimeScripts2(html) {
   if (!html) return html;
@@ -20458,21 +20667,21 @@ function createFileServer2(options) {
     const relativePath = requestPath.replace(/^\//, "");
     const compiledPath = compiledDir ? join13(compiledDir, relativePath) : null;
     const hasCompiledFile = Boolean(
-      compiledPath && existsSync15(compiledPath) && statSync4(compiledPath).isFile()
+      compiledPath && existsSync16(compiledPath) && statSync4(compiledPath).isFile()
     );
     const filePath = hasCompiledFile ? compiledPath : join13(projectDir, relativePath);
-    if (!existsSync15(filePath) || !statSync4(filePath).isFile()) {
+    if (!existsSync16(filePath) || !statSync4(filePath).isFile()) {
       return c2.text("Not found", 404);
     }
     const ext = extname3(filePath).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync5(filePath, "utf-8");
+      const rawHtml = readFileSync6(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 = readFileSync6(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -20924,7 +21133,7 @@ var init_deterministicFonts = __esm({
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync6, existsSync as existsSync16, mkdirSync as mkdirSync11 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
 import { join as join14, dirname as dirname7, resolve as resolve5 } from "path";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -20936,7 +21145,7 @@ 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 (!existsSync17(downloadDir)) mkdirSync11(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
@@ -20945,7 +21154,7 @@ async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagNa
   } else if (!filePath.startsWith("/")) {
     filePath = join14(baseDir, filePath);
   }
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractVideoMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -21012,10 +21221,10 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync16(filePath)) {
+    if (!existsSync17(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync6(filePath, "utf-8");
+    const rawSubHtml = readFileSync7(filePath, "utf-8");
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, absoluteStart, absoluteEnd, filePath, rawSubHtml, nestedVisited });
@@ -21209,8 +21418,8 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve5(projectDir, srcPath);
-      if (existsSync16(filePath)) {
-        compHtml = readFileSync6(filePath, "utf-8");
+      if (existsSync17(filePath)) {
+        compHtml = readFileSync7(filePath, "utf-8");
       }
     }
     if (!compHtml) {
@@ -21330,7 +21539,7 @@ ${html}
 </html>`;
 }
 async function compileForRender(projectDir, htmlPath, downloadDir) {
-  const rawHtml = readFileSync6(htmlPath, "utf-8");
+  const rawHtml = readFileSync7(htmlPath, "utf-8");
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
@@ -21518,10 +21727,10 @@ var init_logger = __esm({
 
 // ../producer/src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync12,
   rmSync as rmSync5,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   writeFileSync as writeFileSync4,
   copyFileSync as copyFileSync2,
   appendFileSync
@@ -21683,28 +21892,28 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync17(workDir)) mkdirSync12(workDir, { recursive: true });
+    if (!existsSync18(workDir)) mkdirSync12(workDir, { recursive: true });
     if (job.config.debug) {
       const logPath = join15(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log);
     }
     const entryFile = job.config.entryFile || "index.html";
     let htmlPath = join15(projectDir, entryFile);
-    if (!existsSync17(htmlPath)) {
+    if (!existsSync18(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync7(htmlPath, "utf-8");
+    const rawEntry = readFileSync8(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)) {
+      if (!existsSync18(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"),
+        readFileSync8(projectIndexPath, "utf-8"),
         entryFile
       );
       if (!standaloneHtml) {
@@ -21952,7 +22161,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       assertNotAborted();
     }
     const framesDir = join15(workDir, "captured-frames");
-    if (!existsSync17(framesDir)) mkdirSync12(framesDir, { recursive: true });
+    if (!existsSync18(framesDir)) mkdirSync12(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -22240,7 +22449,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync17(outputPath)) {
+      if (existsSync18(outputPath)) {
         const debugOutput = join15(workDir, isWebm ? "output.webm" : "output.mp4");
         copyFileSync2(outputPath, debugOutput);
       }
@@ -22317,7 +22526,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync17(workDir)) rmSync5(workDir, { recursive: true, force: true });
+          if (existsSync18(workDir)) rmSync5(workDir, { recursive: true, force: true });
         },
         log
       );
@@ -22379,7 +22588,7 @@ var init_lint = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync18, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
 import { resolve as resolve7, join as join16 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -22408,7 +22617,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve7(projectDir);
-  if (!existsSync18(absProjectDir) || !statSync5(absProjectDir).isDirectory()) {
+  if (!existsSync19(absProjectDir) || !statSync5(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -22419,10 +22628,10 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync18(absoluteEntryPath) && statSync5(absoluteEntryPath).isFile()) {
+    if (existsSync19(absoluteEntryPath) && statSync5(absoluteEntryPath).isFile()) {
       return {
         entryFile,
-        html: readFileSync8(absoluteEntryPath, "utf-8"),
+        html: readFileSync9(absoluteEntryPath, "utf-8"),
         source: "projectDir"
       };
     }
@@ -22493,7 +22702,7 @@ var init_paths = __esm({
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync13,
   statSync as statSync6,
   mkdtempSync,
@@ -22523,11 +22732,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve9(projectDir);
-    if (!existsSync19(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
+    if (!existsSync20(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync19(resolve9(absProjectDir, entry))) {
+    if (!existsSync20(resolve9(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -22674,7 +22883,7 @@ function createRenderHandlers(options = {}) {
       log
     );
     const outputDir = dirname9(absoluteOutputPath);
-    if (!existsSync19(outputDir)) mkdirSync13(outputDir, { recursive: true });
+    if (!existsSync20(outputDir)) mkdirSync13(outputDir, { recursive: true });
     log.info("render started", {
       requestId,
       projectDir: input.projectDir,
@@ -22699,7 +22908,7 @@ function createRenderHandlers(options = {}) {
           log.info(`render progress ${pct}%`, { requestId, stage: j2.currentStage, message });
         }
       });
-      const fileSize = existsSync19(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
+      const fileSize = existsSync20(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -22782,7 +22991,7 @@ function createRenderHandlers(options = {}) {
         log
       );
       const outputDir = dirname9(absoluteOutputPath);
-      if (!existsSync19(outputDir)) mkdirSync13(outputDir, { recursive: true });
+      if (!existsSync20(outputDir)) mkdirSync13(outputDir, { recursive: true });
       log.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
         fps: input.fps,
@@ -22816,7 +23025,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync19(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
+        const fileSize = existsSync20(absoluteOutputPath) ? statSync6(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -22874,7 +23083,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c2.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync19(artifact.path)) {
+    if (!existsSync20(artifact.path)) {
       store.delete(token);
       return c2.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -23008,7 +23217,7 @@ __export(manager_exports2, {
   setBrowserPath: () => setBrowserPath
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync20, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync21, rmSync as rmSync7 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join19 } from "path";
 import { Browser, detectBrowserPlatform, getInstalledBrowsers, install } from "@puppeteer/browsers";
@@ -23028,17 +23237,17 @@ function whichBinary2(name) {
   }
 }
 function findFromEnv2() {
-  if (_browserPathOverride && existsSync20(_browserPathOverride)) {
+  if (_browserPathOverride && existsSync21(_browserPathOverride)) {
     return { executablePath: _browserPathOverride, source: "env" };
   }
   const envPath = process.env["HYPERFRAMES_BROWSER_PATH"];
-  if (envPath && existsSync20(envPath)) {
+  if (envPath && existsSync21(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
   return void 0;
 }
 async function findFromCache() {
-  if (!existsSync20(CACHE_DIR)) {
+  if (!existsSync21(CACHE_DIR)) {
     return void 0;
   }
   const installed = await getInstalledBrowsers({ cacheDir: CACHE_DIR });
@@ -23050,7 +23259,7 @@ async function findFromCache() {
 }
 function findFromSystem2() {
   for (const p of SYSTEM_CHROME_PATHS) {
-    if (existsSync20(p)) {
+    if (existsSync21(p)) {
       return { executablePath: p, source: "system" };
     }
   }
@@ -23070,21 +23279,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 (!existsSync21(CACHE_DIR)) {
     return false;
   }
   rmSync7(CACHE_DIR, { recursive: true, force: true });
@@ -23112,18 +23321,18 @@ __export(studioServer_exports, {
 });
 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 { existsSync as existsSync22, readFileSync as readFileSync10, readdirSync as readdirSync6, statSync as statSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync14 } from "fs";
 import { resolve as resolve10, join as join20, sep as sep2, basename as basename2, dirname as dirname10, extname as extname4 } from "path";
 function resolveDistDir() {
   const builtPath = resolve10(__dirname, "studio");
-  if (existsSync21(resolve10(builtPath, "index.html"))) return builtPath;
+  if (existsSync22(resolve10(builtPath, "index.html"))) return builtPath;
   const devPath = resolve10(__dirname, "..", "..", "..", "studio", "dist");
-  if (existsSync21(resolve10(devPath, "index.html"))) return devPath;
+  if (existsSync22(resolve10(devPath, "index.html"))) return devPath;
   return builtPath;
 }
 function resolveRuntimePath() {
   const builtPath = resolve10(__dirname, "hyperframe-runtime.js");
-  if (existsSync21(builtPath)) return builtPath;
+  if (existsSync22(builtPath)) return builtPath;
   const devPath = resolve10(
     __dirname,
     "..",
@@ -23133,7 +23342,7 @@ function resolveRuntimePath() {
     "dist",
     "hyperframe.runtime.iife.js"
   );
-  if (existsSync21(devPath)) return devPath;
+  if (existsSync22(devPath)) return devPath;
   return builtPath;
 }
 function isSafePath(base, resolved) {
@@ -23157,27 +23366,27 @@ function walkDir(dir, prefix = "") {
   return files;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync21(filePath) || !statSync7(filePath).isFile()) return null;
+  if (!existsSync22(filePath) || !statSync7(filePath).isFile()) return null;
   const mime = getMimeType(filePath);
-  const content = readFileSync9(filePath);
+  const content = readFileSync10(filePath);
   return new Response(content, {
     headers: { "Content-Type": mime, "Cache-Control": "no-store" }
   });
 }
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl) {
   const compFile = resolve10(projectDir, compPath);
-  if (!isSafePath(projectDir, compFile) || !existsSync21(compFile) || !statSync7(compFile).isFile()) {
+  if (!isSafePath(projectDir, compFile) || !existsSync22(compFile) || !statSync7(compFile).isFile()) {
     return null;
   }
-  let rawComp = readFileSync9(compFile, "utf-8");
+  let rawComp = readFileSync10(compFile, "utf-8");
   const templateMatch = rawComp.match(/<template>([\s\S]*)<\/template>/i);
   let content = (templateMatch ? templateMatch[1] : rawComp) ?? rawComp;
   content = content.replace(
     /(<[^>]*?)(data-composition-src=["']([^"']+)["'])([^>]*>)/g,
     (_match, before2, srcAttr, src, after2) => {
       const nestedFile = join20(projectDir, src);
-      if (!existsSync21(nestedFile)) return before2 + srcAttr + after2;
-      const nestedRaw = readFileSync9(nestedFile, "utf-8");
+      if (!existsSync22(nestedFile)) return before2 + srcAttr + after2;
+      const nestedRaw = readFileSync10(nestedFile, "utf-8");
       const nestedTemplate = nestedRaw.match(/<template>([\s\S]*)<\/template>/i);
       const nestedContent = (nestedTemplate ? nestedTemplate[1] : nestedRaw) ?? nestedRaw;
       const styles = [];
@@ -23215,8 +23424,8 @@ function createStudioServer(options) {
   const watcher = createProjectWatcher(projectDir);
   const app = new Hono4();
   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 (!existsSync22(runtimePath)) return c2.text("runtime not built", 404);
+    return c2.body(readFileSync10(runtimePath, "utf-8"), 200, {
       "Content-Type": "text/javascript",
       "Cache-Control": "no-store"
     });
@@ -23251,8 +23460,8 @@ function createStudioServer(options) {
       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");
+      if (!existsSync22(file)) return c2.text("not found", 404);
+      bundled = readFileSync10(file, "utf-8");
     }
     const baseTag = `<base href="/api/projects/${projectId}/preview/">`;
     if (bundled.includes("<head>")) {
@@ -23285,11 +23494,11 @@ function createStudioServer(options) {
       c2.req.path.replace(`/api/projects/${id}/preview/`, "").split("?")[0] ?? ""
     );
     const file = resolve10(projectDir, subPath);
-    if (!isSafePath(projectDir, file) || !existsSync21(file) || !statSync7(file).isFile()) {
+    if (!isSafePath(projectDir, file) || !existsSync22(file) || !statSync7(file).isFile()) {
       return c2.text("not found", 404);
     }
     const mime = getMimeType(file);
-    const content = readFileSync9(file);
+    const content = readFileSync10(file);
     return new Response(content, {
       headers: { "Content-Type": mime, "Cache-Control": "no-store" }
     });
@@ -23299,10 +23508,10 @@ function createStudioServer(options) {
     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)) {
+    if (!isSafePath(projectDir, file) || !existsSync22(file)) {
       return c2.text("not found", 404);
     }
-    const content = readFileSync9(file, "utf-8");
+    const content = readFileSync10(file, "utf-8");
     return c2.json({ filename: filePath, content });
   });
   app.put("/api/projects/:id/files/*", async (c2) => {
@@ -23314,7 +23523,7 @@ function createStudioServer(options) {
       return c2.json({ error: "forbidden" }, 403);
     }
     const dir = dirname10(file);
-    if (!existsSync21(dir)) mkdirSync14(dir, { recursive: true });
+    if (!existsSync22(dir)) mkdirSync14(dir, { recursive: true });
     const body = await c2.req.text();
     writeFileSync6(file, body, "utf-8");
     return c2.json({ ok: true });
@@ -23326,7 +23535,7 @@ function createStudioServer(options) {
     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 });
+    if (!existsSync22(outputDir)) mkdirSync14(outputDir, { recursive: true });
     const outputPath = join20(outputDir, `${projectId}.mp4`);
     renderJobs.set(jobId, { status: "rendering", progress: 0, outputPath });
     (async () => {
@@ -23340,7 +23549,11 @@ function createStudioServer(options) {
           }
         } catch {
         }
+        const { trackRenderComplete: trackRenderComplete2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+        const { bytesToMb: bytesToMb2 } = await Promise.resolve().then(() => (init_system(), system_exports));
+        const { freemem: freemem5 } = await import("os");
         const job = createRenderJob2({ fps: 30, quality: "standard" });
+        const startTime = Date.now();
         const onProgress = (j2) => {
           const entry2 = renderJobs.get(jobId);
           if (entry2) entry2.progress = j2.progress;
@@ -23351,7 +23564,41 @@ function createStudioServer(options) {
           entry.status = "complete";
           entry.progress = 100;
         }
+        const elapsed = Date.now() - startTime;
+        const perf = job.perfSummary;
+        const compositionDurationMs = perf ? Math.round(perf.compositionDurationSeconds * 1e3) : void 0;
+        trackRenderComplete2({
+          durationMs: elapsed,
+          fps: 30,
+          quality: "standard",
+          workers: perf?.workers ?? 1,
+          docker: false,
+          gpu: false,
+          compositionDurationMs,
+          compositionWidth: perf?.resolution.width,
+          compositionHeight: perf?.resolution.height,
+          totalFrames: perf?.totalFrames,
+          speedRatio: compositionDurationMs && compositionDurationMs > 0 && elapsed > 0 ? Math.round(compositionDurationMs / elapsed * 100) / 100 : void 0,
+          captureAvgMs: perf?.captureAvgMs,
+          capturePeakMs: perf?.capturePeakMs,
+          peakMemoryMb: bytesToMb2(process.memoryUsage.rss()),
+          memoryFreeMb: bytesToMb2(freemem5())
+        });
       } catch (err) {
+        try {
+          const { trackRenderError: trackRenderError2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+          const { bytesToMb: bytesToMb2 } = await Promise.resolve().then(() => (init_system(), system_exports));
+          const { freemem: freemem5 } = await import("os");
+          trackRenderError2({
+            fps: 30,
+            quality: "standard",
+            docker: false,
+            errorMessage: err instanceof Error ? err.message : String(err),
+            peakMemoryMb: bytesToMb2(process.memoryUsage.rss()),
+            memoryFreeMb: bytesToMb2(freemem5())
+          });
+        } catch {
+        }
         const entry = renderJobs.get(jobId);
         if (entry) {
           entry.status = "failed";
@@ -23385,10 +23632,10 @@ function createStudioServer(options) {
   app.get("/api/render/:jobId/download", (c2) => {
     const { jobId } = c2.req.param();
     const job = renderJobs.get(jobId);
-    if (!job?.outputPath || !existsSync21(job.outputPath)) {
+    if (!job?.outputPath || !existsSync22(job.outputPath)) {
       return c2.json({ error: "not found" }, 404);
     }
-    const content = readFileSync9(job.outputPath);
+    const content = readFileSync10(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": "video/mp4",
@@ -23408,10 +23655,10 @@ function createStudioServer(options) {
   });
   app.get("*", (c2) => {
     const indexPath = resolve10(studioDir, "index.html");
-    if (!existsSync21(indexPath)) {
+    if (!existsSync22(indexPath)) {
       return c2.text("Studio not found. Rebuild with: pnpm run build", 500);
     }
-    return c2.html(readFileSync9(indexPath, "utf-8"));
+    return c2.html(readFileSync10(indexPath, "utf-8"));
   });
   return { app, watcher };
 }
@@ -23450,7 +23697,7 @@ __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 { existsSync as existsSync23, lstatSync, symlinkSync, unlinkSync, readlinkSync, mkdirSync as mkdirSync15 } from "fs";
 import { resolve as resolve11, dirname as dirname11, basename as basename3, join as join21 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire } from "module";
@@ -23496,7 +23743,7 @@ async function runDevMode(dir) {
   mkdirSync15(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync22(symlinkPath)) {
+    if (existsSync23(symlinkPath)) {
       try {
         const stat = lstatSync(symlinkPath);
         if (stat.isSymbolicLink()) {
@@ -23508,7 +23755,7 @@ async function runDevMode(dir) {
       } catch {
       }
     }
-    if (!existsSync22(symlinkPath)) {
+    if (!existsSync23(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23550,7 +23797,7 @@ async function runDevMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync22(symlinkPath)) unlinkSync(symlinkPath);
+        if (existsSync23(symlinkPath)) unlinkSync(symlinkPath);
       } catch {
       }
     });
@@ -23577,12 +23824,12 @@ async function runLocalStudioMode(dir) {
   mkdirSync15(projectsDir, { recursive: true });
   let createdSymlink = false;
   if (dir !== symlinkPath) {
-    if (existsSync22(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
+    if (existsSync23(symlinkPath) && lstatSync(symlinkPath).isSymbolicLink()) {
       if (resolve11(readlinkSync(symlinkPath)) !== resolve11(dir)) {
         unlinkSync(symlinkPath);
       }
     }
-    if (!existsSync22(symlinkPath)) {
+    if (!existsSync23(symlinkPath)) {
       symlinkSync(dir, symlinkPath, "dir");
       createdSymlink = true;
     }
@@ -23621,7 +23868,7 @@ async function runLocalStudioMode(dir) {
   if (createdSymlink) {
     process.on("exit", () => {
       try {
-        if (existsSync22(symlinkPath)) unlinkSync(symlinkPath);
+        if (existsSync23(symlinkPath)) unlinkSync(symlinkPath);
       } catch {
       }
     });
@@ -23658,6 +23905,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(() => {
@@ -23727,17 +23977,17 @@ var init_format = __esm({
 });
 
 // src/utils/project.ts
-import { existsSync as existsSync23, statSync as statSync8 } from "fs";
+import { existsSync as existsSync24, statSync as statSync8 } from "fs";
 import { resolve as resolve12, basename as basename4 } from "path";
 function resolveProject(dirArg) {
   const dir = resolve12(dirArg ?? ".");
   const name = basename4(dir);
   const indexPath = resolve12(dir, "index.html");
-  if (!existsSync23(dir) || !statSync8(dir).isDirectory()) {
+  if (!existsSync24(dir) || !statSync8(dir).isDirectory()) {
     errorBox("Not a directory: " + dir);
     process.exit(1);
   }
-  if (!existsSync23(indexPath)) {
+  if (!existsSync24(indexPath)) {
     errorBox(
       "No composition found in " + dir,
       "No index.html file found.",
@@ -23826,8 +24076,8 @@ 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 { existsSync as existsSync25, mkdirSync as mkdirSync16, statSync as statSync9 } from "fs";
+import { cpus as cpus3, freemem as freemem3 } from "os";
 import { resolve as resolve13, dirname as dirname12, join as join22 } from "path";
 function defaultWorkerCount() {
   return Math.max(1, Math.min(Math.floor(CPU_CORE_COUNT / 2), 4));
@@ -23835,8 +24085,9 @@ function defaultWorkerCount() {
 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 +24096,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,30 +24121,58 @@ 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)) {
+  if (existsSync25(outputPath)) {
     const stat = statSync9(outputPath);
     fileSize = formatBytes(stat.size);
   }
@@ -23927,10 +24192,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",
@@ -24101,7 +24367,7 @@ __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 { existsSync as existsSync26, readFileSync as readFileSync11, mkdirSync as mkdirSync17, unlinkSync as unlinkSync2 } from "fs";
 import { join as join23, extname as extname5 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function isAudioFile(filePath) {
@@ -24188,10 +24454,10 @@ async function transcribe(inputPath, outputDir, options) {
     { stdio: "ignore", timeout: 3e5 }
   );
   const transcriptPath = `${outputBase}.json`;
-  if (!existsSync25(transcriptPath)) {
+  if (!existsSync26(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(readFileSync11(transcriptPath, "utf-8"));
   const segments = transcript.transcription ?? [];
   let wordCount = 0;
   let maxEnd = 0;
@@ -24230,12 +24496,12 @@ __export(init_exports, {
   default: () => init_default
 });
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   mkdirSync as mkdirSync18,
   copyFileSync as copyFileSync3,
   cpSync as cpSync2,
   writeFileSync as writeFileSync7,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readdirSync as readdirSync7
 } from "fs";
 import { resolve as resolve14, basename as basename5, join as join24, dirname as dirname13 } from "path";
@@ -24361,7 +24627,7 @@ 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;
+  return existsSync27(devPath) ? devPath : builtPath;
 }
 function getStaticTemplateDir(templateId) {
   return resolveAssetDir(["..", "templates", templateId], ["templates", templateId]);
@@ -24375,7 +24641,7 @@ function getBundledSkillsDir() {
 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));
   for (const file of htmlFiles) {
-    let content = readFileSync11(file, "utf-8");
+    let content = readFileSync12(file, "utf-8");
     if (videoFilename) {
       content = content.replaceAll("__VIDEO_SRC__", videoFilename);
     } else {
@@ -24390,7 +24656,7 @@ function patchVideoSrc(dir, videoFilename, durationSeconds) {
   }
 }
 function patchTranscript(dir, transcriptPath) {
-  const raw = JSON.parse(readFileSync11(transcriptPath, "utf-8"));
+  const raw = JSON.parse(readFileSync12(transcriptPath, "utf-8"));
   const words = [];
   for (const seg of raw.transcription ?? []) {
     for (const token of seg.tokens ?? []) {
@@ -24414,7 +24680,7 @@ function patchTranscript(dir, transcriptPath) {
   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));
   for (const file of htmlFiles) {
-    let content = readFileSync11(file, "utf-8");
+    let content = readFileSync12(file, "utf-8");
     const scriptBlocks = content.match(/<script>[\s\S]*?<\/script>/g) ?? [];
     let scriptMatch = null;
     let transcriptMatch = null;
@@ -24463,8 +24729,16 @@ async function handleVideoFile(videoPath, destDir, interactive) {
         const transcode = await Jt({
           message: "Transcode to H.264 MP4 for browser playback?",
           options: [
-            { value: "yes", label: "Yes, transcode", hint: "converts to H.264 MP4" },
-            { value: "no", label: "No, keep original", hint: "video won't play in browser" }
+            {
+              value: "yes",
+              label: "Yes, transcode",
+              hint: "converts to H.264 MP4"
+            },
+            {
+              value: "no",
+              label: "No, keep original",
+              hint: "video won't play in browser"
+            }
           ]
         });
         if (Ct(transcode)) {
@@ -24523,7 +24797,7 @@ function scaffoldProject(destDir, name, templateId, localVideoName, durationSeco
     "utf-8"
   );
   const sharedDir = getSharedTemplateDir();
-  if (existsSync26(sharedDir)) {
+  if (existsSync27(sharedDir)) {
     for (const entry of readdirSync7(sharedDir, { withFileTypes: true })) {
       const src = join24(sharedDir, entry.name);
       const dest = resolve14(destDir, entry.name);
@@ -24533,11 +24807,11 @@ function scaffoldProject(destDir, name, templateId, localVideoName, durationSeco
     }
   }
   const skillsSrcDir = getBundledSkillsDir();
-  if (existsSync26(skillsSrcDir)) {
-    const projectSkills = ["compose-video", "captions"];
+  if (existsSync27(skillsSrcDir)) {
+    const projectSkills = ["hyperframes-compose", "hyperframes-captions"];
     for (const skill of projectSkills) {
       const src = join24(skillsSrcDir, skill);
-      if (existsSync26(src)) {
+      if (existsSync27(src)) {
         const dest = resolve14(destDir, ".claude", "skills", skill);
         mkdirSync18(dest, { recursive: true });
         cpSync2(src, dest, { recursive: true });
@@ -24550,7 +24824,11 @@ async function nextStepLoop(destDir) {
     const next = await Jt({
       message: "What do you want to do?",
       options: [
-        { value: "dev", label: "Open in studio", hint: "full editor with timeline" },
+        {
+          value: "dev",
+          label: "Open in studio",
+          hint: "full editor with timeline"
+        },
         { value: "render", label: "Render to MP4", hint: "export video now" },
         { value: "done", label: "Done for now" }
       ]
@@ -24599,10 +24877,10 @@ var init_init = __esm({
         description: `Scaffold a new composition project
 
 Examples:
-  hyperframes init my-video --template blank --video video.mp4
-  hyperframes init podcast --template warm-grain --audio episode.mp3
-  hyperframes init my-video --template blank --skip-skills --skip-transcribe
-  hyperframes init --human-friendly                    # interactive mode`
+  hyperframes init my-video                            # interactive wizard
+  hyperframes init my-video --template warm-grain      # pick a template
+  hyperframes init my-video --video video.mp4          # with video file
+  hyperframes init my-video --non-interactive           # skip prompts (CI/agents)`
       },
       args: {
         name: { type: "positional", description: "Project name", required: false },
@@ -24611,11 +24889,28 @@ Examples:
           description: `Template (${ALL_TEMPLATE_IDS.join(", ")})`,
           alias: "t"
         },
-        video: { type: "string", description: "Path to a video file (MP4, WebM, MOV)", alias: "V" },
-        audio: { type: "string", description: "Path to an audio file (MP3, WAV, M4A)", alias: "a" },
-        "skip-skills": { type: "boolean", description: "Skip AI coding skills installation" },
-        "skip-transcribe": { type: "boolean", description: "Skip whisper transcription" },
-        "human-friendly": { type: "boolean", description: "Enable interactive terminal UI" }
+        video: {
+          type: "string",
+          description: "Path to a video file (MP4, WebM, MOV)",
+          alias: "V"
+        },
+        audio: {
+          type: "string",
+          description: "Path to an audio file (MP3, WAV, M4A)",
+          alias: "a"
+        },
+        "skip-skills": {
+          type: "boolean",
+          description: "Skip AI coding skills installation"
+        },
+        "skip-transcribe": {
+          type: "boolean",
+          description: "Skip whisper transcription"
+        },
+        "non-interactive": {
+          type: "boolean",
+          description: "Disable interactive prompts (for CI/agents)"
+        }
       },
       async run({ args }) {
         const templateFlag = args.template;
@@ -24623,24 +24918,19 @@ Examples:
         const audioFlag = args.audio;
         const skipSkills = args["skip-skills"] === true;
         const skipTranscribe = args["skip-transcribe"] === true;
-        const humanFriendly = args["human-friendly"] === true;
-        if (!humanFriendly) {
-          if (!templateFlag) {
-            console.error(c.error("Missing required flag: --template"));
-            console.error(`Available: ${ALL_TEMPLATE_IDS.join(", ")}`);
-            console.error(`
-Example: hyperframes init my-video --template blank --video video.mp4`);
-            process.exit(1);
-          }
-          if (!ALL_TEMPLATE_IDS.includes(templateFlag)) {
-            console.error(c.error(`Unknown template: ${templateFlag}`));
+        const nonInteractive = args["non-interactive"] === true;
+        const interactive = !nonInteractive && process.stdout.isTTY === true;
+        if (!interactive) {
+          const resolvedTemplate = templateFlag ?? "blank";
+          if (!ALL_TEMPLATE_IDS.includes(resolvedTemplate)) {
+            console.error(c.error(`Unknown template: ${resolvedTemplate}`));
             console.error(`Available: ${ALL_TEMPLATE_IDS.join(", ")}`);
             process.exit(1);
           }
-          const templateId2 = templateFlag;
+          const templateId2 = resolvedTemplate;
           const name2 = args.name ?? "my-video";
           const destDir2 = resolve14(name2);
-          if (existsSync26(destDir2) && readdirSync7(destDir2).length > 0) {
+          if (existsSync27(destDir2) && readdirSync7(destDir2).length > 0) {
             console.error(c.error(`Directory already exists and is not empty: ${name2}`));
             process.exit(1);
           }
@@ -24650,7 +24940,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
           let sourceFilePath2;
           if (videoFlag) {
             const videoPath = resolve14(videoFlag);
-            if (!existsSync26(videoPath)) {
+            if (!existsSync27(videoPath)) {
               console.error(c.error(`Video file not found: ${videoFlag}`));
               process.exit(1);
             }
@@ -24664,7 +24954,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
           }
           if (audioFlag) {
             const audioPath = resolve14(audioFlag);
-            if (!existsSync26(audioPath)) {
+            if (!existsSync27(audioPath)) {
               console.error(c.error(`Audio file not found: ${audioFlag}`));
               process.exit(1);
             }
@@ -24691,7 +24981,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
           scaffoldProject(destDir2, basename5(destDir2), templateId2, localVideoName2, videoDuration2);
           trackInitTemplate(templateId2);
           const transcriptFile2 = resolve14(destDir2, "transcript.json");
-          if (existsSync26(transcriptFile2)) {
+          if (existsSync27(transcriptFile2)) {
             patchTranscript(destDir2, transcriptFile2);
           }
           if (!skipSkills) {
@@ -24702,23 +24992,22 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
             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;
         }
@@ -24740,7 +25029,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
           name = nameResult;
         }
         const destDir = resolve14(name);
-        if (existsSync26(destDir) && readdirSync7(destDir).length > 0) {
+        if (existsSync27(destDir) && readdirSync7(destDir).length > 0) {
           const overwrite = await Rt({
             message: `Directory ${c.accent(name)} already exists and is not empty. Overwrite?`,
             initialValue: false
@@ -24756,7 +25045,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
         let isAudioOnly = false;
         if (videoFlag) {
           const videoPath = resolve14(videoFlag);
-          if (!existsSync26(videoPath)) {
+          if (!existsSync27(videoPath)) {
             R2.error(`File not found: ${videoFlag}`);
             Nt("Setup cancelled.");
             process.exit(1);
@@ -24772,7 +25061,11 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
             options: [
               { value: "video", label: "Video", hint: "MP4, WebM, MOV" },
               { value: "audio", label: "Audio only", hint: "MP3, WAV, M4A" },
-              { value: "no", label: "No", hint: "Start with motion graphics or text" }
+              {
+                value: "no",
+                label: "No",
+                hint: "Start with motion graphics or text"
+              }
             ],
             initialValue: "no"
           });
@@ -24787,7 +25080,7 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
               validate(val) {
                 const trimmed = val?.trim();
                 if (!trimmed) return "Please enter a file path";
-                if (!existsSync26(resolve14(trimmed))) return "File not found";
+                if (!existsSync27(resolve14(trimmed))) return "File not found";
                 return void 0;
               }
             });
@@ -24829,7 +25122,9 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
               await ensureWhisper2({
                 onProgress: (msg) => spin.message(msg)
               });
-              await ensureModel2(void 0, { onProgress: (msg) => spin.message(msg) });
+              await ensureModel2(void 0, {
+                onProgress: (msg) => spin.message(msg)
+              });
               spin.message("Transcribing audio...");
               const { transcribe: runTranscribe } = await Promise.resolve().then(() => (init_transcribe(), transcribe_exports));
               const transcribeResult = await runTranscribe(sourceFilePath, destDir, {
@@ -24845,25 +25140,33 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
             }
           }
         }
-        const defaultTemplate = isAudioOnly ? "warm-grain" : "blank";
-        const templateResult = await Jt({
-          message: "Pick a template",
-          options: TEMPLATES.map((t2) => ({
-            value: t2.id,
-            label: t2.label,
-            hint: t2.hint
-          })),
-          initialValue: defaultTemplate
-        });
-        if (Ct(templateResult)) {
-          Nt("Setup cancelled.");
-          process.exit(0);
+        let templateId;
+        if (templateFlag && ALL_TEMPLATE_IDS.includes(templateFlag)) {
+          templateId = templateFlag;
+        } else {
+          if (templateFlag) {
+            R2.warn(`Unknown template "${templateFlag}" \u2014 pick from the list below`);
+          }
+          const defaultTemplate = isAudioOnly ? "warm-grain" : "blank";
+          const templateResult = await Jt({
+            message: "Pick a template",
+            options: TEMPLATES.map((t2) => ({
+              value: t2.id,
+              label: t2.label,
+              hint: t2.hint
+            })),
+            initialValue: defaultTemplate
+          });
+          if (Ct(templateResult)) {
+            Nt("Setup cancelled.");
+            process.exit(0);
+          }
+          templateId = templateResult;
         }
-        const templateId = templateResult;
         scaffoldProject(destDir, name, templateId, localVideoName, videoDuration);
         trackInitTemplate(templateId);
         const transcriptFile = resolve14(destDir, "transcript.json");
-        if (existsSync26(transcriptFile)) {
+        if (existsSync27(transcriptFile)) {
           patchTranscript(destDir, transcriptFile);
         }
         if (!skipSkills) {
@@ -24871,6 +25174,10 @@ Example: hyperframes init my-video --template blank --video video.mp4`);
         }
         const files = readdirSync7(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);
       }
     });
@@ -24882,7 +25189,7 @@ var lint_exports = {};
 __export(lint_exports, {
   default: () => lint_default
 });
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 var lint_default;
 var init_lint2 = __esm({
   "src/commands/lint.ts"() {
@@ -24900,7 +25207,7 @@ var init_lint2 = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync12(project.indexPath, "utf-8");
+        const html = readFileSync13(project.indexPath, "utf-8");
         const result = lintHyperframeHtml(html, { filePath: project.indexPath });
         if (args.json) {
           console.log(JSON.stringify(withMeta(result), null, 2));
@@ -24949,7 +25256,7 @@ var info_exports = {};
 __export(info_exports, {
   default: () => info_default
 });
-import { readFileSync as readFileSync13, readdirSync as readdirSync8, statSync as statSync10 } from "fs";
+import { readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync10 } from "fs";
 import { join as join25 } from "path";
 function totalSize(dir) {
   let total = 0;
@@ -24982,7 +25289,7 @@ var init_info = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync13(project.indexPath, "utf-8");
+        const html = readFileSync14(project.indexPath, "utf-8");
         ensureDOMParser();
         const parsed = parseHtml(html);
         const tracks = new Set(parsed.elements.map((el) => el.zIndex));
@@ -25033,7 +25340,7 @@ var compositions_exports = {};
 __export(compositions_exports, {
   default: () => compositions_default
 });
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 function parseCompositions(html) {
   const parser = new DOMParser();
   const doc = parser.parseFromString(html, "text/html");
@@ -25090,7 +25397,7 @@ var init_compositions = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync14(project.indexPath, "utf-8");
+        const html = readFileSync15(project.indexPath, "utf-8");
         ensureDOMParser();
         const compositions = parseCompositions(html);
         if (compositions.length === 0) {
@@ -25126,7 +25433,7 @@ var benchmark_exports = {};
 __export(benchmark_exports, {
   default: () => benchmark_default
 });
-import { existsSync as existsSync27, statSync as statSync11 } from "fs";
+import { existsSync as existsSync28, statSync as statSync11 } from "fs";
 import { resolve as resolve15, join as join26 } from "path";
 var DEFAULT_CONFIGS, benchmark_default;
 var init_benchmark = __esm({
@@ -25211,7 +25518,7 @@ var init_benchmark = __esm({
               await producer.executeRenderJob(job, project.dir, outputPath);
               const elapsedMs = Date.now() - startTime;
               let fileSize = null;
-              if (existsSync27(outputPath)) {
+              if (existsSync28(outputPath)) {
                 const stat = statSync11(outputPath);
                 fileSize = stat.size;
               }
@@ -25420,7 +25727,7 @@ var docs_exports = {};
 __export(docs_exports, {
   default: () => docs_default
 });
-import { readFileSync as readFileSync15, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync29 } from "fs";
 import { resolve as resolve16, dirname as dirname14, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function docsDir() {
@@ -25428,7 +25735,7 @@ function docsDir() {
   const dir = dirname14(thisFile);
   const devPath = resolve16(dir, "..", "docs");
   const builtPath = resolve16(dir, "docs");
-  return existsSync28(devPath) ? devPath : builtPath;
+  return existsSync29(devPath) ? devPath : builtPath;
 }
 function formatInlineCode(line) {
   return line.replace(/`([^`]+)`/g, (_match, code) => c.accent(code));
@@ -25520,11 +25827,11 @@ var init_docs = __esm({
           process.exit(1);
         }
         const filePath = join27(docsDir(), entry.file);
-        if (!existsSync28(filePath)) {
+        if (!existsSync29(filePath)) {
           console.error(c.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
-        const content = readFileSync15(filePath, "utf-8");
+        const content = readFileSync16(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -25538,6 +25845,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) {
@@ -25615,6 +25923,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"() {
@@ -25625,6 +25994,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: {},
@@ -25635,12 +26005,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();
@@ -25839,6 +26218,7 @@ init_version();
 init_config();
 init_client();
 init_events();
+init_system();
 
 // src/cli.ts
 init_updateCheck();