hyperframes 0.6.18 → 0.6.19

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.6.18" : "0.0.0-dev";
+    VERSION = true ? "0.6.19" : "0.0.0-dev";
   }
 });
 
@@ -11438,7 +11438,7 @@ import { get as httpsGet } from "https";
 import { pipeline } from "stream/promises";
 function downloadFile(url, dest) {
   const tmp = `${dest}.tmp`;
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const follow = (u) => {
       httpsGet(u, (res) => {
         if (res.statusCode === 301 || res.statusCode === 302) {
@@ -11455,7 +11455,7 @@ function downloadFile(url, dest) {
         const file = createWriteStream(tmp);
         pipeline(res, file).then(() => {
           renameSync(tmp, dest);
-          resolve43();
+          resolve45();
         }).catch((err) => {
           try {
             unlinkSync(tmp);
@@ -12180,7 +12180,7 @@ function hasNpx() {
   }
 }
 function runSkillsAdd(repo) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const child = spawn("npx", ["skills", "add", repo, "--all"], {
       stdio: "inherit",
       timeout: 12e4,
@@ -12194,7 +12194,7 @@ function runSkillsAdd(repo) {
       env: { ...process.env, GIT_CLONE_PROTECTION_ACTIVE: "0" }
     });
     child.on("close", (code, signal) => {
-      if (code === 0) resolve43();
+      if (code === 0) resolve45();
       else if (signal === "SIGINT" || code === 130) process.exit(0);
       else reject(new Error(`npx skills add exited with code ${code}`));
     });
@@ -13109,7 +13109,7 @@ function computePeaks(floats, count) {
   return peaks.map((p2) => p2 / maxPeak);
 }
 function decodeAudioPeaks(audioPath) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const proc = spawn3(
       "ffmpeg",
       [
@@ -13142,7 +13142,7 @@ function decodeAudioPeaks(audioPath) {
         return;
       }
       const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + numSamples * 4);
-      resolve43(computePeaks(new Float32Array(ab), PEAK_COUNT));
+      resolve45(computePeaks(new Float32Array(ab), PEAK_COUNT));
     });
     proc.on("error", reject);
   });
@@ -16617,10 +16617,10 @@ function compareDocumentPosition(nodeA, nodeB) {
 function uniqueSort(nodes) {
   nodes = nodes.filter((node, i2, arr) => !arr.includes(node, i2 + 1));
   nodes.sort((a, b2) => {
-    const relative10 = compareDocumentPosition(a, b2);
-    if (relative10 & DocumentPosition.PRECEDING) {
+    const relative11 = compareDocumentPosition(a, b2);
+    if (relative11 & DocumentPosition.PRECEDING) {
       return -1;
-    } else if (relative10 & DocumentPosition.FOLLOWING) {
+    } else if (relative11 & DocumentPosition.FOLLOWING) {
       return 1;
     }
     return 0;
@@ -17082,8 +17082,8 @@ var init_custom_element_registry = __esm({
         } : (element) => element.localName === localName;
         registry.set(localName, { Class, check });
         if (waiting.has(localName)) {
-          for (const resolve43 of waiting.get(localName))
-            resolve43(Class);
+          for (const resolve45 of waiting.get(localName))
+            resolve45(Class);
           waiting.delete(localName);
         }
         ownerDocument.querySelectorAll(
@@ -17123,13 +17123,13 @@ var init_custom_element_registry = __esm({
        */
       whenDefined(localName) {
         const { registry, waiting } = this;
-        return new Promise((resolve43) => {
+        return new Promise((resolve45) => {
           if (registry.has(localName))
-            resolve43(registry.get(localName).Class);
+            resolve45(registry.get(localName).Class);
           else {
             if (!waiting.has(localName))
               waiting.set(localName, []);
-            waiting.get(localName).push(resolve43);
+            waiting.get(localName).push(resolve45);
           }
         });
       }
@@ -29355,7 +29355,7 @@ var init_screenshotService = __esm({
 import { existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
 import { join as join23 } from "path";
 async function driveWarmupTicks(options, state) {
-  const sleep2 = options.sleep ?? realSleep;
+  const sleep3 = options.sleep ?? realSleep;
   while (true) {
     if (options.lockWarmupTicks) {
       if (state.ticks >= LOCKED_WARMUP_TICKS) return;
@@ -29367,7 +29367,7 @@ async function driveWarmupTicks(options, state) {
       state.ticks += 1;
     } catch {
     }
-    await sleep2(options.intervalMs);
+    await sleep3(options.intervalMs);
   }
 }
 async function waitForCloseWithTimeout(promise) {
@@ -29378,10 +29378,10 @@ async function waitForCloseWithTimeout(promise) {
       () => void 0,
       () => void 0
     ),
-    new Promise((resolve43) => {
+    new Promise((resolve45) => {
       timer = setTimeout(() => {
         timedOut = true;
-        resolve43();
+        resolve45();
       }, CAPTURE_SESSION_CLOSE_TIMEOUT_MS);
     })
   ]);
@@ -29479,7 +29479,7 @@ async function pollPageExpression(page, expression, timeoutMs, intervalMs = 100)
   while (Date.now() < deadline) {
     const ready = Boolean(await page.evaluate(expression));
     if (ready) return true;
-    await new Promise((resolve43) => setTimeout(resolve43, intervalMs));
+    await new Promise((resolve45) => setTimeout(resolve45, intervalMs));
   }
   return Boolean(await page.evaluate(expression));
 }
@@ -29496,7 +29496,7 @@ async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await check()) return true;
-    await new Promise((resolve43) => setTimeout(resolve43, intervalMs));
+    await new Promise((resolve45) => setTimeout(resolve45, intervalMs));
   }
   return check();
 }
@@ -29530,7 +29530,7 @@ async function waitForOptionalTailwindReady(page, timeoutMs) {
     page.evaluate(
       `Promise.resolve(window.__tailwindReady).then(() => true, () => false)`
     ),
-    new Promise((resolve43) => setTimeout(() => resolve43(false), timeoutMs))
+    new Promise((resolve45) => setTimeout(() => resolve45(false), timeoutMs))
   ]);
   if (!ready) {
     throw new Error(
@@ -29883,14 +29883,14 @@ var init_frameCapture = __esm({
     BROWSER_CONSOLE_BUFFER_SIZE = 200;
     CAPTURE_SESSION_CLOSE_TIMEOUT_MS = 5e3;
     LOCKED_WARMUP_TICKS = 60;
-    realSleep = (ms) => new Promise((resolve43) => setTimeout(resolve43, ms));
+    realSleep = (ms) => new Promise((resolve45) => setTimeout(resolve45, ms));
   }
 });
 
 // ../engine/src/utils/gpuEncoder.ts
 import { spawn as spawn4 } from "child_process";
 async function detectGpuEncoder() {
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const ffmpeg = spawn4("ffmpeg", ["-encoders"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -29899,13 +29899,13 @@ async function detectGpuEncoder() {
       stdout2 += data.toString();
     });
     ffmpeg.on("close", () => {
-      if (stdout2.includes("h264_nvenc")) resolve43("nvenc");
-      else if (stdout2.includes("h264_videotoolbox")) resolve43("videotoolbox");
-      else if (stdout2.includes("h264_vaapi")) resolve43("vaapi");
-      else if (stdout2.includes("h264_qsv")) resolve43("qsv");
-      else resolve43(null);
+      if (stdout2.includes("h264_nvenc")) resolve45("nvenc");
+      else if (stdout2.includes("h264_videotoolbox")) resolve45("videotoolbox");
+      else if (stdout2.includes("h264_vaapi")) resolve45("vaapi");
+      else if (stdout2.includes("h264_qsv")) resolve45("qsv");
+      else resolve45(null);
     });
-    ffmpeg.on("error", () => resolve43(null));
+    ffmpeg.on("error", () => resolve45(null));
   });
 }
 async function getCachedGpuEncoder() {
@@ -30026,7 +30026,7 @@ async function runFfmpeg(args, opts) {
   const signal = opts?.signal;
   const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
   const onStderr = opts?.onStderr;
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const ffmpeg = spawn5("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -30052,7 +30052,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("close", (code) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve43({
+      resolve45({
         success: !signal?.aborted && code === 0,
         exitCode: code,
         stderr,
@@ -30062,7 +30062,7 @@ async function runFfmpeg(args, opts) {
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve43({
+      resolve45({
         success: false,
         exitCode: null,
         stderr: err.message,
@@ -30293,7 +30293,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   const inputPath = join24(framesDir, framePattern);
   const inputArgs = ["-framerate", fpsToFfmpegArg(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const ffmpeg = spawn6("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -30318,7 +30318,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       if (signal) signal.removeEventListener("abort", onAbort);
       const durationMs = Date.now() - startTime;
       if (signal?.aborted) {
-        resolve43({
+        resolve45({
           success: false,
           outputPath,
           durationMs,
@@ -30329,7 +30329,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       if (code !== 0) {
-        resolve43({
+        resolve45({
           success: false,
           outputPath,
           durationMs,
@@ -30340,12 +30340,12 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
         return;
       }
       const fileSize = existsSync20(outputPath) ? statSync6(outputPath).size : 0;
-      resolve43({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
+      resolve45({ success: true, outputPath, durationMs, framesEncoded: frameCount, fileSize });
     });
     ffmpeg.on("error", (err) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve43({
+      resolve45({
         success: false,
         outputPath,
         durationMs: Date.now() - startTime,
@@ -30403,18 +30403,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     let gpuEncoder = null;
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
-    const chunkResult = await new Promise((resolve43) => {
+    const chunkResult = await new Promise((resolve45) => {
       const ffmpeg = spawn6("ffmpeg", args);
       let stderr = "";
       ffmpeg.stderr.on("data", (d2) => {
         stderr += d2.toString();
       });
       ffmpeg.on("close", (code) => {
-        if (code === 0) resolve43({ success: true });
-        else resolve43({ success: false, error: `Chunk ${i2} encode failed: ${stderr.slice(-400)}` });
+        if (code === 0) resolve45({ success: true });
+        else resolve45({ success: false, error: `Chunk ${i2} encode failed: ${stderr.slice(-400)}` });
       });
       ffmpeg.on("error", (err) => {
-        resolve43({ success: false, error: `Chunk ${i2} encode error: ${err.message}` });
+        resolve45({ success: false, error: `Chunk ${i2} encode error: ${err.message}` });
       });
     });
     if (!chunkResult.success) {
@@ -30444,18 +30444,18 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     "-y",
     outputPath
   ];
-  const concatResult = await new Promise((resolve43) => {
+  const concatResult = await new Promise((resolve45) => {
     const ffmpeg = spawn6("ffmpeg", concatArgs);
     let stderr = "";
     ffmpeg.stderr.on("data", (d2) => {
       stderr += d2.toString();
     });
     ffmpeg.on("close", (code) => {
-      if (code === 0) resolve43({ success: true });
-      else resolve43({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
+      if (code === 0) resolve45({ success: true });
+      else resolve45({ success: false, error: `Chunk concat failed: ${stderr.slice(-400)}` });
     });
     ffmpeg.on("error", (err) => {
-      resolve43({ success: false, error: `Chunk concat error: ${err.message}` });
+      resolve45({ success: false, error: `Chunk concat error: ${err.message}` });
     });
   });
   if (!concatResult.success) {
@@ -30557,37 +30557,37 @@ import { dirname as dirname8 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
   const pending = /* @__PURE__ */ new Map();
-  const enqueueAt = (frame, resolve43) => {
+  const enqueueAt = (frame, resolve45) => {
     const list = pending.get(frame);
     if (list === void 0) {
-      pending.set(frame, [resolve43]);
+      pending.set(frame, [resolve45]);
     } else {
-      list.push(resolve43);
+      list.push(resolve45);
     }
   };
   const flushAt = (frame) => {
     const list = pending.get(frame);
     if (list === void 0) return;
     pending.delete(frame);
-    for (const resolve43 of list) resolve43();
+    for (const resolve45 of list) resolve45();
   };
-  const waitForFrame = (frame) => new Promise((resolve43) => {
+  const waitForFrame = (frame) => new Promise((resolve45) => {
     if (frame === cursor) {
-      resolve43();
+      resolve45();
       return;
     }
-    enqueueAt(frame, resolve43);
+    enqueueAt(frame, resolve45);
   });
   const advanceTo = (frame) => {
     cursor = frame;
     flushAt(frame);
   };
-  const waitForAllDone = () => new Promise((resolve43) => {
+  const waitForAllDone = () => new Promise((resolve45) => {
     if (cursor >= endFrame) {
-      resolve43();
+      resolve45();
       return;
     }
-    enqueueAt(endFrame, resolve43);
+    enqueueAt(endFrame, resolve45);
   });
   return { waitForFrame, advanceTo, waitForAllDone };
 }
@@ -30768,7 +30768,7 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
   let stderr = "";
   let exitCode = null;
   let exitPromiseResolve = null;
-  const exitPromise = new Promise((resolve43) => exitPromiseResolve = resolve43);
+  const exitPromise = new Promise((resolve45) => exitPromiseResolve = resolve45);
   ffmpeg.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
@@ -30828,8 +30828,8 @@ Process error: ${err.message}`;
       if (signal) signal.removeEventListener("abort", onAbort);
       const stdin = ffmpeg.stdin;
       if (stdin && !stdin.destroyed) {
-        await new Promise((resolve43) => {
-          stdin.end(() => resolve43());
+        await new Promise((resolve45) => {
+          stdin.end(() => resolve45());
         });
       }
       await exitPromise;
@@ -30873,7 +30873,7 @@ import { spawn as spawn8 } from "child_process";
 import { readFileSync as readFileSync18 } from "fs";
 import { extname as extname5 } from "path";
 function runFfprobe(args) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const proc = spawn8("ffprobe", args);
     let stdout2 = "";
     let stderr = "";
@@ -30887,7 +30887,7 @@ function runFfprobe(args) {
       if (code !== 0) {
         reject(new Error(`[FFmpeg] ffprobe exited with code ${code}: ${stderr}`));
       } else {
-        resolve43(stdout2);
+        resolve45(stdout2);
       }
     });
     proc.on("error", (err) => {
@@ -31738,9 +31738,165 @@ var init_staticGuard = __esm({
   }
 });
 
+// ../core/src/compiler/inlineSubCompositions.ts
+function defaultBuildScopeSelector(compId) {
+  const escaped = compId.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `[data-composition-id="${escaped}"]`;
+}
+function inlineSubCompositions(document2, hosts, options) {
+  const {
+    resolveHtml,
+    parseHtml: parseHtml2,
+    hostIdentityMap,
+    rewriteInlineStyles = false,
+    flattenInnerRoot,
+    readVariableDefaults,
+    parseHostVariables,
+    buildScopeSelector = defaultBuildScopeSelector,
+    scriptErrorLabel = "[HyperFrames] composition script error:",
+    onMissingComposition
+  } = options;
+  const styles = [];
+  const scripts = [];
+  const externalScriptSrcs = [];
+  const variablesByComp = {};
+  for (const hostEl of hosts) {
+    const src = hostEl.getAttribute("data-composition-src");
+    if (!src) continue;
+    const compHtml = resolveHtml(src);
+    if (compHtml == null) {
+      if (onMissingComposition) {
+        onMissingComposition(src);
+      }
+      continue;
+    }
+    const compDoc = parseHtml2(compHtml);
+    let compId;
+    let runtimeCompId;
+    if (hostIdentityMap) {
+      const identity = hostIdentityMap.get(hostEl);
+      compId = identity?.authoredCompositionId || null;
+      runtimeCompId = identity?.runtimeCompositionId || compId || "";
+    } else {
+      compId = hostEl.getAttribute("data-composition-id") || null;
+      runtimeCompId = compId || "";
+    }
+    const contentRoot = compDoc.querySelector("template");
+    const contentHtml = contentRoot ? contentRoot.innerHTML || "" : compDoc.body?.innerHTML || "";
+    const contentDoc = parseHtml2(contentHtml);
+    const innerRoot = compId ? contentDoc.querySelector(`[data-composition-id="${compId}"]`) : contentDoc.querySelector("[data-composition-id]");
+    const inferredCompId = innerRoot?.getAttribute("data-composition-id")?.trim() || "";
+    const authoredRootId = innerRoot?.getAttribute("id")?.trim() || null;
+    const scopeCompId = compId || inferredCompId;
+    const runtimeScope = runtimeCompId ? buildScopeSelector(runtimeCompId) : "";
+    if (readVariableDefaults && parseHostVariables && runtimeCompId) {
+      const mergedVariables = {
+        ...readVariableDefaults(compDoc.documentElement),
+        ...parseHostVariables(hostEl)
+      };
+      if (Object.keys(mergedVariables).length > 0) {
+        variablesByComp[runtimeCompId] = mergedVariables;
+      }
+    }
+    if (!contentRoot && compDoc.head) {
+      for (const s2 of [...compDoc.head.querySelectorAll("style")]) {
+        const css = rewriteCssAssetUrls(s2.textContent || "", src);
+        styles.push(
+          scopeCompId ? scopeCssToComposition(css, scopeCompId, runtimeScope || void 0, authoredRootId) : css
+        );
+      }
+      for (const s2 of [...compDoc.head.querySelectorAll("script")]) {
+        const externalSrc = (s2.getAttribute("src") || "").trim();
+        if (externalSrc && !externalScriptSrcs.includes(externalSrc)) {
+          externalScriptSrcs.push(externalSrc);
+        }
+      }
+    }
+    for (const s2 of [...contentDoc.querySelectorAll("style")]) {
+      const css = rewriteCssAssetUrls(s2.textContent || "", src);
+      styles.push(
+        scopeCompId ? scopeCssToComposition(css, scopeCompId, runtimeScope || void 0, authoredRootId) : css
+      );
+      s2.remove();
+    }
+    for (const s2 of [...contentDoc.querySelectorAll("script")]) {
+      const externalSrc = (s2.getAttribute("src") || "").trim();
+      if (externalSrc) {
+        if (!externalScriptSrcs.includes(externalSrc)) {
+          externalScriptSrcs.push(externalSrc);
+        }
+      } else {
+        scripts.push(
+          scopeCompId ? wrapScopedCompositionScript(
+            s2.textContent || "",
+            scopeCompId,
+            scriptErrorLabel,
+            runtimeScope || void 0,
+            runtimeCompId || scopeCompId,
+            authoredRootId
+          ) : `(function(){ try { ${s2.textContent || ""} } catch (_err) { console.error(${JSON.stringify(scriptErrorLabel)}, _err); } })();`
+        );
+      }
+      s2.remove();
+    }
+    const assetEls = innerRoot ? innerRoot.querySelectorAll("[src], [href]") : contentDoc.querySelectorAll("[src], [href]");
+    rewriteAssetPaths(
+      assetEls,
+      src,
+      (el, attr) => el.getAttribute(attr),
+      (el, attr, val) => {
+        el.setAttribute(attr, val);
+      }
+    );
+    if (rewriteInlineStyles) {
+      const styledEls = innerRoot ? innerRoot.querySelectorAll("[style]") : contentDoc.querySelectorAll("[style]");
+      rewriteInlineStyleAssetUrls(
+        styledEls,
+        src,
+        (el) => el.getAttribute("style"),
+        (el, val) => {
+          el.setAttribute("style", val);
+        }
+      );
+    }
+    if (innerRoot) {
+      const innerW = innerRoot.getAttribute("data-width");
+      const innerH = innerRoot.getAttribute("data-height");
+      if (innerW && !hostEl.getAttribute("data-width")) hostEl.setAttribute("data-width", innerW);
+      if (innerH && !hostEl.getAttribute("data-height")) {
+        hostEl.setAttribute("data-height", innerH);
+      }
+    }
+    if (innerRoot) {
+      innerRoot.setAttribute("data-composition-file", src);
+      for (const child of [...innerRoot.querySelectorAll("style, script")]) child.remove();
+      if (flattenInnerRoot) {
+        const prepared = flattenInnerRoot(innerRoot);
+        hostEl.innerHTML = prepared.outerHTML || "";
+      } else {
+        hostEl.innerHTML = compId ? innerRoot.innerHTML || "" : innerRoot.outerHTML || "";
+      }
+    } else {
+      for (const child of [...contentDoc.querySelectorAll("style, script")]) child.remove();
+      const bodyHtml = contentDoc.body?.innerHTML || "";
+      hostEl.innerHTML = bodyHtml || contentDoc.documentElement?.outerHTML || "";
+    }
+    hostEl.setAttribute("data-composition-file", src);
+    hostEl.removeAttribute("data-composition-src");
+  }
+  return { styles, scripts, externalScriptSrcs, variablesByComp };
+}
+var init_inlineSubCompositions = __esm({
+  "../core/src/compiler/inlineSubCompositions.ts"() {
+    "use strict";
+    init_rewriteSubCompPaths();
+    init_compositionScoping();
+  }
+});
+
 // ../core/src/compiler/htmlBundler.ts
 import { readFileSync as readFileSync19, existsSync as existsSync23 } from "fs";
-import { join as join26, resolve as resolve14, isAbsolute as isAbsolute3, sep as sep3 } from "path";
+import { join as join26, resolve as resolve14, relative as relative3, dirname as dirname9, isAbsolute as isAbsolute3, sep as sep3 } from "path";
 import { transformSync } from "esbuild";
 function safePath(projectDir, relativePath) {
   const resolved = resolve14(projectDir, relativePath);
@@ -31794,6 +31950,70 @@ function safeReadFile(filePath) {
     return null;
   }
 }
+function withCommentsStripped(css, fn) {
+  const comments = [];
+  const stripped = css.replace(CSS_COMMENT_RE, (m2) => {
+    const idx = comments.length;
+    comments.push(m2);
+    return `/*__hf_c${idx}__*/`;
+  });
+  const result = fn(stripped);
+  const restore = (s2) => {
+    let out = s2;
+    for (let i2 = 0; i2 < comments.length; i2++) {
+      out = out.replace(`/*__hf_c${i2}__*/`, comments[i2]);
+    }
+    return out;
+  };
+  return { result, restore };
+}
+function rebaseCssUrls(css, cssFileDir, projectDir) {
+  const resolvedRoot = resolve14(projectDir);
+  const resolvedDir = resolve14(cssFileDir);
+  if (resolvedDir === resolvedRoot) return css;
+  return css.replace(REBASE_URL_RE, (full, quote, urlValue) => {
+    if (!urlValue || !isRelativeUrl(urlValue)) return full;
+    const { basePath, suffix } = splitUrlSuffix(urlValue.trim());
+    if (!basePath) return full;
+    const absolutePath = resolve14(resolvedDir, basePath);
+    const rebased = relative3(resolvedRoot, absolutePath).split(sep3).join("/");
+    if (rebased === basePath) return full;
+    return `url(${quote || ""}${rebased}${suffix}${quote || ""})`;
+  });
+}
+function inlineCssFile(css, cssFileDir, projectDir, visited = /* @__PURE__ */ new Set()) {
+  const { result: strippedCss, restore: restoreComments } = withCommentsStripped(css, (s2) => s2);
+  const importPlaceholders = [];
+  const withPlaceholders = strippedCss.replace(
+    CSS_IMPORT_RE,
+    (full, _q1, urlPath, _q2, barePath, mediaQuery) => {
+      const importPath = urlPath ?? barePath;
+      if (!importPath || !isRelativeUrl(importPath)) return full;
+      const resolved = resolve14(cssFileDir, importPath);
+      const normalizedBase = resolve14(projectDir) + sep3;
+      if (!resolved.startsWith(normalizedBase)) return full;
+      if (visited.has(resolved)) return "";
+      const content = safeReadFile(resolved);
+      if (content == null) return full;
+      visited.add(resolved);
+      const inlined = inlineCssFile(content, dirname9(resolved), projectDir, visited);
+      const trimmedMedia = (mediaQuery || "").trim();
+      const block = trimmedMedia ? `@media ${trimmedMedia} {
+${inlined}
+}
+` : inlined + "\n";
+      const idx = importPlaceholders.length;
+      importPlaceholders.push(block);
+      return `/*__hf_import_${idx}__*/`;
+    }
+  );
+  let rebased = rebaseCssUrls(withPlaceholders, cssFileDir, projectDir);
+  rebased = restoreComments(rebased);
+  for (let i2 = 0; i2 < importPlaceholders.length; i2++) {
+    rebased = rebased.replace(`/*__hf_import_${i2}__*/`, importPlaceholders[i2]);
+  }
+  return rebased;
+}
 function safeReadFileBuffer(filePath) {
   if (!existsSync23(filePath)) return null;
   try {
@@ -32107,9 +32327,10 @@ async function bundleToSingleHtml(projectDir, options) {
     const href = el.getAttribute("href");
     if (!href || !isRelativeUrl(href)) continue;
     const cssPath = safePath(projectDir, href);
-    const css = cssPath ? safeReadFile(cssPath) : null;
+    if (!cssPath) continue;
+    const css = safeReadFile(cssPath);
     if (css == null) continue;
-    localCssChunks.push(css);
+    localCssChunks.push(inlineCssFile(css, dirname9(cssPath), projectDir));
     if (!cssAnchorPlaced) {
       const anchor = document2.createElement("style");
       anchor.setAttribute("data-hf-bundled-local-css", "1");
@@ -32160,118 +32381,35 @@ async function bundleToSingleHtml(projectDir, options) {
       document2.body.appendChild(script);
     }
   }
-  const compStyleChunks = [];
-  const compScriptChunks = [];
-  const compExternalScriptSrcs = [];
-  const compVariablesByComp = {};
   const trackedCompositionHosts = getBundledTrackedCompositionHosts(document2);
   const hostIdentityByElement = assignBundledRuntimeCompositionIds(trackedCompositionHosts);
   const subCompositionHosts = trackedCompositionHosts.filter(
     (host) => host.hasAttribute("data-composition-src")
   );
-  for (const hostEl of subCompositionHosts) {
-    const src = hostEl.getAttribute("data-composition-src");
-    if (!src || !isRelativeUrl(src)) continue;
-    const compPath = safePath(projectDir, src);
-    const compHtml = compPath ? safeReadFile(compPath) : null;
-    if (compHtml == null) {
-      console.warn(`[Bundler] Composition file not found: ${src}`);
-      continue;
-    }
-    const compDoc = parseHTMLContent(compHtml);
-    const hostIdentity = hostIdentityByElement.get(hostEl);
-    const compId = hostIdentity?.authoredCompositionId || null;
-    const runtimeCompId = hostIdentity?.runtimeCompositionId || compId || "";
-    const contentRoot = compDoc.querySelector("template");
-    const contentHtml = contentRoot ? contentRoot.innerHTML || "" : compDoc.body.innerHTML || "";
-    const contentDoc = parseHTMLContent(contentHtml);
-    const innerRoot = compId ? contentDoc.querySelector(`[data-composition-id="${compId}"]`) : contentDoc.querySelector("[data-composition-id]");
-    const inferredCompId = innerRoot?.getAttribute("data-composition-id")?.trim() || "";
-    const authoredRootId = innerRoot?.getAttribute("id")?.trim() || null;
-    const scopeCompId = compId || inferredCompId;
-    const runtimeScope = runtimeCompId ? cssAttributeSelector("data-composition-id", runtimeCompId) : "";
-    const mergedVariables = runtimeCompId ? {
-      ...readDeclaredDefaults(compDoc.documentElement),
-      ...parseHostVariableValues(hostEl)
-    } : {};
-    if (runtimeCompId && Object.keys(mergedVariables).length > 0) {
-      compVariablesByComp[runtimeCompId] = mergedVariables;
-    }
-    if (!contentRoot && compDoc.head) {
-      for (const s2 of [...compDoc.head.querySelectorAll("style")]) {
-        const css = rewriteCssAssetUrls(s2.textContent || "", src);
-        compStyleChunks.push(
-          scopeCompId ? scopeCssToComposition(css, scopeCompId, runtimeScope, authoredRootId) : css
-        );
-      }
-      for (const s2 of [...compDoc.head.querySelectorAll("script")]) {
-        const externalSrc = (s2.getAttribute("src") || "").trim();
-        if (externalSrc && !compExternalScriptSrcs.includes(externalSrc)) {
-          compExternalScriptSrcs.push(externalSrc);
-        }
-      }
-    }
-    for (const s2 of [...contentDoc.querySelectorAll("style")]) {
-      const css = rewriteCssAssetUrls(s2.textContent || "", src);
-      compStyleChunks.push(
-        scopeCompId ? scopeCssToComposition(css, scopeCompId, runtimeScope, authoredRootId) : css
-      );
-      s2.remove();
-    }
-    for (const s2 of [...contentDoc.querySelectorAll("script")]) {
-      const externalSrc = (s2.getAttribute("src") || "").trim();
-      if (externalSrc) {
-        if (!compExternalScriptSrcs.includes(externalSrc)) {
-          compExternalScriptSrcs.push(externalSrc);
-        }
-      } else {
-        compScriptChunks.push(
-          scopeCompId ? wrapScopedCompositionScript(
-            s2.textContent || "",
-            scopeCompId,
-            "[HyperFrames] composition script error:",
-            runtimeScope,
-            runtimeCompId || scopeCompId,
-            authoredRootId
-          ) : `(function(){ try { ${s2.textContent || ""} } catch (_err) { console.error('[HyperFrames] composition script error:', _err); } })();`
-        );
-      }
-      s2.remove();
-    }
-    const assetEls = innerRoot ? innerRoot.querySelectorAll("[src], [href]") : contentDoc.querySelectorAll("[src], [href]");
-    rewriteAssetPaths(
-      assetEls,
-      src,
-      (el, attr) => el.getAttribute(attr),
-      (el, attr, val) => {
-        el.setAttribute(attr, val);
-      }
-    );
-    const styledEls = innerRoot ? innerRoot.querySelectorAll("[style]") : contentDoc.querySelectorAll("[style]");
-    rewriteInlineStyleAssetUrls(
-      styledEls,
-      src,
-      (el) => el.getAttribute("style"),
-      (el, val) => {
-        el.setAttribute("style", val);
-      }
-    );
-    if (innerRoot) {
-      const innerW = innerRoot.getAttribute("data-width");
-      const innerH = innerRoot.getAttribute("data-height");
-      if (innerW && !hostEl.getAttribute("data-width")) hostEl.setAttribute("data-width", innerW);
-      if (innerH && !hostEl.getAttribute("data-height")) hostEl.setAttribute("data-height", innerH);
-      innerRoot.setAttribute("data-composition-file", src);
-      for (const child of [...innerRoot.querySelectorAll("style, script")]) child.remove();
-      const preparedInnerRoot = prepareFlattenedInnerRoot(innerRoot);
-      hostEl.innerHTML = preparedInnerRoot.outerHTML || "";
-    } else {
-      for (const child of [...contentDoc.querySelectorAll("style, script")]) child.remove();
-      hostEl.innerHTML = contentDoc.body.innerHTML || "";
+  const subCompResult = inlineSubCompositions(document2, subCompositionHosts, {
+    resolveHtml: (srcPath) => {
+      if (!isRelativeUrl(srcPath)) return null;
+      const compPath = safePath(projectDir, srcPath);
+      return compPath ? safeReadFile(compPath) : null;
+    },
+    parseHtml: parseHTMLContent,
+    hostIdentityMap: hostIdentityByElement,
+    rewriteInlineStyles: true,
+    flattenInnerRoot: prepareFlattenedInnerRoot,
+    readVariableDefaults: readDeclaredDefaults,
+    parseHostVariables: parseHostVariableValues,
+    buildScopeSelector: (compId) => cssAttributeSelector("data-composition-id", compId),
+    scriptErrorLabel: "[HyperFrames] composition script error:",
+    onMissingComposition: (srcPath) => {
+      console.warn(`[Bundler] Composition file not found: ${srcPath}`);
     }
-    hostEl.setAttribute("data-composition-file", src);
-    hostEl.removeAttribute("data-composition-src");
-  }
+  });
+  const compStyleChunks = [...subCompResult.styles];
+  const compScriptChunks = [...subCompResult.scripts];
+  const compExternalScriptSrcs = [...subCompResult.externalScriptSrcs];
+  const compVariablesByComp = {
+    ...subCompResult.variablesByComp
+  };
   const candidateInlineHosts = trackedCompositionHosts.filter(
     (host) => !host.hasAttribute("data-composition-src")
   );
@@ -32409,18 +32547,21 @@ async function bundleToSingleHtml(projectDir, options) {
   }
   return document2.toString();
 }
-var DEFAULT_RUNTIME_SCRIPT_URL, FLATTENED_INNER_ROOT_STRIP_ATTRS;
+var DEFAULT_RUNTIME_SCRIPT_URL, CSS_IMPORT_RE, REBASE_URL_RE, CSS_COMMENT_RE, FLATTENED_INNER_ROOT_STRIP_ATTRS;
 var init_htmlBundler = __esm({
   "../core/src/compiler/htmlBundler.ts"() {
     "use strict";
     init_htmlCompiler();
     init_htmlDocument();
-    init_rewriteSubCompPaths();
     init_compositionScoping();
     init_staticGuard();
     init_runtime_inline();
     init_getVariables();
+    init_inlineSubCompositions();
     DEFAULT_RUNTIME_SCRIPT_URL = "";
+    CSS_IMPORT_RE = /@import\s+(?:url\(\s*(["']?)([^)"']+)\1\s*\)|(["'])([^"']+)\3)\s*([^;]*);\s*/g;
+    REBASE_URL_RE = /\burl\(\s*(["']?)([^)"']+)\1\s*\)/g;
+    CSS_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
     FLATTENED_INNER_ROOT_STRIP_ATTRS = [
       "data-composition-id",
       "data-composition-file",
@@ -32448,6 +32589,7 @@ __export(compiler_exports, {
   injectDurations: () => injectDurations,
   injectScriptsAtHeadStart: () => injectScriptsAtHeadStart,
   injectScriptsIntoHtml: () => injectScriptsIntoHtml,
+  inlineSubCompositions: () => inlineSubCompositions,
   parseHTMLContent: () => parseHTMLContent,
   scopeCssToComposition: () => scopeCssToComposition,
   shouldClampMediaDuration: () => shouldClampMediaDuration,
@@ -32464,6 +32606,7 @@ var init_compiler = __esm({
     init_htmlDocument();
     init_staticGuard();
     init_compositionScoping();
+    init_inlineSubCompositions();
   }
 });
 
@@ -32675,7 +32818,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   args.push("-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0");
   if (format === "png") args.push("-compression_level", "6");
   args.push("-y", outputPattern);
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const ffmpeg = spawn9("ffmpeg", args);
     let stderr = "";
     const onAbort = () => {
@@ -32710,7 +32853,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       files.forEach((file, index) => {
         framePaths.set(index, join28(videoOutputDir, file));
       });
-      resolve43({
+      resolve45({
         videoId,
         srcPath: videoPath,
         outputDir: videoOutputDir,
@@ -33645,7 +33788,7 @@ var init_videoFrameInjector = __esm({
 
 // ../engine/src/services/audioMixer.ts
 import { existsSync as existsSync26, mkdirSync as mkdirSync16, rmSync as rmSync6 } from "fs";
-import { isAbsolute as isAbsolute5, join as join29, dirname as dirname9 } from "path";
+import { isAbsolute as isAbsolute5, join as join29, dirname as dirname10 } from "path";
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -33695,7 +33838,7 @@ function parseAudioElements(html) {
 }
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG2.ffmpegProcessTimeout;
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync26(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = ["-i", videoPath];
   if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
@@ -33722,7 +33865,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 = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync26(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-ss",
@@ -33758,7 +33901,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 = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync26(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const args = [
     "-f",
@@ -33801,7 +33944,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       error: result2.error
     };
   }
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync26(outputDir)) mkdirSync16(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
@@ -34288,11 +34431,11 @@ function createFileServer(options) {
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const server = serve({ fetch: app.fetch, port }, (info) => {
       const actualPort = info.port;
       const url = `http://localhost:${actualPort}`;
-      resolve43({
+      resolve45({
         url,
         port: actualPort,
         close: () => server.close()
@@ -36378,7 +36521,7 @@ var init_deterministicFonts = __esm({
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync31, readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname10, resolve as resolve16 } from "path";
+import { dirname as dirname11, resolve as resolve16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
   if (process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH) {
@@ -36414,7 +36557,7 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Invalid manifest at ${manifestPath}; missing iife artifact or sha256.`
     );
   }
-  const runtimePath = resolve16(dirname10(manifestPath), runtimeFileName);
+  const runtimePath = resolve16(dirname11(manifestPath), runtimeFileName);
   if (!existsSync31(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
@@ -36437,7 +36580,7 @@ var PRODUCER_DIR, SIBLING_MANIFEST_PATH, MODULE_RELATIVE_MANIFEST_PATH, CWD_RELA
 var init_hyperframeRuntimeLoader = __esm({
   "../producer/src/services/hyperframeRuntimeLoader.ts"() {
     "use strict";
-    PRODUCER_DIR = dirname10(fileURLToPath2(import.meta.url));
+    PRODUCER_DIR = dirname11(fileURLToPath2(import.meta.url));
     SIBLING_MANIFEST_PATH = resolve16(PRODUCER_DIR, "hyperframe.manifest.json");
     MODULE_RELATIVE_MANIFEST_PATH = resolve16(
       PRODUCER_DIR,
@@ -36667,10 +36810,10 @@ function createFileServer2(options) {
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const connections = /* @__PURE__ */ new Set();
     const server = serve2({ fetch: app.fetch, port }, (info) => {
-      resolve43({
+      resolve45({
         url: `http://localhost:${info.port}`,
         port: info.port,
         addPreHeadScript: (script) => {
@@ -36971,11 +37114,11 @@ import {
   isAbsolute as nodeIsAbsolute
 } from "path";
 function isPathInside2(childPath, parentPath, options = {}) {
-  const resolvePath = options.pathModule?.resolve ?? nodeResolve;
+  const resolvePath3 = options.pathModule?.resolve ?? nodeResolve;
   const relativePath = options.pathModule?.relative ?? nodeRelative;
   const isPathAbsolute = options.pathModule?.isAbsolute ?? nodeIsAbsolute;
-  const absChild = resolvePath(childPath);
-  const absParent = resolvePath(parentPath);
+  const absChild = resolvePath3(childPath);
+  const absParent = resolvePath3(parentPath);
   if (absChild === absParent) return true;
   const rel = relativePath(absParent, absChild);
   return rel !== "" && !rel.startsWith("..") && !isPathAbsolute(rel);
@@ -37007,7 +37150,7 @@ var init_paths = __esm({
 
 // ../producer/src/services/render/shared.ts
 import { copyFileSync as copyFileSync2, cpSync, existsSync as existsSync33, mkdirSync as mkdirSync19, symlinkSync, writeFileSync as writeFileSync15 } from "fs";
-import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute6, join as join36, relative as relative3, resolve as resolve18 } from "path";
+import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute6, join as join36, relative as relative4, resolve as resolve18 } from "path";
 function projectBrowserEndToCompositionTimeline(existingStart, browserStart, browserEnd) {
   return browserEnd + (existingStart - browserStart);
 }
@@ -37048,7 +37191,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
   writeFileSync15(join36(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
     const outPath = join36(compileDir, srcPath);
-    mkdirSync19(dirname11(outPath), { recursive: true });
+    mkdirSync19(dirname12(outPath), { recursive: true });
     writeFileSync15(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
@@ -37057,7 +37200,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync19(dirname11(outPath), { recursive: true });
+    mkdirSync19(dirname12(outPath), { recursive: true });
     copyFileSync2(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -37108,7 +37251,7 @@ function createCompiledFrameSrcResolver(compiledDir) {
   return (framePath) => {
     const resolvedFramePath = resolve18(framePath);
     if (!isPathInside2(resolvedFramePath, compiledRoot)) return null;
-    const relativePath = relative3(compiledRoot, resolvedFramePath);
+    const relativePath = relative4(compiledRoot, resolvedFramePath);
     if (!relativePath || relativePath.startsWith("..") || isAbsolute6(relativePath)) {
       return null;
     }
@@ -37187,9 +37330,9 @@ var init_shared = __esm({
     materializePathModule = {
       resolve: resolve18,
       join: join36,
-      dirname: dirname11,
+      dirname: dirname12,
       basename: basename4,
-      relative: relative3,
+      relative: relative4,
       isAbsolute: isAbsolute6
     };
     materializeFileSystem = {
@@ -37730,7 +37873,7 @@ var init_urlDownloader2 = __esm({
 
 // ../producer/src/services/htmlCompiler.ts
 import { readFileSync as readFileSync24, existsSync as existsSync34, mkdirSync as mkdirSync20 } from "fs";
-import { join as join38, dirname as dirname12, resolve as resolve19 } from "path";
+import { join as join38, dirname as dirname13, resolve as resolve19 } from "path";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
   for (const element of elements) {
@@ -37890,7 +38033,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         item.rawSubHtml,
-        dirname12(item.filePath),
+        dirname13(item.filePath),
         downloadDir
       );
       const nested = await parseSubCompositions(
@@ -38052,108 +38195,31 @@ function coalesceHeadStylesAndBodyScripts2(html) {
   }
   return document2.toString();
 }
-function inlineSubCompositions(html, subCompositions, projectDir) {
+function inlineSubCompositions2(html, subCompositions, projectDir) {
   const { document: document2 } = parseHTML(html);
   const head = document2.querySelector("head");
   const body = document2.querySelector("body");
-  const hosts = document2.querySelectorAll("[data-composition-src]");
+  const hosts = Array.from(document2.querySelectorAll("[data-composition-src]"));
   if (!hosts.length) return html;
-  const collectedStyles = [];
-  const collectedScripts = [];
-  const collectedExternalScriptSrcs = [];
-  for (const host of hosts) {
-    const srcPath = host.getAttribute("data-composition-src");
-    if (!srcPath) continue;
-    let compHtml = subCompositions.get(srcPath) || null;
-    if (!compHtml) {
-      const filePath = resolve19(projectDir, srcPath);
-      if (existsSync34(filePath)) {
-        compHtml = readFileSync24(filePath, "utf-8");
-      }
-    }
-    if (!compHtml) {
-      continue;
-    }
-    const compDoc = parseHTML(compHtml).document;
-    const compId = host.getAttribute("data-composition-id");
-    const templateEl = compDoc.querySelector("template");
-    const bodyEl = compDoc.querySelector("body");
-    const contentHtml = templateEl ? templateEl.innerHTML || "" : bodyEl ? bodyEl.innerHTML || "" : compDoc.toString();
-    const contentDoc = parseHTML(contentHtml).document;
-    const innerRoot = compId ? contentDoc.querySelector(`[data-composition-id="${compId}"]`) : contentDoc.querySelector("[data-composition-id]");
-    const inferredCompId = innerRoot?.getAttribute("data-composition-id")?.trim() || null;
-    if (!templateEl) {
-      const compHead = compDoc.querySelector("head");
-      if (compHead) {
-        for (const styleEl of compHead.querySelectorAll("style")) {
-          const css = rewriteCssAssetUrls(styleEl.textContent || "", srcPath);
-          const scopeId = compId || inferredCompId;
-          if (scopeId && css.trim()) {
-            collectedStyles.push(scopeCssToComposition(css, scopeId));
-          } else {
-            collectedStyles.push(css);
-          }
-        }
-        for (const scriptEl of compHead.querySelectorAll("script")) {
-          const src = (scriptEl.getAttribute("src") || "").trim();
-          if (src && !collectedExternalScriptSrcs.includes(src)) {
-            collectedExternalScriptSrcs.push(src);
+  const result = inlineSubCompositions(
+    document2,
+    hosts,
+    {
+      resolveHtml: (srcPath) => {
+        let compHtml = subCompositions.get(srcPath) || null;
+        if (!compHtml) {
+          const filePath = resolve19(projectDir, srcPath);
+          if (existsSync34(filePath)) {
+            compHtml = readFileSync24(filePath, "utf-8");
           }
         }
-      }
-    }
-    for (const styleEl of contentDoc.querySelectorAll("style")) {
-      const css = rewriteCssAssetUrls(styleEl.textContent || "", srcPath);
-      const scopeId = compId || inferredCompId;
-      if (scopeId && css.trim()) {
-        collectedStyles.push(scopeCssToComposition(css, scopeId));
-      } else {
-        collectedStyles.push(css);
-      }
-      styleEl.remove();
-    }
-    for (const scriptEl of contentDoc.querySelectorAll("script")) {
-      const src = (scriptEl.getAttribute("src") || "").trim();
-      if (src) {
-        if (!collectedExternalScriptSrcs.includes(src)) {
-          collectedExternalScriptSrcs.push(src);
-        }
-        scriptEl.remove();
-        continue;
-      }
-      const content = (scriptEl.textContent || "").trim();
-      if (content) {
-        const scriptMountCompId = compId || inferredCompId || "";
-        collectedScripts.push(
-          scriptMountCompId ? wrapScopedCompositionScript(
-            content,
-            scriptMountCompId,
-            "[Compiler] Composition script failed"
-          ) : `(function(){ try { ${content} } catch (_err) { console.error("[Compiler] Composition script failed", _err); } })()`
-        );
-      }
-      scriptEl.remove();
-    }
-    const rewriteTarget = innerRoot || contentDoc;
-    rewriteAssetPaths(
-      rewriteTarget.querySelectorAll("[src], [href]"),
-      srcPath,
-      (el, attr) => (el.getAttribute(attr) || "").trim(),
-      (el, attr, val) => el.setAttribute(attr, val)
-    );
-    if (innerRoot) {
-      const innerW = innerRoot.getAttribute("data-width");
-      const innerH = innerRoot.getAttribute("data-height");
-      if (innerW && !host.getAttribute("data-width")) host.setAttribute("data-width", innerW);
-      if (innerH && !host.getAttribute("data-height")) host.setAttribute("data-height", innerH);
-      innerRoot.querySelectorAll("style, script").forEach((el) => el.remove());
-      host.innerHTML = compId ? innerRoot.innerHTML || "" : innerRoot.outerHTML || "";
-    } else {
-      contentDoc.querySelectorAll("style, script").forEach((el) => el.remove());
-      host.innerHTML = contentDoc.toString();
+        return compHtml;
+      },
+      parseHtml: (htmlStr) => parseHTML(htmlStr).document,
+      scriptErrorLabel: "[Compiler] Composition script failed"
     }
-    host.setAttribute("data-composition-file", srcPath);
-    host.removeAttribute("data-composition-src");
+  );
+  for (const host of hosts) {
     const hostW = host.getAttribute("data-width");
     const hostH = host.getAttribute("data-height");
     if (hostW && hostH) {
@@ -38169,18 +38235,18 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
       }
     }
   }
-  if (collectedStyles.length && head) {
+  if (result.styles.length && head) {
     const styleEl = document2.createElement("style");
-    styleEl.textContent = collectedStyles.join("\n\n");
+    styleEl.textContent = result.styles.join("\n\n");
     head.appendChild(styleEl);
   }
-  if (collectedExternalScriptSrcs.length && body) {
+  if (result.externalScriptSrcs.length && body) {
     const existingScriptSrcs = new Set(
       Array.from(document2.querySelectorAll("script[src]")).map(
         (el) => (el.getAttribute("src") || "").trim()
       )
     );
-    for (const src of collectedExternalScriptSrcs) {
+    for (const src of result.externalScriptSrcs) {
       if (!existingScriptSrcs.has(src)) {
         const scriptEl = document2.createElement("script");
         scriptEl.setAttribute("src", src);
@@ -38189,9 +38255,9 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
       }
     }
   }
-  if (collectedScripts.length && body) {
+  if (result.scripts.length && body) {
     const scriptEl = document2.createElement("script");
-    scriptEl.textContent = collectedScripts.join("\n;\n");
+    scriptEl.textContent = result.scripts.join("\n;\n");
     body.appendChild(scriptEl);
   }
   return document2.toString();
@@ -38328,7 +38394,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     subCompositions
   } = await parseSubCompositions(compiledHtml, projectDir, downloadDir);
   const fullHtml = ensureFullDocument(compiledHtml);
-  const inlinedHtml = inlineSubCompositions(fullHtml, subCompositions, projectDir);
+  const inlinedHtml = inlineSubCompositions2(fullHtml, subCompositions, projectDir);
   const sanitizedHtml = inlinedHtml.replace(
     /(<(?:video|audio)\b[^>]*?)\s+preload\s*=\s*["']none["']/gi,
     "$1"
@@ -40033,7 +40099,7 @@ var init_captureHdrSequentialLoop = __esm({
 // ../producer/src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
-import { dirname as dirname13, join as join45 } from "path";
+import { dirname as dirname14, join as join45 } from "path";
 import { createRequire } from "module";
 import { existsSync as existsSync36 } from "fs";
 import { cpus as cpus3 } from "os";
@@ -40046,7 +40112,7 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname13(fileURLToPath3(import.meta.url));
+  const moduleDir = dirname14(fileURLToPath3(import.meta.url));
   const jsPath = join45(moduleDir, "shaderTransitionWorker.js");
   if (existsSync36(jsPath)) return { path: jsPath, isTs: false };
   const tsPath = join45(moduleDir, "shaderTransitionWorker.ts");
@@ -40181,8 +40247,8 @@ async function createShaderTransitionWorkerPool(opts) {
       if (terminated) {
         throw new Error("shader-blend pool already terminated");
       }
-      return new Promise((resolve43, reject) => {
-        const task = traceEnabled ? { req, resolve: resolve43, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve43, reject };
+      return new Promise((resolve45, reject) => {
+        const task = traceEnabled ? { req, resolve: resolve45, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve45, reject };
         const idle = slots.find((s2) => !s2.busy);
         if (idle) {
           queue.unshift(task);
@@ -40915,7 +40981,7 @@ import {
   copyFileSync as copyFileSync4,
   appendFileSync
 } from "fs";
-import { join as join49, dirname as dirname14, resolve as resolve20 } from "path";
+import { join as join49, dirname as dirname15, resolve as resolve20 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function sampleDirectoryBytes(dir) {
@@ -41596,10 +41662,10 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
   return document2.toString();
 }
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
-  const moduleDir = dirname14(fileURLToPath4(import.meta.url));
+  const moduleDir = dirname15(fileURLToPath4(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve20(process.env.PRODUCER_RENDERS_DIR, "..") : resolve20(moduleDir, "../..");
   const debugDir = join49(producerRoot, ".debug");
-  const workDir = job.config.debug ? join49(debugDir, job.id) : join49(dirname14(outputPath), `work-${job.id}`);
+  const workDir = job.config.debug ? join49(debugDir, job.id) : join49(dirname15(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log2 = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -42291,10 +42357,10 @@ var init_semaphore = __esm({
           this.active++;
           return () => this.release();
         }
-        return new Promise((resolve43) => {
+        return new Promise((resolve45) => {
           this.queue.push(() => {
             this.active++;
-            resolve43(() => this.release());
+            resolve45(() => this.release());
           });
         });
       }
@@ -42325,7 +42391,7 @@ import {
   rmSync as rmSync10,
   createReadStream
 } from "fs";
-import { resolve as resolve22, dirname as dirname15, join as join51 } from "path";
+import { resolve as resolve22, dirname as dirname16, join as join51 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs as parseArgs2 } from "util";
 import crypto2 from "crypto";
@@ -42502,7 +42568,7 @@ function createRenderHandlers(options = {}) {
       rendersDir,
       log2
     );
-    const outputDir = dirname15(absoluteOutputPath);
+    const outputDir = dirname16(absoluteOutputPath);
     if (!existsSync41(outputDir)) mkdirSync25(outputDir, { recursive: true });
     const release2 = await renderSemaphore.acquire();
     log2.info("render started", {
@@ -42613,7 +42679,7 @@ function createRenderHandlers(options = {}) {
         rendersDir,
         log2
       );
-      const outputDir = dirname15(absoluteOutputPath);
+      const outputDir = dirname16(absoluteOutputPath);
       if (!existsSync41(outputDir)) mkdirSync25(outputDir, { recursive: true });
       log2.info("render-stream started", { requestId, projectDir: input.projectDir });
       const job = createRenderJob({
@@ -42914,7 +42980,7 @@ var init_runtimeEnvSnapshot = __esm({
 
 // ../producer/src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync42, mkdirSync as mkdirSync26, readFileSync as readFileSync28, readdirSync as readdirSync17, writeFileSync as writeFileSync20 } from "fs";
-import { join as join52, relative as relative4, resolve as resolve23 } from "path";
+import { join as join52, relative as relative5, resolve as resolve23 } from "path";
 function stripUndefined(value) {
   if (Array.isArray(value)) return value.map(stripUndefined);
   if (value !== null && typeof value === "object") {
@@ -42940,7 +43006,7 @@ function listPlanFiles(planDir) {
         walk(full);
       } else if (entry.isFile()) {
         results.push({
-          planRelativePath: relative4(rootResolved, full).split(/[\\/]+/).join("/"),
+          planRelativePath: relative5(rootResolved, full).split(/[\\/]+/).join("/"),
           absolutePath: full
         });
       }
@@ -43110,7 +43176,7 @@ var init_planValidation = __esm({
 
 // ../producer/src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "child_process";
-import { dirname as dirname16, join as join53 } from "path";
+import { dirname as dirname17, join as join53 } from "path";
 import { existsSync as existsSync43, readFileSync as readFileSync29 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { promisify as promisify2 } from "util";
@@ -43145,7 +43211,7 @@ function buildSyntheticRenderJob(input) {
 }
 function readProducerVersion() {
   if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname16(fileURLToPath5(import.meta.url));
+  const startDir = dirname17(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i2 = 0; i2 < 10; i2++) {
     const candidate = join53(current, "package.json");
@@ -43159,7 +43225,7 @@ function readProducerVersion() {
       } catch {
       }
     }
-    const parent = dirname16(current);
+    const parent = dirname17(current);
     if (parent === current) break;
     current = parent;
   }
@@ -43190,7 +43256,7 @@ import {
   statSync as statSync15,
   writeFileSync as writeFileSync21
 } from "fs";
-import { join as join54, relative as relative5, sep as sep6 } from "path";
+import { join as join54, relative as relative6, sep as sep6 } from "path";
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
@@ -43375,7 +43441,7 @@ async function plan(projectDir, config, planDir) {
     recursive: true,
     dereference: true,
     filter: (src) => {
-      const rel = relative5(projectDir, src);
+      const rel = relative6(projectDir, src);
       if (rel === "" || rel.startsWith("..")) return true;
       const firstSegment = rel.split(sep6, 1)[0];
       return firstSegment === void 0 || !PLAN_PROJECT_DIR_SKIP_SEGMENTS.has(firstSegment);
@@ -44119,7 +44185,7 @@ async function defaultRunFfmpeg(args) {
   };
 }
 function runFfprobeJson(args) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const proc = spawn10("ffprobe", args);
     let stdout2 = "";
     let stderr = "";
@@ -44142,7 +44208,7 @@ function runFfprobeJson(args) {
         return;
       }
       try {
-        resolve43(JSON.parse(stdout2));
+        resolve45(JSON.parse(stdout2));
       } catch (err) {
         reject(new Error(`Failed to parse ffprobe output: ${err.message}`));
       }
@@ -44169,7 +44235,7 @@ import {
   statSync as statSync16,
   writeFileSync as writeFileSync23
 } from "fs";
-import { dirname as dirname17, join as join56 } from "path";
+import { dirname as dirname18, join as join56 } from "path";
 async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   const start = Date.now();
   const log2 = options?.logger ?? defaultLogger;
@@ -44197,8 +44263,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   if (plan2.dimensions.format === "png-sequence") {
     return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
   }
-  if (!existsSync46(dirname17(outputPath))) {
-    mkdirSync29(dirname17(outputPath), { recursive: true });
+  if (!existsSync46(dirname18(outputPath))) {
+    mkdirSync29(dirname18(outputPath), { recursive: true });
   }
   const workDir = `${outputPath}.assemble-work`;
   if (existsSync46(workDir)) rmSync13(workDir, { recursive: true, force: true });
@@ -44810,13 +44876,13 @@ __export(preview_exports, {
 });
 import { spawn as spawn11 } from "child_process";
 import { existsSync as existsSync48, lstatSync as lstatSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync5, readlinkSync, mkdirSync as mkdirSync30 } from "fs";
-import { resolve as resolve25, dirname as dirname18, basename as basename6, join as join58 } from "path";
+import { resolve as resolve25, dirname as dirname19, basename as basename6, join as join58 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { createRequire as createRequire2 } from "module";
 async function runDevMode(dir, options) {
   const thisFile = fileURLToPath6(import.meta.url);
-  const repoRoot = resolve25(dirname18(thisFile), "..", "..", "..", "..");
-  const projectsDir = join58(repoRoot, "packages", "studio", "data", "projects");
+  const repoRoot2 = resolve25(dirname19(thisFile), "..", "..", "..", "..");
+  const projectsDir = join58(repoRoot2, "packages", "studio", "data", "projects");
   const pName = options?.projectName ?? basename6(dir);
   const symlinkPath = join58(projectsDir, pName);
   mkdirSync30(projectsDir, { recursive: true });
@@ -44842,7 +44908,7 @@ async function runDevMode(dir, options) {
   ge(c2.bold("hyperframes preview"));
   const s2 = ft();
   s2.start("Starting studio...");
-  const studioPkgDir = join58(repoRoot, "packages", "studio");
+  const studioPkgDir = join58(repoRoot2, "packages", "studio");
   const child = spawn11("bun", ["run", "dev"], {
     cwd: studioPkgDir,
     stdio: ["ignore", "pipe", "pipe"]
@@ -44885,8 +44951,8 @@ async function runDevMode(dir, options) {
       }
     });
   }
-  return new Promise((resolve43) => {
-    child.on("close", () => resolve43());
+  return new Promise((resolve45) => {
+    child.on("close", () => resolve45());
   });
 }
 function hasLocalStudio(dir) {
@@ -44900,7 +44966,7 @@ function hasLocalStudio(dir) {
 }
 async function runLocalStudioMode(dir, options) {
   const req = createRequire2(join58(dir, "package.json"));
-  const studioPkgPath = dirname18(req.resolve("@hyperframes/studio/package.json"));
+  const studioPkgPath = dirname19(req.resolve("@hyperframes/studio/package.json"));
   const pName = options?.projectName ?? basename6(dir);
   const projectsDir = join58(studioPkgPath, "data", "projects");
   const symlinkPath = join58(projectsDir, pName);
@@ -44960,8 +45026,8 @@ async function runLocalStudioMode(dir, options) {
       }
     });
   }
-  return new Promise((resolve43) => {
-    child.on("close", () => resolve43());
+  return new Promise((resolve45) => {
+    child.on("close", () => resolve45());
   });
 }
 async function runEmbeddedMode(dir, startPort, options) {
@@ -45209,7 +45275,7 @@ import {
   readFileSync as readFileSync33,
   readdirSync as readdirSync21
 } from "fs";
-import { resolve as resolve26, basename as basename7, join as join59, dirname as dirname19 } from "path";
+import { resolve as resolve26, basename as basename7, join as join59, dirname as dirname20 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { execFileSync as execFileSync5, spawn as spawn12 } from "child_process";
 function probeVideo(filePath) {
@@ -45278,7 +45344,7 @@ function transcodeToMp4(inputPath, outputPath) {
   });
 }
 function resolveAssetDir(devSegments, builtSegments) {
-  const base = dirname19(fileURLToPath7(import.meta.url));
+  const base = dirname20(fileURLToPath7(import.meta.url));
   const devPath = resolve26(base, ...devSegments);
   const builtPath = resolve26(base, ...builtSegments);
   return existsSync49(devPath) ? devPath : builtPath;
@@ -46064,7 +46130,7 @@ __export(add_exports, {
   runAdd: () => runAdd
 });
 import { existsSync as existsSync50 } from "fs";
-import { resolve as resolve27, relative as relative6 } from "path";
+import { resolve as resolve27, relative as relative7 } from "path";
 function remapTarget(item, originalTarget, paths) {
   if (item.type === "hyperframes:block") {
     const blocksDir = paths.blocks.replace(/\/+$/, "");
@@ -46206,7 +46272,7 @@ var init_add = __esm({
           console.log("");
           console.log(`${c2.success("\u2713")} Added ${c2.accent(result.name)} (${result.type})`);
           for (const file of result.written) {
-            console.log(`  ${c2.dim(relative6(projectDir, file))}`);
+            console.log(`  ${c2.dim(relative7(projectDir, file))}`);
           }
           if (result.snippet) {
             console.log("");
@@ -46479,9 +46545,9 @@ __export(play_exports, {
   examples: () => examples5
 });
 import { existsSync as existsSync52, readFileSync as readFileSync34 } from "fs";
-import { resolve as resolve30, dirname as dirname20 } from "path";
+import { resolve as resolve30, dirname as dirname21 } from "path";
 function commandDir() {
-  return dirname20(new URL(import.meta.url).pathname);
+  return dirname21(new URL(import.meta.url).pathname);
 }
 function resolveRuntimePath2() {
   const d2 = commandDir();
@@ -46712,7 +46778,7 @@ var init_play = __esm({
 });
 
 // src/utils/publishProject.ts
-import { basename as basename9, join as join60, relative as relative7 } from "path";
+import { basename as basename9, join as join60, relative as relative8 } from "path";
 import { readdirSync as readdirSync22, readFileSync as readFileSync35, statSync as statSync19 } from "fs";
 import AdmZip from "adm-zip";
 function isRecord2(value) {
@@ -46814,7 +46880,7 @@ function collectProjectFiles(rootDir, currentDir, paths) {
   for (const entry of readdirSync22(currentDir, { withFileTypes: true })) {
     if (shouldIgnoreSegment(entry.name)) continue;
     const absolutePath = join60(currentDir, entry.name);
-    const relativePath = relative7(rootDir, absolutePath).replaceAll("\\", "/");
+    const relativePath = relative8(rootDir, absolutePath).replaceAll("\\", "/");
     if (!relativePath) continue;
     if (entry.isDirectory()) {
       collectProjectFiles(rootDir, absolutePath, paths);
@@ -47187,7 +47253,7 @@ __export(render_exports, {
 });
 import { mkdirSync as mkdirSync32, readdirSync as readdirSync23, readFileSync as readFileSync36, statSync as statSync20, writeFileSync as writeFileSync26, rmSync as rmSync14 } from "fs";
 import { cpus as cpus4, freemem as freemem3, tmpdir as tmpdir4 } from "os";
-import { resolve as resolve32, dirname as dirname21, join as join62, basename as basename11 } from "path";
+import { resolve as resolve32, dirname as dirname22, join as join62, basename as basename11 } from "path";
 import { execFileSync as execFileSync6, spawn as spawn13 } from "child_process";
 function formatFpsParseError(input, reason) {
   switch (reason) {
@@ -47378,7 +47444,7 @@ async function renderDocker(projectDir, outputPath, options) {
     );
     process.exit(1);
   }
-  const outputDir = dirname21(outputPath);
+  const outputDir = dirname22(outputPath);
   const outputFilename = basename11(outputPath);
   const dockerArgs = buildDockerRunArgs({
     imageTag,
@@ -47798,7 +47864,7 @@ var init_render2 = __esm({
         const datePart = now.toISOString().slice(0, 10);
         const timePart = now.toTimeString().slice(0, 8).replace(/:/g, "-");
         const outputPath = args.output ? resolve32(args.output) : join62(rendersDir, `${project.name}_${datePart}_${timePart}${ext}`);
-        mkdirSync32(dirname21(outputPath), { recursive: true });
+        mkdirSync32(dirname22(outputPath), { recursive: true });
         const useDocker = args.docker ?? false;
         const useGpu = args.gpu ?? false;
         const browserGpuArg = args["browser-gpu"];
@@ -48214,7 +48280,7 @@ var init_lint3 = __esm({
 // src/utils/staticProjectServer.ts
 import { createServer } from "http";
 import { existsSync as existsSync54, readFileSync as readFileSync37 } from "fs";
-import { isAbsolute as isAbsolute8, relative as relative8, resolve as resolve33 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative9, resolve as resolve33 } from "path";
 async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Failed to bind local HTTP server") {
   const server = createServer((req, res) => {
     const url = req.url ?? "/";
@@ -48224,7 +48290,7 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
       return;
     }
     const filePath = resolve33(projectDir, decodeURIComponent(url).replace(/^\//, ""));
-    const rel = relative8(projectDir, filePath);
+    const rel = relative9(projectDir, filePath);
     if (rel.startsWith("..") || isAbsolute8(rel)) {
       res.writeHead(403);
       res.end();
@@ -48409,7 +48475,7 @@ __export(layout_exports, {
   examples: () => examples9
 });
 import { existsSync as existsSync55, readFileSync as readFileSync38 } from "fs";
-import { dirname as dirname22, join as join63 } from "path";
+import { dirname as dirname23, join as join63 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function getCompositionDuration2(page) {
   return page.evaluate(() => {
@@ -48461,7 +48527,7 @@ async function seekTo(page, time) {
     if (!fonts?.ready) return Promise.resolve();
     return Promise.race([
       fonts.ready.then(() => void 0),
-      new Promise((resolve43) => setTimeout(resolve43, 500))
+      new Promise((resolve45) => setTimeout(resolve45, 500))
     ]);
   }).catch(() => {
   });
@@ -48521,7 +48587,7 @@ async function runLayoutAudit(projectDir, opts) {
       if (!fonts?.ready) return Promise.resolve();
       return Promise.race([
         fonts.ready.then(() => void 0),
-        new Promise((resolve43) => setTimeout(resolve43, 750))
+        new Promise((resolve45) => setTimeout(resolve45, 750))
       ]);
     }).catch(() => {
     });
@@ -48726,7 +48792,7 @@ var init_layout2 = __esm({
     init_updateCheck();
     init_layoutAudit();
     __filename = fileURLToPath8(import.meta.url);
-    __dirname2 = dirname22(__filename);
+    __dirname2 = dirname23(__filename);
     SEEK_SETTLE_MS = 120;
     INSPECT_SCHEMA_VERSION = 1;
     examples9 = [
@@ -48864,7 +48930,7 @@ __export(compositions_exports, {
   parseSubComposition: () => parseSubComposition
 });
 import { existsSync as existsSync56, readFileSync as readFileSync40 } from "fs";
-import { resolve as resolve34, dirname as dirname23 } from "path";
+import { resolve as resolve34, dirname as dirname24 } from "path";
 function countRenderableDescendants(root) {
   return Array.from(root.querySelectorAll("*")).filter(
     (el) => !NON_RENDERED_TAGS.has(el.tagName.toLowerCase())
@@ -49003,7 +49069,7 @@ var init_compositions = __esm({
         const project = resolveProject(args.dir);
         const html = readFileSync40(project.indexPath, "utf-8");
         ensureDOMParser();
-        const compositions = parseCompositions(html, dirname23(project.indexPath));
+        const compositions = parseCompositions(html, dirname24(project.indexPath));
         if (compositions.length === 0) {
           console.log(`${c2.success("\u25C7")}  ${c2.accent(project.name)} \u2014 no compositions found`);
           return;
@@ -49841,12 +49907,12 @@ async function runPipeline(options, session, media, format, bgFormat) {
         const drains = [];
         if (!fgWroteFully) {
           drains.push(
-            new Promise((resolve43) => fg.proc.stdin.once("drain", () => resolve43()))
+            new Promise((resolve45) => fg.proc.stdin.once("drain", () => resolve45()))
           );
         }
         if (!bgWroteFully && bg) {
           drains.push(
-            new Promise((resolve43) => bg.proc.stdin.once("drain", () => resolve43()))
+            new Promise((resolve45) => bg.proc.stdin.once("drain", () => resolve45()))
           );
         }
         await Promise.all(drains);
@@ -49879,11 +49945,11 @@ ${decoder.getStderr().slice(-400)}`
   return processed;
 }
 function waitForExit(proc, label2, getStderr) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     proc.on("error", reject);
     proc.on("exit", (code, signal) => {
       if (code === 0 && !signal) {
-        resolve43();
+        resolve45();
         return;
       }
       const cause = signal ? `killed by ${signal}` : `exited with code ${code}`;
@@ -50384,7 +50450,7 @@ __export(synthesize_exports, {
 });
 import { execFileSync as execFileSync7 } from "child_process";
 import { existsSync as existsSync62, writeFileSync as writeFileSync28, mkdirSync as mkdirSync35, readdirSync as readdirSync25, unlinkSync as unlinkSync6 } from "fs";
-import { join as join69, dirname as dirname24, basename as basename12 } from "path";
+import { join as join69, dirname as dirname25, basename as basename12 } from "path";
 import { homedir as homedir11 } from "os";
 function findPython() {
   for (const name of ["python3", "python"]) {
@@ -50462,7 +50528,7 @@ async function synthesize(text, outputPath, options) {
     ensureVoices({ onProgress: options?.onProgress })
   ]);
   const scriptPath = ensureSynthScript();
-  mkdirSync35(dirname24(outputPath), { recursive: true });
+  mkdirSync35(dirname25(outputPath), { recursive: true });
   options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
   try {
     const stdout2 = execFileSync7(
@@ -50753,11 +50819,11 @@ __export(docs_exports, {
   examples: () => examples18
 });
 import { readFileSync as readFileSync42, existsSync as existsSync64 } from "fs";
-import { resolve as resolve39, dirname as dirname25, join as join70 } from "path";
+import { resolve as resolve39, dirname as dirname26, join as join70 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 function docsDir() {
   const thisFile = fileURLToPath9(import.meta.url);
-  const dir = dirname25(thisFile);
+  const dir = dirname26(thisFile);
   const devPath = resolve39(dir, "..", "docs");
   const builtPath = resolve39(dir, "docs");
   return existsSync64(devPath) ? devPath : builtPath;
@@ -51354,7 +51420,7 @@ __export(validate_exports, {
   shouldIgnoreRequestFailure: () => shouldIgnoreRequestFailure
 });
 import { existsSync as existsSync65, readFileSync as readFileSync43 } from "fs";
-import { join as join71, dirname as dirname26 } from "path";
+import { join as join71, dirname as dirname27 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 function shouldIgnoreRequestFailure(url, errorText) {
   if (errorText !== "net::ERR_ABORTED") return false;
@@ -51525,7 +51591,7 @@ var init_validate = __esm({
     init_colors();
     init_updateCheck();
     __filename2 = fileURLToPath10(import.meta.url);
-    __dirname3 = dirname26(__filename2);
+    __dirname3 = dirname27(__filename2);
     CONTRAST_SAMPLES = 5;
     SEEK_SETTLE_MS2 = 150;
     MEDIA_EXTENSIONS = /\.(aac|flac|m4a|mov|mp3|mp4|oga|ogg|wav|webm)$/i;
@@ -51631,7 +51697,7 @@ __export(snapshot_exports, {
 import { spawn as spawn15 } from "child_process";
 import { existsSync as existsSync66, mkdtempSync as mkdtempSync3, readFileSync as readFileSync44, mkdirSync as mkdirSync36, rmSync as rmSync15 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { resolve as resolve40, join as join72, relative as relative9, isAbsolute as isAbsolute9 } from "path";
+import { resolve as resolve40, join as join72, relative as relative10, isAbsolute as isAbsolute9 } from "path";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
   const tmp = mkdtempSync3(join72(tmpdir5(), "hf-snapshot-frame-"));
   const outPath = join72(tmp, "frame.png");
@@ -51816,7 +51882,7 @@ async function captureSnapshots(projectDir, opts) {
               const url = new URL(v2.src);
               const decodedPath = decodeURIComponent(url.pathname).replace(/^\//, "");
               const candidate = resolve40(projectDir, decodedPath);
-              const rel = relative9(projectDir, candidate);
+              const rel = relative10(projectDir, candidate);
               if (!rel.startsWith("..") && !isAbsolute9(rel) && existsSync66(candidate)) {
                 filePath = candidate;
               }
@@ -53408,7 +53474,7 @@ var require_p_retry = __commonJS({
       return error;
     };
     var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
-    var pRetry2 = (input, options) => new Promise((resolve43, reject) => {
+    var pRetry2 = (input, options) => new Promise((resolve45, reject) => {
       options = {
         onFailedAttempt: () => {
         },
@@ -53418,7 +53484,7 @@ var require_p_retry = __commonJS({
       const operation = retry.operation(options);
       operation.attempt(async (attemptNumber) => {
         try {
-          resolve43(await input(attemptNumber));
+          resolve45(await input(attemptNumber));
         } catch (error) {
           if (!(error instanceof Error)) {
             reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
@@ -53954,8 +54020,8 @@ var require_retry3 = __commonJS({
       }
       const delay = getNextRetryDelay(config);
       err.config.retryConfig.currentRetryAttempt += 1;
-      const backoff = config.retryBackoff ? config.retryBackoff(err, delay) : new Promise((resolve43) => {
-        setTimeout(resolve43, delay);
+      const backoff = config.retryBackoff ? config.retryBackoff(err, delay) : new Promise((resolve45) => {
+        setTimeout(resolve45, delay);
       });
       if (config.onRetryAttempt) {
         await config.onRetryAttempt(err);
@@ -54863,8 +54929,8 @@ var require_helpers = __commonJS({
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
       const req2 = (href.startsWith("https:") ? https2 : http4).request(url, opts);
-      const promise = new Promise((resolve43, reject) => {
-        req2.once("response", resolve43).once("error", reject).end();
+      const promise = new Promise((resolve45, reject) => {
+        req2.once("response", resolve45).once("error", reject).end();
       });
       req2.then = promise.then.bind(promise);
       return req2;
@@ -55041,7 +55107,7 @@ var require_parse_proxy_response = __commonJS({
     var debug_1 = __importDefault(require_src2());
     var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
-      return new Promise((resolve43, reject) => {
+      return new Promise((resolve45, reject) => {
         let buffersLength = 0;
         const buffers = [];
         function read() {
@@ -55107,7 +55173,7 @@ var require_parse_proxy_response = __commonJS({
           }
           debug("got proxy server response: %o %o", firstLine, headers);
           cleanup();
-          resolve43({
+          resolve45({
             connect: {
               statusCode,
               statusText,
@@ -55351,7 +55417,7 @@ var require_ponyfill_es2018 = __commonJS({
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value) {
-        return newPromise((resolve43) => resolve43(value));
+        return newPromise((resolve45) => resolve45(value));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -55521,8 +55587,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released reader");
       }
       function defaultReaderClosedPromiseInitialize(reader) {
-        reader._closedPromise = newPromise((resolve43, reject) => {
-          reader._closedPromise_resolve = resolve43;
+        reader._closedPromise = newPromise((resolve45, reject) => {
+          reader._closedPromise_resolve = resolve45;
           reader._closedPromise_reject = reject;
         });
       }
@@ -55696,8 +55762,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve43, reject) => {
-            resolvePromise = resolve43;
+          const promise = newPromise((resolve45, reject) => {
+            resolvePromise = resolve45;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -55802,8 +55868,8 @@ var require_ponyfill_es2018 = __commonJS({
           const reader = this._reader;
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve43, reject) => {
-            resolvePromise = resolve43;
+          const promise = newPromise((resolve45, reject) => {
+            resolvePromise = resolve45;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -56822,8 +56888,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve43, reject) => {
-            resolvePromise = resolve43;
+          const promise = newPromise((resolve45, reject) => {
+            resolvePromise = resolve45;
             rejectPromise = reject;
           });
           const readIntoRequest = {
@@ -57135,10 +57201,10 @@ var require_ponyfill_es2018 = __commonJS({
           wasAlreadyErroring = true;
           reason = void 0;
         }
-        const promise = newPromise((resolve43, reject) => {
+        const promise = newPromise((resolve45, reject) => {
           stream._pendingAbortRequest = {
             _promise: void 0,
-            _resolve: resolve43,
+            _resolve: resolve45,
             _reject: reject,
             _reason: reason,
             _wasAlreadyErroring: wasAlreadyErroring
@@ -57155,9 +57221,9 @@ var require_ponyfill_es2018 = __commonJS({
         if (state === "closed" || state === "errored") {
           return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
         }
-        const promise = newPromise((resolve43, reject) => {
+        const promise = newPromise((resolve45, reject) => {
           const closeRequest = {
-            _resolve: resolve43,
+            _resolve: resolve45,
             _reject: reject
           };
           stream._closeRequest = closeRequest;
@@ -57170,9 +57236,9 @@ var require_ponyfill_es2018 = __commonJS({
         return promise;
       }
       function WritableStreamAddWriteRequest(stream) {
-        const promise = newPromise((resolve43, reject) => {
+        const promise = newPromise((resolve45, reject) => {
           const writeRequest = {
-            _resolve: resolve43,
+            _resolve: resolve45,
             _reject: reject
           };
           stream._writeRequests.push(writeRequest);
@@ -57788,8 +57854,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released writer");
       }
       function defaultWriterClosedPromiseInitialize(writer) {
-        writer._closedPromise = newPromise((resolve43, reject) => {
-          writer._closedPromise_resolve = resolve43;
+        writer._closedPromise = newPromise((resolve45, reject) => {
+          writer._closedPromise_resolve = resolve45;
           writer._closedPromise_reject = reject;
           writer._closedPromiseState = "pending";
         });
@@ -57825,8 +57891,8 @@ var require_ponyfill_es2018 = __commonJS({
         writer._closedPromiseState = "resolved";
       }
       function defaultWriterReadyPromiseInitialize(writer) {
-        writer._readyPromise = newPromise((resolve43, reject) => {
-          writer._readyPromise_resolve = resolve43;
+        writer._readyPromise = newPromise((resolve45, reject) => {
+          writer._readyPromise_resolve = resolve45;
           writer._readyPromise_reject = reject;
         });
         writer._readyPromiseState = "pending";
@@ -57913,7 +57979,7 @@ var require_ponyfill_es2018 = __commonJS({
         source._disturbed = true;
         let shuttingDown = false;
         let currentWrite = promiseResolvedWith(void 0);
-        return newPromise((resolve43, reject) => {
+        return newPromise((resolve45, reject) => {
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
@@ -58058,7 +58124,7 @@ var require_ponyfill_es2018 = __commonJS({
             if (isError) {
               reject(error);
             } else {
-              resolve43(void 0);
+              resolve45(void 0);
             }
             return null;
           }
@@ -58339,8 +58405,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve43) => {
-          resolveCancelPromise = resolve43;
+        const cancelPromise = newPromise((resolve45) => {
+          resolveCancelPromise = resolve45;
         });
         function pullAlgorithm() {
           if (reading) {
@@ -58431,8 +58497,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve43) => {
-          resolveCancelPromise = resolve43;
+        const cancelPromise = newPromise((resolve45) => {
+          resolveCancelPromise = resolve45;
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
@@ -59212,8 +59278,8 @@ var require_ponyfill_es2018 = __commonJS({
           const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
           const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
           let startPromise_resolve;
-          const startPromise = newPromise((resolve43) => {
-            startPromise_resolve = resolve43;
+          const startPromise = newPromise((resolve45) => {
+            startPromise_resolve = resolve45;
           });
           InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
           SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -59306,8 +59372,8 @@ var require_ponyfill_es2018 = __commonJS({
         if (stream._backpressureChangePromise !== void 0) {
           stream._backpressureChangePromise_resolve();
         }
-        stream._backpressureChangePromise = newPromise((resolve43) => {
-          stream._backpressureChangePromise_resolve = resolve43;
+        stream._backpressureChangePromise = newPromise((resolve45) => {
+          stream._backpressureChangePromise_resolve = resolve45;
         });
         stream._backpressure = backpressure;
       }
@@ -59475,8 +59541,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve43, reject) => {
-          controller._finishPromise_resolve = resolve43;
+        controller._finishPromise = newPromise((resolve45, reject) => {
+          controller._finishPromise_resolve = resolve45;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -59502,8 +59568,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve43, reject) => {
-          controller._finishPromise_resolve = resolve43;
+        controller._finishPromise = newPromise((resolve45, reject) => {
+          controller._finishPromise_resolve = resolve45;
           controller._finishPromise_reject = reject;
         });
         const flushPromise = controller._flushAlgorithm();
@@ -59533,8 +59599,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const writable = stream._writable;
-        controller._finishPromise = newPromise((resolve43, reject) => {
-          controller._finishPromise_resolve = resolve43;
+        controller._finishPromise = newPromise((resolve45, reject) => {
+          controller._finishPromise_resolve = resolve45;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -61503,7 +61569,7 @@ import zlib from "zlib";
 import Stream2, { PassThrough as PassThrough2, pipeline as pump } from "stream";
 import { Buffer as Buffer3 } from "buffer";
 async function fetch3(url, options_) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     const request = new Request2(url, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol)) {
@@ -61512,7 +61578,7 @@ async function fetch3(url, options_) {
     if (parsedURL.protocol === "data:") {
       const data = dist_default3(request.url);
       const response2 = new Response2(data, { headers: { "Content-Type": data.typeFull } });
-      resolve43(response2);
+      resolve45(response2);
       return;
     }
     const send = (parsedURL.protocol === "https:" ? https : http3).request;
@@ -61634,7 +61700,7 @@ async function fetch3(url, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve43(fetch3(new Request2(locationURL, requestOptions)));
+            resolve45(fetch3(new Request2(locationURL, requestOptions)));
             finalize();
             return;
           }
@@ -61667,7 +61733,7 @@ async function fetch3(url, options_) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
         response = new Response2(body, responseOptions);
-        resolve43(response);
+        resolve45(response);
         return;
       }
       const zlibOptions = {
@@ -61681,7 +61747,7 @@ async function fetch3(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve43(response);
+        resolve45(response);
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
@@ -61705,12 +61771,12 @@ async function fetch3(url, options_) {
             });
           }
           response = new Response2(body, responseOptions);
-          resolve43(response);
+          resolve45(response);
         });
         raw.once("end", () => {
           if (!response) {
             response = new Response2(body, responseOptions);
-            resolve43(response);
+            resolve45(response);
           }
         });
         return;
@@ -61722,11 +61788,11 @@ async function fetch3(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve43(response);
+        resolve45(response);
         return;
       }
       response = new Response2(body, responseOptions);
-      resolve43(response);
+      resolve45(response);
     });
     writeToStream(request_, request).catch(reject);
   });
@@ -67808,7 +67874,7 @@ var require_jwtaccess = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve43, reject) => {
+        return new Promise((resolve45, reject) => {
           if (!inputStream) {
             reject(new Error("Must pass in a stream containing the service account auth settings."));
           }
@@ -67817,7 +67883,7 @@ var require_jwtaccess = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve43();
+              resolve45();
             } catch (err) {
               reject(err);
             }
@@ -68056,7 +68122,7 @@ var require_jwtclient = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve43, reject) => {
+        return new Promise((resolve45, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the service account auth settings.");
           }
@@ -68065,7 +68131,7 @@ var require_jwtclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve43();
+              resolve45();
             } catch (e3) {
               reject(e3);
             }
@@ -68198,7 +68264,7 @@ var require_refreshclient = __commonJS({
         }
       }
       async fromStreamAsync(inputStream) {
-        return new Promise((resolve43, reject) => {
+        return new Promise((resolve45, reject) => {
           if (!inputStream) {
             return reject(new Error("Must pass in a stream containing the user refresh token."));
           }
@@ -68207,7 +68273,7 @@ var require_refreshclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              return resolve43();
+              return resolve45();
             } catch (err) {
               return reject(err);
             }
@@ -70040,7 +70106,7 @@ var require_pluggable_auth_handler = __commonJS({
        * @return A promise that resolves with the executable response.
        */
       retrieveResponseFromExecutable(envMap) {
-        return new Promise((resolve43, reject) => {
+        return new Promise((resolve45, reject) => {
           const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {
             env: { ...process.env, ...Object.fromEntries(envMap) }
           });
@@ -70062,7 +70128,7 @@ var require_pluggable_auth_handler = __commonJS({
               try {
                 const responseJson = JSON.parse(output);
                 const response = new executable_response_1.ExecutableResponse(responseJson);
-                return resolve43(response);
+                return resolve45(response);
               } catch (error) {
                 if (error instanceof executable_response_1.ExecutableResponseError) {
                   return reject(error);
@@ -70965,7 +71031,7 @@ var require_googleauth = __commonJS({
         }
       }
       fromStreamAsync(inputStream, options) {
-        return new Promise((resolve43, reject) => {
+        return new Promise((resolve45, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the Google auth settings.");
           }
@@ -70975,7 +71041,7 @@ var require_googleauth = __commonJS({
               try {
                 const data = JSON.parse(chunks.join(""));
                 const r2 = this._cacheClientFromJSON(data, options);
-                return resolve43(r2);
+                return resolve45(r2);
               } catch (err) {
                 if (!this.keyFilename)
                   throw err;
@@ -70985,7 +71051,7 @@ var require_googleauth = __commonJS({
                 });
                 this.cachedCredential = client;
                 this.setGapicJWTValues(client);
-                return resolve43(client);
+                return resolve45(client);
               }
             } catch (err) {
               return reject(err);
@@ -71021,17 +71087,17 @@ var require_googleauth = __commonJS({
        * Run the Google Cloud SDK command that prints the default project ID
        */
       async getDefaultServiceProjectId() {
-        return new Promise((resolve43) => {
+        return new Promise((resolve45) => {
           (0, child_process_1.exec)("gcloud config config-helper --format json", (err, stdout2) => {
             if (!err && stdout2) {
               try {
                 const projectId = JSON.parse(stdout2).configuration.properties.core.project;
-                resolve43(projectId);
+                resolve45(projectId);
                 return;
               } catch (e3) {
               }
             }
-            resolve43(null);
+            resolve45(null);
           });
         });
       }
@@ -78874,14 +78940,14 @@ function __asyncValues(o) {
   }, i2);
   function verb(n) {
     i2[n] = o[n] && function(v2) {
-      return new Promise(function(resolve43, reject) {
-        v2 = o[n](v2), settle(resolve43, reject, v2.done, v2.value);
+      return new Promise(function(resolve45, reject) {
+        v2 = o[n](v2), settle(resolve45, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve43, reject, d2, v2) {
+  function settle(resolve45, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve43({ value: v3, done: d2 });
+      resolve45({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -89371,8 +89437,8 @@ var init_node4 = __esm({
         const url = `${websocketBaseUrl}/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.BidiGenerateMusic?key=${apiKey}`;
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve43) => {
-          onopenResolve = resolve43;
+        const onopenPromise = new Promise((resolve45) => {
+          onopenResolve = resolve45;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -89578,8 +89644,8 @@ var init_node4 = __esm({
         }
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve43) => {
-          onopenResolve = resolve43;
+        const onopenPromise = new Promise((resolve45) => {
+          onopenResolve = resolve45;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -91927,7 +91993,7 @@ var init_node4 = __esm({
         return void 0;
       }
     };
-    sleep$1 = (ms) => new Promise((resolve43) => setTimeout(resolve43, ms));
+    sleep$1 = (ms) => new Promise((resolve45) => setTimeout(resolve45, ms));
     FallbackEncoder = ({ headers, body }) => {
       return {
         bodyHeaders: {
@@ -92436,8 +92502,8 @@ ${underline2}`);
     };
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse = defaultParseResponse) {
-        super((resolve43) => {
-          resolve43(null);
+        super((resolve45) => {
+          resolve45(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse;
@@ -94895,11 +94961,11 @@ var init_capture2 = __esm({
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           try {
-            const { mkdirSync: mkdirSync42, writeFileSync: writeFileSync35 } = await import("fs");
-            mkdirSync42(outputDir, { recursive: true });
+            const { mkdirSync: mkdirSync43, writeFileSync: writeFileSync36 } = await import("fs");
+            mkdirSync43(outputDir, { recursive: true });
             const isTimeout = /timeout|timed out/i.test(errMsg);
             const reason = isTimeout ? "Page navigation timed out \u2014 the site may be blocking headless browsers or requires authentication." : `Capture failed: ${errMsg}`;
-            writeFileSync35(
+            writeFileSync36(
               `${outputDir}/BLOCKED.md`,
               `# Capture Failed
 
@@ -94931,6 +94997,1136 @@ URL: ${url}
   }
 });
 
+// src/commands/lambda/state.ts
+var state_exports = {};
+__export(state_exports, {
+  DEFAULT_STACK_NAME: () => DEFAULT_STACK_NAME,
+  deleteStackOutputs: () => deleteStackOutputs,
+  listStackNames: () => listStackNames,
+  readStackOutputs: () => readStackOutputs,
+  requireStack: () => requireStack,
+  stateFilePath: () => stateFilePath,
+  writeStackOutputs: () => writeStackOutputs
+});
+import { existsSync as existsSync69, mkdirSync as mkdirSync41, readdirSync as readdirSync28, readFileSync as readFileSync48, rmSync as rmSync16, writeFileSync as writeFileSync35 } from "fs";
+import { dirname as dirname28, join as join80 } from "path";
+function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  return join80(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
+}
+function writeStackOutputs(outputs, cwd = process.cwd()) {
+  const path2 = stateFilePath(outputs.stackName, cwd);
+  mkdirSync41(dirname28(path2), { recursive: true });
+  writeFileSync35(path2, JSON.stringify(outputs, null, 2) + "\n");
+  return path2;
+}
+function readStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  const path2 = stateFilePath(stackName, cwd);
+  if (!existsSync69(path2)) return null;
+  try {
+    return JSON.parse(readFileSync48(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function deleteStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
+  const path2 = stateFilePath(stackName, cwd);
+  if (existsSync69(path2)) rmSync16(path2);
+}
+function listStackNames(cwd = process.cwd()) {
+  const dir = join80(cwd, STATE_DIR_NAME);
+  if (!existsSync69(dir)) return [];
+  return readdirSync28(dir).filter((f3) => f3.startsWith(STATE_FILE_PREFIX) && f3.endsWith(".json")).map((f3) => f3.slice(STATE_FILE_PREFIX.length, -".json".length));
+}
+function requireStack(stackName, cwd = process.cwd()) {
+  const stack = readStackOutputs(stackName, cwd);
+  if (!stack) {
+    const known = listStackNames(cwd);
+    let hint = `Run \`hyperframes lambda deploy${stackName === DEFAULT_STACK_NAME ? "" : ` --stack-name=${stackName}`}\` first.`;
+    if (known.length) {
+      hint += ` Known stacks here: ${known.join(", ")}.`;
+    }
+    console.error(
+      `[hyperframes lambda] no stack state for "${stackName}" at ${stateFilePath(stackName, cwd)}. ${hint}`
+    );
+    process.exit(1);
+  }
+  return stack;
+}
+var STATE_DIR_NAME, STATE_FILE_PREFIX, DEFAULT_STACK_NAME;
+var init_state = __esm({
+  "src/commands/lambda/state.ts"() {
+    "use strict";
+    STATE_DIR_NAME = ".hyperframes";
+    STATE_FILE_PREFIX = "lambda-stack-";
+    DEFAULT_STACK_NAME = "hyperframes-default";
+  }
+});
+
+// src/commands/lambda/sam.ts
+import { execFileSync as execFileSync9, spawnSync as spawnSync4 } from "child_process";
+import { existsSync as existsSync70 } from "fs";
+import { join as join81 } from "path";
+function assertSamAvailable() {
+  try {
+    execFileSync9("sam", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "`sam` CLI not found on PATH. Install AWS SAM CLI from https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html and retry."
+    );
+  }
+}
+function assertAwsCliAvailable() {
+  try {
+    execFileSync9("aws", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "`aws` CLI not found on PATH. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html and configure credentials before retrying."
+    );
+  }
+}
+function locateSamTemplate(repoRoot2) {
+  const candidate = join81(repoRoot2, "examples", "aws-lambda", "template.yaml");
+  if (!existsSync70(candidate)) {
+    throw new Error(
+      `[lambda] SAM template not found at ${candidate}. If you're running from an installed package, point --sam-template at your local copy of examples/aws-lambda/template.yaml.`
+    );
+  }
+  return candidate;
+}
+function samDeploy(opts) {
+  assertSamAvailable();
+  const paramOverrides = [
+    `ChromeSource=${opts.chromeSource ?? "sparticuz"}`,
+    `ReservedConcurrency=${opts.reservedConcurrency ?? -1}`
+  ];
+  if (opts.lambdaMemoryMb !== void 0) {
+    paramOverrides.push(`LambdaMemoryMb=${opts.lambdaMemoryMb}`);
+  }
+  const args = [
+    "deploy",
+    "--stack-name",
+    opts.stackName,
+    "--region",
+    opts.region,
+    "--resolve-s3",
+    "--capabilities",
+    "CAPABILITY_IAM",
+    "--no-confirm-changeset",
+    "--no-fail-on-empty-changeset",
+    "--parameter-overrides",
+    ...paramOverrides
+  ];
+  if (opts.awsProfile) {
+    args.push("--profile", opts.awsProfile);
+  }
+  const samDir = join81(opts.repoRoot, "examples", "aws-lambda");
+  const result = spawnSync4("sam", args, { cwd: samDir, stdio: opts.stdio ?? "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`[lambda] sam deploy exited with code ${result.status ?? "unknown"}`);
+  }
+}
+function samDelete(opts) {
+  assertSamAvailable();
+  const args = ["delete", "--stack-name", opts.stackName, "--region", opts.region, "--no-prompts"];
+  if (opts.awsProfile) {
+    args.push("--profile", opts.awsProfile);
+  }
+  const samDir = join81(opts.repoRoot, "examples", "aws-lambda");
+  const result = spawnSync4("sam", args, { cwd: samDir, stdio: opts.stdio ?? "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`[lambda] sam delete exited with code ${result.status ?? "unknown"}`);
+  }
+}
+function fetchStackOutputs(opts) {
+  assertAwsCliAvailable();
+  const args = [
+    "cloudformation",
+    "describe-stacks",
+    "--stack-name",
+    opts.stackName,
+    "--region",
+    opts.region,
+    "--query",
+    "Stacks[0].Outputs",
+    "--output",
+    "json"
+  ];
+  if (opts.awsProfile) {
+    args.unshift("--profile", opts.awsProfile);
+  }
+  const out = execFileSync9("aws", args, { encoding: "utf-8" });
+  const parsed = JSON.parse(out);
+  const byKey = new Map(parsed.map((o) => [o.OutputKey, o.OutputValue]));
+  const bucketName = byKey.get("RenderBucketName");
+  const functionName = byKey.get("RenderFunctionArn");
+  const stateMachineArn = byKey.get("RenderStateMachineArn");
+  if (!bucketName || !functionName || !stateMachineArn) {
+    throw new Error(
+      `[lambda] stack ${opts.stackName} is missing one of RenderBucketName/RenderFunctionArn/RenderStateMachineArn. Got keys: ${[...byKey.keys()].join(", ")}`
+    );
+  }
+  return {
+    bucketName,
+    // RenderFunctionArn is the full ARN; the Lambda function name is the
+    // last colon-segment, which downstream `getRenderProgress` calls use
+    // for cost math + CloudWatch lookups.
+    functionName: functionName.split(":").pop() ?? functionName,
+    stateMachineArn
+  };
+}
+var init_sam = __esm({
+  "src/commands/lambda/sam.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/lambda/repoRoot.ts
+import { existsSync as existsSync71 } from "fs";
+import { dirname as dirname29, resolve as resolve43 } from "path";
+import { fileURLToPath as fileURLToPath11 } from "url";
+function repoRoot() {
+  const override = process.env.HYPERFRAMES_REPO_ROOT;
+  if (override && existsSync71(resolve43(override, "packages", "aws-lambda", "package.json"))) {
+    return override;
+  }
+  let dir = dirname29(fileURLToPath11(import.meta.url));
+  for (let depth = 0; depth < 12; depth++) {
+    if (existsSync71(resolve43(dir, "packages", "aws-lambda", "package.json"))) {
+      return dir;
+    }
+    const parent = dirname29(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    "[hyperframes lambda] could not find the repo root (no packages/aws-lambda/ above this CLI's source). Run `hyperframes lambda` from within a hyperframes checkout, or set HYPERFRAMES_REPO_ROOT explicitly."
+  );
+}
+var init_repoRoot = __esm({
+  "src/commands/lambda/repoRoot.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/lambda/deploy.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  runDeploy: () => runDeploy
+});
+import { spawnSync as spawnSync5 } from "child_process";
+import { existsSync as existsSync72 } from "fs";
+import { join as join82, resolve as resolve44 } from "path";
+async function runDeploy(args = {}) {
+  const resolved = {
+    stackName: args.stackName ?? DEFAULT_STACK_NAME,
+    region: args.region ?? process.env.AWS_REGION ?? DEFAULT_REGION,
+    awsProfile: args.awsProfile ?? process.env.AWS_PROFILE,
+    reservedConcurrency: args.reservedConcurrency ?? DEFAULT_CONCURRENCY,
+    chromeSource: args.chromeSource ?? "sparticuz",
+    lambdaMemoryMb: args.lambdaMemoryMb ?? DEFAULT_MEMORY_MB,
+    skipBuild: args.skipBuild ?? false
+  };
+  const root = repoRoot();
+  locateSamTemplate(root);
+  if (!resolved.skipBuild) {
+    console.log(c2.dim("\u2192 Building handler ZIP"));
+    buildHandlerZip(root);
+  } else {
+    const zip = join82(root, "packages", "aws-lambda", "dist", "handler.zip");
+    if (!existsSync72(zip)) {
+      throw new Error(
+        `--skip-build set but ${zip} does not exist. Run \`bun run --cwd packages/aws-lambda build:zip\` first or drop --skip-build.`
+      );
+    }
+  }
+  console.log(c2.dim(`\u2192 sam deploy (stack=${resolved.stackName} region=${resolved.region})`));
+  samDeploy({
+    repoRoot: root,
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile,
+    reservedConcurrency: resolved.reservedConcurrency,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    chromeSource: resolved.chromeSource
+  });
+  console.log(c2.dim("\u2192 Reading stack outputs"));
+  const outputs = fetchStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile
+  });
+  const statePath = writeStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    bucketName: outputs.bucketName,
+    stateMachineArn: outputs.stateMachineArn,
+    functionName: outputs.functionName,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log();
+  console.log(c2.success("Stack deployed."));
+  console.log(`  ${c2.dim("Bucket:")}         ${outputs.bucketName}`);
+  console.log(`  ${c2.dim("State machine:")}  ${outputs.stateMachineArn}`);
+  console.log(`  ${c2.dim("Function:")}       ${outputs.functionName}`);
+  console.log(`  ${c2.dim("State file:")}     ${resolve44(statePath)}`);
+  console.log();
+  console.log(c2.dim(`Render with: hyperframes lambda render <project-dir>`));
+}
+function buildHandlerZip(root) {
+  const result = spawnSync5(
+    "bun",
+    ["run", "--cwd", join82(root, "packages", "aws-lambda"), "build:zip"],
+    { stdio: "inherit" }
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      `[lambda deploy] handler ZIP build exited with code ${result.status ?? "unknown"}`
+    );
+  }
+}
+var DEFAULT_REGION, DEFAULT_MEMORY_MB, DEFAULT_CONCURRENCY;
+var init_deploy = __esm({
+  "src/commands/lambda/deploy.ts"() {
+    "use strict";
+    init_colors();
+    init_sam();
+    init_repoRoot();
+    init_state();
+    DEFAULT_REGION = "us-east-1";
+    DEFAULT_MEMORY_MB = 10240;
+    DEFAULT_CONCURRENCY = 8;
+  }
+});
+
+// src/commands/lambda/sites.ts
+var sites_exports = {};
+__export(sites_exports, {
+  runSitesCreate: () => runSitesCreate
+});
+import { resolve as resolvePath } from "path";
+async function loadSDK() {
+  return import("@hyperframes/aws-lambda/sdk");
+}
+async function runSitesCreate(args) {
+  const stack = requireStack(args.stackName);
+  const projectDir = resolvePath(args.projectDir);
+  const { deploySite } = await loadSDK();
+  const handle = await deploySite({
+    projectDir,
+    bucketName: stack.bucketName,
+    region: stack.region,
+    siteId: args.siteId
+  });
+  if (args.json) {
+    console.log(JSON.stringify(handle, null, 2));
+    return;
+  }
+  console.log(
+    c2.success(handle.uploaded ? "Site uploaded." : "Site already up to date (skipped upload).")
+  );
+  console.log(`  ${c2.dim("Site ID:")}       ${handle.siteId}`);
+  console.log(`  ${c2.dim("S3 URI:")}        ${handle.projectS3Uri}`);
+  console.log(`  ${c2.dim("Bytes:")}         ${handle.bytes}`);
+  console.log(`  ${c2.dim("Uploaded at:")}   ${handle.uploadedAt}`);
+  console.log();
+  console.log(
+    c2.dim(
+      `Render with: hyperframes lambda render ${args.projectDir} --site-id=${handle.siteId}` + (args.stackName === DEFAULT_STACK_NAME ? "" : ` --stack-name=${args.stackName}`)
+    )
+  );
+}
+var init_sites = __esm({
+  "src/commands/lambda/sites.ts"() {
+    "use strict";
+    init_colors();
+    init_state();
+  }
+});
+
+// src/commands/lambda/render.ts
+var render_exports2 = {};
+__export(render_exports2, {
+  runRender: () => runRender
+});
+import { resolve as resolvePath2 } from "path";
+async function loadSDK2() {
+  return import("@hyperframes/aws-lambda/sdk");
+}
+async function runRender(args) {
+  const stack = requireStack(args.stackName);
+  const projectDir = resolvePath2(args.projectDir);
+  const config = {
+    fps: args.fps,
+    width: args.width,
+    height: args.height,
+    format: args.format,
+    codec: args.codec,
+    quality: args.quality,
+    chunkSize: args.chunkSize,
+    maxParallelChunks: args.maxParallelChunks,
+    runtimeCap: "lambda"
+  };
+  const siteHandle = args.siteId ? {
+    siteId: args.siteId,
+    bucketName: stack.bucketName,
+    projectS3Uri: `s3://${stack.bucketName}/sites/${args.siteId}/project.tar.gz`,
+    bytes: 0,
+    uploadedAt: "",
+    uploaded: false
+  } : void 0;
+  const { renderToLambda } = await loadSDK2();
+  const handle = await renderToLambda({
+    projectDir: siteHandle ? void 0 : projectDir,
+    siteHandle,
+    bucketName: stack.bucketName,
+    stateMachineArn: stack.stateMachineArn,
+    region: stack.region,
+    config,
+    executionName: args.executionName,
+    outputKey: args.outputKey
+  });
+  if (args.json) {
+    if (args.wait) {
+      await waitForCompletion(handle.executionArn, stack, args.waitIntervalMs, args.json);
+    } else {
+      console.log(JSON.stringify(handle, null, 2));
+    }
+    return;
+  }
+  console.log(c2.success("Render started."));
+  console.log(`  ${c2.dim("Render ID:")}     ${handle.renderId}`);
+  console.log(`  ${c2.dim("Execution ARN:")} ${handle.executionArn}`);
+  console.log(`  ${c2.dim("Output S3 URI:")} ${handle.outputS3Uri}`);
+  console.log(`  ${c2.dim("Project S3:")}    ${handle.projectS3Uri}`);
+  console.log(`  ${c2.dim("Stack state:")}   ${stateFilePath(args.stackName)}`);
+  console.log();
+  if (args.wait) {
+    await waitForCompletion(handle.executionArn, stack, args.waitIntervalMs, args.json);
+    return;
+  }
+  console.log(c2.dim(`Poll with: hyperframes lambda progress ${handle.renderId}`));
+}
+async function waitForCompletion(executionArn, stack, intervalMs, json) {
+  const { getRenderProgress } = await loadSDK2();
+  let lastRendered = -1;
+  while (true) {
+    const progress = await getRenderProgress({
+      executionArn,
+      region: stack.region,
+      defaultMemorySizeMb: stack.lambdaMemoryMb
+    });
+    if (!json && progress.framesRendered !== lastRendered) {
+      lastRendered = progress.framesRendered;
+      const total = progress.totalFrames ?? "?";
+      const pct = Math.round(progress.overallProgress * 100);
+      console.log(
+        `  ${c2.dim(`[${progress.status}]`)} ${pct}% \u2022 ${progress.framesRendered}/${total} frames \u2022 ${progress.costs.displayCost}`
+      );
+    }
+    if (progress.status !== "RUNNING") {
+      if (json) {
+        console.log(JSON.stringify(progress, null, 2));
+      } else if (progress.status === "SUCCEEDED" && progress.outputFile) {
+        console.log();
+        console.log(c2.success("Render complete."));
+        console.log(`  ${c2.dim("Output:")}        ${progress.outputFile.s3Uri}`);
+        console.log(`  ${c2.dim("Size:")}          ${progress.outputFile.bytes ?? "?"} bytes`);
+        console.log(`  ${c2.dim("Total cost:")}    ${progress.costs.displayCost}`);
+      } else {
+        console.log();
+        console.log(c2.error(`Render ended with status ${progress.status}.`));
+        for (const err of progress.errors) {
+          console.log(`  ${c2.dim(err.state)}: ${err.error} \u2014 ${err.cause}`);
+        }
+        process.exitCode = 1;
+      }
+      return;
+    }
+    await sleep2(intervalMs);
+  }
+}
+function sleep2(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+var init_render3 = __esm({
+  "src/commands/lambda/render.ts"() {
+    "use strict";
+    init_colors();
+    init_state();
+  }
+});
+
+// src/commands/lambda/progress.ts
+var progress_exports = {};
+__export(progress_exports, {
+  runProgress: () => runProgress
+});
+async function runProgress(args) {
+  const stack = requireStack(args.stackName);
+  const executionArn = args.target.startsWith("arn:") ? args.target : executionArnFromName(stack.stateMachineArn, args.target);
+  const { getRenderProgress } = await import("@hyperframes/aws-lambda/sdk");
+  const progress = await getRenderProgress({
+    executionArn,
+    region: stack.region,
+    defaultMemorySizeMb: stack.lambdaMemoryMb
+  });
+  if (args.json) {
+    console.log(JSON.stringify(progress, null, 2));
+    return;
+  }
+  const pct = Math.round(progress.overallProgress * 100);
+  console.log(`${c2.dim("Status:")}    ${statusColor(progress.status)}`);
+  console.log(`${c2.dim("Progress:")}  ${pct}%`);
+  console.log(
+    `${c2.dim("Frames:")}    ${progress.framesRendered}${progress.totalFrames === null ? "" : ` / ${progress.totalFrames}`}`
+  );
+  console.log(`${c2.dim("Lambdas:")}   ${progress.lambdasInvoked}`);
+  console.log(
+    `${c2.dim("Cost:")}      ${progress.costs.displayCost} (Lambda $${progress.costs.breakdown.lambdaUsd.toFixed(4)} + SFN $${progress.costs.breakdown.stepFunctionsUsd.toFixed(4)})`
+  );
+  if (progress.outputFile) {
+    console.log(`${c2.dim("Output:")}    ${progress.outputFile.s3Uri}`);
+  }
+  if (progress.errors.length > 0) {
+    console.log();
+    console.log(c2.error("Errors:"));
+    for (const err of progress.errors) {
+      console.log(`  ${c2.dim(err.state)}: ${err.error} \u2014 ${err.cause}`);
+    }
+  }
+  if (progress.fatalErrorEncountered) {
+    process.exitCode = 1;
+  }
+}
+function executionArnFromName(stateMachineArn, name) {
+  return stateMachineArn.replace(":stateMachine:", ":execution:") + `:${name}`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "SUCCEEDED":
+      return c2.success(status);
+    case "FAILED":
+    case "TIMED_OUT":
+    case "ABORTED":
+      return c2.error(status);
+    default:
+      return status;
+  }
+}
+var init_progress2 = __esm({
+  "src/commands/lambda/progress.ts"() {
+    "use strict";
+    init_colors();
+    init_state();
+  }
+});
+
+// src/commands/lambda/destroy.ts
+var destroy_exports = {};
+__export(destroy_exports, {
+  runDestroy: () => runDestroy
+});
+async function runDestroy(args) {
+  const stack = requireStack(args.stackName);
+  console.log(c2.dim(`\u2192 sam delete (stack=${stack.stackName} region=${stack.region})`));
+  samDelete({
+    repoRoot: repoRoot(),
+    stackName: stack.stackName,
+    region: stack.region,
+    awsProfile: args.awsProfile ?? process.env.AWS_PROFILE
+  });
+  deleteStackOutputs(args.stackName);
+  console.log();
+  console.log(c2.success("Stack torn down."));
+  console.log(
+    c2.dim(
+      `Note: the render bucket "${stack.bucketName}" was deployed with Retain \u2014 empty + delete it via the AWS console or CLI if you want to fully reclaim storage.`
+    )
+  );
+}
+var init_destroy = __esm({
+  "src/commands/lambda/destroy.ts"() {
+    "use strict";
+    init_colors();
+    init_state();
+    init_sam();
+    init_repoRoot();
+  }
+});
+
+// src/commands/lambda/policies.ts
+var policies_exports = {};
+__export(policies_exports, {
+  REQUIRED_ACTIONS: () => REQUIRED_ACTIONS,
+  allRequiredActions: () => allRequiredActions,
+  buildPolicyDocument: () => buildPolicyDocument,
+  buildRoleTrustPolicy: () => buildRoleTrustPolicy,
+  runPolicies: () => runPolicies,
+  validatePolicy: () => validatePolicy
+});
+import { readFileSync as readFileSync49 } from "fs";
+function allRequiredActions() {
+  const set = /* @__PURE__ */ new Set();
+  for (const group of Object.values(REQUIRED_ACTIONS)) {
+    for (const action of group) set.add(action);
+  }
+  return [...set].sort();
+}
+function buildPolicyDocument() {
+  return {
+    Version: "2012-10-17",
+    Statement: [
+      {
+        Effect: "Allow",
+        Action: allRequiredActions(),
+        Resource: "*"
+      }
+    ]
+  };
+}
+function buildRoleTrustPolicy() {
+  return {
+    Version: "2012-10-17",
+    Statement: [
+      {
+        Effect: "Allow",
+        Principal: { Service: "cloudformation.amazonaws.com" },
+        Action: "sts:AssumeRole"
+      }
+    ]
+  };
+}
+async function runPolicies(args) {
+  switch (args.verb) {
+    case "user": {
+      const doc = buildPolicyDocument();
+      console.log(JSON.stringify(doc, null, 2));
+      if (!args.json) {
+        console.error(
+          c2.dim(
+            "\n# Attach the above as an inline policy to the IAM user/role that runs `hyperframes lambda *`.\n# Scope `Resource` to your stack's ARNs after the first successful deploy."
+          )
+        );
+      }
+      return;
+    }
+    case "role": {
+      const trust = buildRoleTrustPolicy();
+      const inline = buildPolicyDocument();
+      const wrapped = {
+        TrustRelationship: trust,
+        InlinePolicy: inline
+      };
+      console.log(JSON.stringify(wrapped, null, 2));
+      return;
+    }
+    case "validate": {
+      if (!args.inputPath) {
+        const msg = "[lambda policies validate] usage: hyperframes lambda policies validate <policy.json>";
+        if (args.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+          process.exitCode = 1;
+          return;
+        }
+        throw new Error(msg);
+      }
+      let result;
+      try {
+        result = validatePolicy(args.inputPath);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (args.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+          process.exitCode = 1;
+          return;
+        }
+        console.error(c2.error(`Failed to validate ${args.inputPath}: ${msg}`));
+        process.exitCode = 1;
+        return;
+      }
+      if (args.json) {
+        console.log(JSON.stringify({ ok: result.missing.length === 0, ...result }, null, 2));
+        if (result.missing.length > 0) process.exitCode = 1;
+        return;
+      }
+      for (const warning of result.warnings) {
+        console.warn(c2.dim(`Warning: ${warning}`));
+      }
+      if (result.missing.length === 0) {
+        console.log(c2.success(`Policy covers all ${result.required.length} required actions.`));
+        return;
+      }
+      console.log(c2.error(`Policy is missing ${result.missing.length} required action(s):`));
+      for (const action of result.missing) {
+        console.log(`  \u2022 ${action}`);
+      }
+      console.log();
+      console.log(
+        c2.dim("Run `hyperframes lambda policies user` to print the full required policy.")
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+}
+function validatePolicy(policyPath) {
+  const raw = readFileSync49(policyPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  const statements = Array.isArray(parsed.Statement) ? parsed.Statement : parsed.Statement ? [
+    parsed.Statement
+  ] : [];
+  const grantedPatterns = [];
+  const warnings = [];
+  for (const stmt of statements) {
+    if (stmt.Effect !== "Allow") continue;
+    if (stmt.NotAction !== void 0) {
+      warnings.push(
+        "Allow statement uses NotAction; the validator only checks positive Action grants, so this statement is being ignored. Convert to an explicit Action list to validate it."
+      );
+      continue;
+    }
+    if (stmt.NotResource !== void 0) {
+      warnings.push(
+        "Allow statement uses NotResource; resource-scoping is not modelled by this validator. Treating the statement as fully granted on its Action set."
+      );
+    }
+    const actions = stmt.Action;
+    if (typeof actions === "string") {
+      grantedPatterns.push(actions);
+    } else if (Array.isArray(actions)) {
+      for (const a of actions) if (typeof a === "string") grantedPatterns.push(a);
+    }
+  }
+  for (const pattern of grantedPatterns) {
+    if (hasMidStringWildcard(pattern)) {
+      warnings.push(
+        `Action pattern ${JSON.stringify(pattern)} contains a mid-string wildcard the validator can't expand; only end-anchored wildcards (\`*\`, \`service:*\`, \`prefix*\`) are honoured.`
+      );
+    }
+  }
+  const required = allRequiredActions();
+  const granted = [];
+  const missing = [];
+  for (const action of required) {
+    if (grantedPatterns.some((pattern) => actionMatches(pattern, action))) {
+      granted.push(action);
+    } else {
+      missing.push(action);
+    }
+  }
+  return { required, granted, missing, warnings };
+}
+function hasMidStringWildcard(pattern) {
+  if (pattern === "*") return false;
+  if (pattern.endsWith(":*")) return false;
+  if (pattern.endsWith("*") && !pattern.slice(0, -1).includes("*")) return false;
+  return pattern.includes("*") || pattern.includes("?");
+}
+function actionMatches(pattern, action) {
+  if (pattern === "*") return true;
+  if (pattern === action) return true;
+  if (pattern.endsWith(":*")) {
+    const service = pattern.slice(0, -2);
+    return action.startsWith(`${service}:`);
+  }
+  if (pattern.endsWith("*")) {
+    return action.startsWith(pattern.slice(0, -1));
+  }
+  return false;
+}
+var REQUIRED_ACTIONS;
+var init_policies = __esm({
+  "src/commands/lambda/policies.ts"() {
+    "use strict";
+    init_colors();
+    REQUIRED_ACTIONS = {
+      cloudformation: [
+        "cloudformation:CreateChangeSet",
+        "cloudformation:CreateStack",
+        "cloudformation:DeleteChangeSet",
+        "cloudformation:DeleteStack",
+        "cloudformation:DescribeChangeSet",
+        "cloudformation:DescribeStackEvents",
+        "cloudformation:DescribeStackResource",
+        "cloudformation:DescribeStackResources",
+        "cloudformation:DescribeStacks",
+        "cloudformation:ExecuteChangeSet",
+        "cloudformation:GetTemplate",
+        "cloudformation:GetTemplateSummary",
+        "cloudformation:ListStacks",
+        "cloudformation:UpdateStack",
+        "cloudformation:ValidateTemplate"
+      ],
+      cloudwatchAlarms: [
+        "cloudwatch:DeleteAlarms",
+        "cloudwatch:DescribeAlarms",
+        "cloudwatch:PutMetricAlarm"
+      ],
+      iam: [
+        "iam:AttachRolePolicy",
+        "iam:CreateRole",
+        "iam:DeleteRole",
+        "iam:DeleteRolePolicy",
+        "iam:DetachRolePolicy",
+        "iam:GetRole",
+        "iam:GetRolePolicy",
+        "iam:PassRole",
+        "iam:PutRolePolicy",
+        "iam:TagRole",
+        "iam:UntagRole"
+      ],
+      lambda: [
+        "lambda:AddPermission",
+        "lambda:CreateFunction",
+        "lambda:DeleteFunction",
+        "lambda:GetFunction",
+        "lambda:GetFunctionConfiguration",
+        "lambda:InvokeFunction",
+        "lambda:ListFunctions",
+        "lambda:PutFunctionConcurrency",
+        "lambda:RemovePermission",
+        "lambda:TagResource",
+        "lambda:UntagResource",
+        "lambda:UpdateFunctionCode",
+        "lambda:UpdateFunctionConfiguration"
+      ],
+      logs: [
+        "logs:CreateLogGroup",
+        "logs:DeleteLogGroup",
+        "logs:DescribeLogGroups",
+        "logs:PutRetentionPolicy",
+        "logs:TagResource"
+      ],
+      s3Bucket: [
+        "s3:CreateBucket",
+        "s3:DeleteBucket",
+        "s3:DeleteBucketPolicy",
+        "s3:GetBucketLocation",
+        "s3:GetBucketPolicy",
+        "s3:GetBucketTagging",
+        "s3:GetBucketVersioning",
+        "s3:GetLifecycleConfiguration",
+        "s3:ListAllMyBuckets",
+        "s3:ListBucket",
+        "s3:PutBucketPolicy",
+        "s3:PutBucketTagging",
+        "s3:PutBucketVersioning",
+        "s3:PutLifecycleConfiguration",
+        "s3:PutPublicAccessBlock"
+      ],
+      s3Object: ["s3:DeleteObject", "s3:GetObject", "s3:PutObject"],
+      states: [
+        "states:CreateStateMachine",
+        "states:DeleteStateMachine",
+        "states:DescribeExecution",
+        "states:DescribeStateMachine",
+        "states:GetExecutionHistory",
+        "states:ListExecutions",
+        "states:ListStateMachines",
+        "states:StartExecution",
+        "states:StopExecution",
+        "states:TagResource",
+        "states:UntagResource",
+        "states:UpdateStateMachine"
+      ]
+    };
+  }
+});
+
+// src/commands/lambda.ts
+var lambda_exports = {};
+__export(lambda_exports, {
+  default: () => lambda_default,
+  examples: () => examples24
+});
+function parseIntFlag(raw) {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  const n = Number.parseInt(String(raw), 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parsePositiveInt(raw, flagName) {
+  const n = parseIntFlag(raw);
+  if (n === void 0) return void 0;
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`[lambda] ${flagName} must be a positive integer; got ${n}`);
+  }
+  return n;
+}
+function parseEnum(raw, allowed, errorPrefix, defaultValue) {
+  if (raw === void 0 || raw === null || raw === "") return defaultValue;
+  const s2 = String(raw);
+  if (allowed.includes(s2)) return s2;
+  throw new Error(`${errorPrefix} must be ${allowed.join("|")}; got ${s2}`);
+}
+var examples24, HELP, lambda_default, FORMATS, CODECS, QUALITIES2, CHROME_SOURCES, parseFormat, parseCodec, parseQuality, parseChromeSource;
+var init_lambda = __esm({
+  "src/commands/lambda.ts"() {
+    "use strict";
+    init_dist();
+    init_colors();
+    examples24 = [
+      ["Deploy the Lambda render stack to AWS", "hyperframes lambda deploy"],
+      [
+        "Render a composition on the deployed stack",
+        "hyperframes lambda render ./my-project --width 1920 --height 1080"
+      ],
+      [
+        "Render and stream progress until done",
+        "hyperframes lambda render ./my-project --width 1920 --height 1080 --wait"
+      ],
+      ["Check progress for a started render", "hyperframes lambda progress hf-render-abcd1234"],
+      [
+        "Pre-upload a project so multiple renders share the upload",
+        "hyperframes lambda sites create ./my-project"
+      ],
+      ["Tear the stack down", "hyperframes lambda destroy"],
+      ["Print the IAM policy the CLI needs", "hyperframes lambda policies user"],
+      [
+        "Validate a checked-in IAM policy still covers the CLI",
+        "hyperframes lambda policies validate ./infra/iam/hyperframes.json"
+      ]
+    ];
+    HELP = `
+${c2.bold("hyperframes lambda")} ${c2.dim("<subcommand> [args]")}
+
+Deploy + drive distributed video renders on AWS Lambda.
+
+${c2.bold("SUBCOMMANDS:")}
+  ${c2.accent("deploy")}            ${c2.dim("Provision the Lambda + Step Functions + S3 stack via SAM")}
+  ${c2.accent("sites create")}      ${c2.dim("Tar + upload a project to S3 (reusable across renders)")}
+  ${c2.accent("render")}            ${c2.dim("Start a distributed render (returns a renderId)")}
+  ${c2.accent("progress")}          ${c2.dim("Print progress + cost for an in-flight or finished render")}
+  ${c2.accent("destroy")}           ${c2.dim("Tear the stack down (S3 bucket is retained)")}
+  ${c2.accent("policies")}          ${c2.dim("Print or validate the IAM permissions the CLI needs")}
+
+${c2.bold("FIRST RUN:")}
+  ${c2.accent("hyperframes lambda deploy")}
+  ${c2.accent("hyperframes lambda render ./my-project --width 1920 --height 1080 --wait")}
+
+${c2.bold("REQUIREMENTS:")}
+  \u2022 AWS CLI configured (env vars, ~/.aws/credentials, or SSO)
+  \u2022 AWS SAM CLI installed (https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+  \u2022 bun on PATH (used to build the handler ZIP)
+`;
+    lambda_default = defineCommand({
+      meta: { name: "lambda", description: "Deploy and drive renders on AWS Lambda" },
+      args: {
+        subcommand: {
+          type: "positional",
+          required: false,
+          description: "deploy | sites | render | progress | destroy | policies"
+        },
+        target: {
+          type: "positional",
+          required: false,
+          description: "Subcommand-specific positional (project dir, render id, policies verb, etc.)"
+        },
+        extra: {
+          type: "positional",
+          required: false,
+          description: "Extra positional (e.g. `sites create <projectDir>` or `policies validate <policy.json>`)"
+        },
+        // Stack identity
+        "stack-name": {
+          type: "string",
+          description: "CloudFormation stack name (default: hyperframes-default)"
+        },
+        region: { type: "string", description: "AWS region (default: AWS_REGION env or us-east-1)" },
+        profile: { type: "string", description: "AWS profile name (default: AWS_PROFILE env)" },
+        // deploy
+        concurrency: { type: "string", description: "Lambda reserved concurrency (default: 8)" },
+        "chrome-source": {
+          type: "string",
+          description: "sparticuz | chrome-headless-shell (default: sparticuz)"
+        },
+        memory: { type: "string", description: "Lambda memory MB (default: 10240)" },
+        "skip-build": { type: "boolean", description: "Reuse existing handler.zip (deploy)" },
+        // sites / render
+        "site-id": { type: "string", description: "Explicit site id (overrides content hash)" },
+        width: { type: "string", description: "Render width in pixels" },
+        height: { type: "string", description: "Render height in pixels" },
+        fps: { type: "string", description: "Render fps (24 | 30 | 60)" },
+        format: { type: "string", description: "mp4 | mov | png-sequence (default: mp4)" },
+        codec: { type: "string", description: "h264 | h265 (mp4 only)" },
+        quality: { type: "string", description: "draft | standard | high" },
+        "chunk-size": { type: "string", description: "Frames per chunk (default: 240)" },
+        "max-parallel-chunks": { type: "string", description: "Max concurrent chunks (default: 16)" },
+        "execution-name": {
+          type: "string",
+          description: "Step Functions execution name (default: hf-render-<uuid>)"
+        },
+        "output-key": {
+          type: "string",
+          description: "Final output S3 key (default: renders/<exec>/output.<ext>)"
+        },
+        wait: { type: "boolean", description: "Block until the render finishes" },
+        "wait-interval-ms": {
+          type: "string",
+          description: "Poll cadence in ms when --wait is set (default: 5000)"
+        },
+        // shared
+        json: { type: "boolean", description: "Emit machine-readable JSON" }
+      },
+      async run({ args }) {
+        const subcommand = args.subcommand;
+        if (!subcommand) {
+          console.log(HELP);
+          return;
+        }
+        const stackName = args["stack-name"] ?? // Lazy-imported so the dispatcher doesn't pull state.ts (and its
+        // node:fs deps) on every CLI invocation — only on lambda runs.
+        (await Promise.resolve().then(() => (init_state(), state_exports))).DEFAULT_STACK_NAME;
+        const profileFlag = args.profile;
+        if (profileFlag) process.env.AWS_PROFILE = profileFlag;
+        const regionFlag = args.region;
+        if (regionFlag) process.env.AWS_REGION = regionFlag;
+        const verbsNeedingSDK = /* @__PURE__ */ new Set(["deploy", "sites", "render", "progress", "destroy"]);
+        if (verbsNeedingSDK.has(subcommand)) {
+          try {
+            await import("@hyperframes/aws-lambda/sdk");
+          } catch (err) {
+            if (err.code === "ERR_MODULE_NOT_FOUND") {
+              console.error(
+                `${c2.error("@hyperframes/aws-lambda is not installed.")} The ${c2.accent(`hyperframes lambda ${subcommand}`)} command needs it at runtime.
+Install it alongside the CLI:
+  ${c2.accent("npm install -g @hyperframes/aws-lambda")}
+Or, for an opt-in dev setup:
+  ${c2.accent("npm install @hyperframes/aws-lambda")}`
+              );
+              process.exit(1);
+            }
+            throw err;
+          }
+        }
+        switch (subcommand) {
+          case "deploy": {
+            const { runDeploy: runDeploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+            await runDeploy2({
+              stackName,
+              region: args.region,
+              awsProfile: args.profile,
+              reservedConcurrency: parsePositiveInt(args.concurrency, "--concurrency"),
+              chromeSource: parseChromeSource(args["chrome-source"]),
+              lambdaMemoryMb: parsePositiveInt(args.memory, "--memory"),
+              skipBuild: Boolean(args["skip-build"])
+            });
+            return;
+          }
+          case "sites": {
+            if (args.target !== "create") {
+              console.error(
+                `[lambda sites] unknown verb "${String(args.target)}". Only "create" is supported.`
+              );
+              process.exit(1);
+            }
+            const projectDir = args.extra;
+            if (!projectDir) {
+              console.error(
+                "[lambda sites create] usage: hyperframes lambda sites create <projectDir>"
+              );
+              process.exit(1);
+            }
+            const { runSitesCreate: runSitesCreate2 } = await Promise.resolve().then(() => (init_sites(), sites_exports));
+            await runSitesCreate2({
+              projectDir,
+              stackName,
+              siteId: args["site-id"],
+              json: Boolean(args.json)
+            });
+            return;
+          }
+          case "render": {
+            const projectDir = args.target;
+            if (!projectDir) {
+              console.error(
+                "[lambda render] usage: hyperframes lambda render <projectDir> --width <px> --height <px>"
+              );
+              process.exit(1);
+            }
+            const width = parsePositiveInt(args.width, "--width");
+            const height = parsePositiveInt(args.height, "--height");
+            if (width === void 0 || height === void 0) {
+              console.error("[lambda render] --width and --height are required.");
+              process.exit(1);
+            }
+            const fpsRaw = parseIntFlag(args.fps) ?? 30;
+            if (fpsRaw !== 24 && fpsRaw !== 30 && fpsRaw !== 60) {
+              console.error(`[lambda render] --fps must be 24, 30, or 60; got ${fpsRaw}.`);
+              process.exit(1);
+            }
+            const { runRender: runRender2 } = await Promise.resolve().then(() => (init_render3(), render_exports2));
+            await runRender2({
+              projectDir,
+              stackName,
+              siteId: args["site-id"],
+              fps: fpsRaw,
+              width,
+              height,
+              format: parseFormat(args.format),
+              codec: parseCodec(args.codec),
+              quality: parseQuality(args.quality),
+              chunkSize: parsePositiveInt(args["chunk-size"], "--chunk-size"),
+              maxParallelChunks: parsePositiveInt(args["max-parallel-chunks"], "--max-parallel-chunks"),
+              executionName: args["execution-name"],
+              outputKey: args["output-key"],
+              json: Boolean(args.json),
+              wait: Boolean(args.wait),
+              waitIntervalMs: parsePositiveInt(args["wait-interval-ms"], "--wait-interval-ms") ?? 5e3
+            });
+            return;
+          }
+          case "progress": {
+            const target = args.target;
+            if (!target) {
+              console.error(
+                "[lambda progress] usage: hyperframes lambda progress <renderId | executionArn>"
+              );
+              process.exit(1);
+            }
+            const { runProgress: runProgress2 } = await Promise.resolve().then(() => (init_progress2(), progress_exports));
+            await runProgress2({ target, stackName, json: Boolean(args.json) });
+            return;
+          }
+          case "destroy": {
+            const { runDestroy: runDestroy2 } = await Promise.resolve().then(() => (init_destroy(), destroy_exports));
+            await runDestroy2({ stackName, awsProfile: args.profile });
+            return;
+          }
+          case "policies": {
+            const verb = args.target;
+            if (verb !== "role" && verb !== "user" && verb !== "validate") {
+              console.error(
+                `[lambda policies] usage: hyperframes lambda policies <role|user|validate> [args]`
+              );
+              process.exit(1);
+            }
+            const { runPolicies: runPolicies2 } = await Promise.resolve().then(() => (init_policies(), policies_exports));
+            await runPolicies2({
+              verb,
+              inputPath: args.extra,
+              json: Boolean(args.json)
+            });
+            return;
+          }
+          default:
+            console.error(`${c2.error("Unknown subcommand:")} ${subcommand}
+${HELP}`);
+            process.exit(1);
+        }
+      }
+    });
+    FORMATS = ["mp4", "mov", "png-sequence"];
+    CODECS = ["h264", "h265"];
+    QUALITIES2 = ["draft", "standard", "high"];
+    CHROME_SOURCES = ["sparticuz", "chrome-headless-shell"];
+    parseFormat = (raw) => parseEnum(raw, FORMATS, "[lambda render] --format", "mp4");
+    parseCodec = (raw) => parseEnum(raw, CODECS, "[lambda render] --codec", void 0);
+    parseQuality = (raw) => parseEnum(raw, QUALITIES2, "[lambda render] --quality", void 0);
+    parseChromeSource = (raw) => parseEnum(raw, CHROME_SOURCES, "[lambda deploy] --chrome-source", "sparticuz");
+  }
+});
+
 // src/telemetry/index.ts
 var telemetry_exports2 = {};
 __export(telemetry_exports2, {
@@ -95063,9 +96259,9 @@ __export(autoUpdate_exports, {
   scheduleBackgroundInstall: () => scheduleBackgroundInstall
 });
 import { spawn as spawn16 } from "child_process";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync41, openSync as openSync2 } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync42, openSync as openSync2 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join80 } from "path";
+import { join as join83 } from "path";
 import { compareVersions as compareVersions2 } from "compare-versions";
 function isAutoInstallDisabled() {
   if (isDevMode()) return true;
@@ -95080,15 +96276,15 @@ function majorOf(version) {
 }
 function log(line) {
   try {
-    mkdirSync41(CONFIG_DIR2, { recursive: true, mode: 448 });
+    mkdirSync42(CONFIG_DIR2, { recursive: true, mode: 448 });
     appendFileSync2(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `, { mode: 384 });
   } catch {
   }
 }
 function launchDetachedInstall(installCommand, version) {
-  mkdirSync41(CONFIG_DIR2, { recursive: true, mode: 448 });
-  const configFile = join80(CONFIG_DIR2, "config.json");
+  mkdirSync42(CONFIG_DIR2, { recursive: true, mode: 448 });
+  const configFile = join83(CONFIG_DIR2, "config.json");
   const nodeScript = `
     const { exec } = require("node:child_process");
     const { readFileSync, renameSync, writeFileSync } = require("node:fs");
@@ -95207,8 +96403,8 @@ var init_autoUpdate = __esm({
     init_config();
     init_env();
     init_installerDetection();
-    CONFIG_DIR2 = join80(homedir12(), ".hyperframes");
-    LOG_FILE = join80(CONFIG_DIR2, "auto-update.log");
+    CONFIG_DIR2 = join83(homedir12(), ".hyperframes");
+    LOG_FILE = join83(CONFIG_DIR2, "auto-update.log");
     PENDING_TIMEOUT_MS = 10 * 60 * 1e3;
   }
 });
@@ -95286,10 +96482,10 @@ function renderRootHelp() {
   lines.push(`Run ${c2.cyan("hyperframes <command> --help")} for more information about a command.`);
   return lines.join("\n");
 }
-function formatExamples(examples24) {
+function formatExamples(examples25) {
   const lines = [];
   lines.push(c2.bold("Examples:"));
-  for (const [comment, command2] of examples24) {
+  for (const [comment, command2] of examples25) {
     lines.push(`  ${c2.gray(`# ${comment}`)}`);
     lines.push(`  ${command2}`);
     lines.push("");
@@ -95306,9 +96502,9 @@ async function showUsage2(cmd, parent) {
   console.log(usage + "\n");
   const name = meta?.name;
   if (name) {
-    const examples24 = STATIC_EXAMPLES[name] ?? await loadExamples(name);
-    if (examples24) {
-      console.log(formatExamples(examples24) + "\n");
+    const examples25 = STATIC_EXAMPLES[name] ?? await loadExamples(name);
+    if (examples25) {
+      console.log(formatExamples(examples25) + "\n");
     }
   }
 }
@@ -95356,6 +96552,10 @@ var init_help = __esm({
           ["upgrade", "Check for updates and show upgrade instructions"]
         ]
       },
+      {
+        title: "Deploy",
+        commands: [["lambda", "Deploy and drive distributed renders on AWS Lambda"]]
+      },
       {
         title: "AI & Integrations",
         commands: [
@@ -95392,17 +96592,17 @@ var init_help = __esm({
 // src/cli.ts
 init_version();
 init_dist();
-import { dirname as dirname27, join as join81 } from "path";
-import { fileURLToPath as fileURLToPath11 } from "url";
-import { existsSync as existsSync69 } from "fs";
+import { dirname as dirname30, join as join84 } from "path";
+import { fileURLToPath as fileURLToPath12 } from "url";
+import { existsSync as existsSync73 } from "fs";
 (() => {
-  const here = dirname27(fileURLToPath11(import.meta.url));
-  const shader = join81(here, "shaderTransitionWorker.js");
-  const png = join81(here, "pngDecodeBlitWorker.js");
-  if (!process.env.HF_SHADER_WORKER_ENTRY && existsSync69(shader)) {
+  const here = dirname30(fileURLToPath12(import.meta.url));
+  const shader = join84(here, "shaderTransitionWorker.js");
+  const png = join84(here, "pngDecodeBlitWorker.js");
+  if (!process.env.HF_SHADER_WORKER_ENTRY && existsSync73(shader)) {
     process.env.HF_SHADER_WORKER_ENTRY = shader;
   }
-  if (!process.env.HF_PNG_DECODE_BLIT_WORKER_ENTRY && existsSync69(png)) {
+  if (!process.env.HF_PNG_DECODE_BLIT_WORKER_ENTRY && existsSync73(png)) {
     process.env.HF_PNG_DECODE_BLIT_WORKER_ENTRY = png;
   }
 })();
@@ -95439,7 +96639,8 @@ var subCommands = {
   telemetry: () => Promise.resolve().then(() => (init_telemetry(), telemetry_exports)).then((m2) => m2.default),
   validate: () => Promise.resolve().then(() => (init_validate(), validate_exports)).then((m2) => m2.default),
   snapshot: () => Promise.resolve().then(() => (init_snapshot(), snapshot_exports)).then((m2) => m2.default),
-  capture: () => Promise.resolve().then(() => (init_capture2(), capture_exports2)).then((m2) => m2.default)
+  capture: () => Promise.resolve().then(() => (init_capture2(), capture_exports2)).then((m2) => m2.default),
+  lambda: () => Promise.resolve().then(() => (init_lambda(), lambda_exports)).then((m2) => m2.default)
 };
 var main = defineCommand({
   meta: {