hyperframes 0.6.54 → 0.6.56

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.6.54" : "0.0.0-dev";
+    VERSION = true ? "0.6.56" : "0.0.0-dev";
   }
 });
 
@@ -3094,18 +3094,18 @@ function serializeValue(value) {
 }
 function serializeObject(obj) {
   const entries2 = Object.entries(obj).map(([key2, value]) => {
-    const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key2) ? key2 : JSON.stringify(key2);
-    return `${safeKey}: ${serializeValue(value)}`;
+    const safeKey2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key2) ? key2 : JSON.stringify(key2);
+    return `${safeKey2}: ${serializeValue(value)}`;
   });
   return `{ ${entries2.join(", ")} }`;
 }
 function serializeExtras(extras) {
   return Object.entries(extras).map(([key2, value]) => {
-    const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key2) ? key2 : JSON.stringify(key2);
-    return `${safeKey}: ${serializeValue(value)}`;
+    const safeKey2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key2) ? key2 : JSON.stringify(key2);
+    return `${safeKey2}: ${serializeValue(value)}`;
   }).join(", ");
 }
-function getAnimationsForElement(animations, elementId) {
+function getAnimationsForElementId(animations, elementId) {
   const selector = `#${elementId}`;
   return animations.filter((a) => a.targetSelector === selector);
 }
@@ -35082,7 +35082,7 @@ __export(gsapParser_exports, {
   SUPPORTED_EASES: () => SUPPORTED_EASES,
   SUPPORTED_PROPS: () => SUPPORTED_PROPS,
   addAnimationToScript: () => addAnimationToScript,
-  getAnimationsForElement: () => getAnimationsForElement,
+  getAnimationsForElementId: () => getAnimationsForElementId,
   gsapAnimationsToKeyframes: () => gsapAnimationsToKeyframes,
   keyframesToGsapAnimations: () => keyframesToGsapAnimations,
   parseGsapScript: () => parseGsapScript,
@@ -35156,6 +35156,112 @@ function resolveNode(node, scope) {
 function extractLiteralValue(node, scope) {
   return resolveNode(node, scope);
 }
+function selectorFromQueryCall(node, scope) {
+  if (node?.type !== "CallExpression") return null;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression" || callee.property?.type !== "Identifier") return null;
+  const method = callee.property.name;
+  const argValue = resolveNode(node.arguments?.[0], scope);
+  if (typeof argValue !== "string" || argValue.length === 0) return null;
+  if (QUERY_METHODS.has(method) || method === "toArray") return argValue;
+  if (method === "getElementById") return `#${argValue}`;
+  return null;
+}
+function enclosingScopeNode(path2) {
+  let p2 = path2?.parentPath;
+  while (p2) {
+    if (SCOPE_NODE_TYPES.has(p2.node?.type)) return p2.node;
+    p2 = p2.parentPath;
+  }
+  return null;
+}
+function scopeChainOf(path2) {
+  const chain = [];
+  let p2 = path2;
+  while (p2) {
+    if (SCOPE_NODE_TYPES.has(p2.node?.type)) chain.push(p2.node);
+    p2 = p2.parentPath;
+  }
+  return chain;
+}
+function addBinding(bindings, scopeNode, name, selector) {
+  let scoped = bindings.get(scopeNode);
+  if (!scoped) {
+    scoped = /* @__PURE__ */ new Map();
+    bindings.set(scopeNode, scoped);
+  }
+  if (!scoped.has(name)) scoped.set(name, selector);
+}
+function collectTargetBindings(ast, scope) {
+  const bindings = /* @__PURE__ */ new Map();
+  recast.types.visit(ast, {
+    visitVariableDeclarator(path2) {
+      const name = path2.node.id?.name;
+      const selector = selectorFromQueryCall(path2.node.init, scope);
+      if (name && selector !== null) addBinding(bindings, enclosingScopeNode(path2), name, selector);
+      this.traverse(path2);
+    },
+    visitAssignmentExpression(path2) {
+      const left = path2.node.left;
+      const selector = selectorFromQueryCall(path2.node.right, scope);
+      if (left?.type === "Identifier" && selector !== null) {
+        addBinding(bindings, enclosingScopeNode(path2), left.name, selector);
+      }
+      this.traverse(path2);
+    }
+  });
+  recast.types.visit(ast, {
+    visitCallExpression(path2) {
+      const node = path2.node;
+      const callee = node.callee;
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && ITERATION_METHODS.has(callee.property.name)) {
+        const collectionSelector = resolveCollectionSelector(callee.object, path2, scope, bindings);
+        const fn = node.arguments?.[0];
+        const param = fn?.params?.[0];
+        if (collectionSelector && param?.type === "Identifier" && isFunctionNode(fn)) {
+          addBinding(bindings, fn, param.name, collectionSelector);
+        }
+      }
+      this.traverse(path2);
+    }
+  });
+  return bindings;
+}
+function isFunctionNode(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
+}
+function resolveCollectionSelector(node, callPath, scope, bindings) {
+  if (node?.type === "Identifier") return lookupBinding(node.name, callPath, bindings);
+  if (node?.type === "CallExpression") return selectorFromQueryCall(node, scope);
+  return null;
+}
+function lookupBinding(name, path2, bindings) {
+  for (const scopeNode of scopeChainOf(path2)) {
+    const selector = bindings.get(scopeNode)?.get(name);
+    if (selector !== void 0) return selector;
+  }
+  return null;
+}
+function resolveTargetSelector(node, path2, scope, bindings) {
+  if (!node) return null;
+  if (node.type === "StringLiteral" || node.type === "Literal") {
+    return typeof node.value === "string" ? node.value : null;
+  }
+  if (node.type === "Identifier") {
+    return lookupBinding(node.name, path2, bindings);
+  }
+  if (node.type === "CallExpression") {
+    return selectorFromQueryCall(node, scope);
+  }
+  if (node.type === "ArrayExpression") {
+    const parts = node.elements.map((el) => resolveTargetSelector(el, path2, scope, bindings)).filter((s2) => typeof s2 === "string" && s2.length > 0);
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  if (node.type === "MemberExpression" && node.object?.type === "Identifier") {
+    return lookupBinding(node.object.name, path2, bindings);
+  }
+  return null;
+}
 function objectExpressionToRecord(node, scope) {
   const result = {};
   if (node?.type !== "ObjectExpression") return result;
@@ -35199,13 +35305,20 @@ function findTimelineVar(ast) {
   });
   return { timelineVar, timelineCount };
 }
-function findAllTweenCalls(ast, timelineVar) {
+function isTimelineRootedCall(callNode, timelineVar) {
+  let obj = callNode.callee?.object;
+  while (obj?.type === "CallExpression") {
+    obj = obj.callee?.object;
+  }
+  return obj?.type === "Identifier" && obj.name === timelineVar;
+}
+function findAllTweenCalls(ast, timelineVar, scope, targetBindings) {
   const results = [];
   recast.types.visit(ast, {
     visitCallExpression(path2) {
       const node = path2.node;
       const callee = node.callee;
-      if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === timelineVar && callee.property?.type === "Identifier") {
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && isTimelineRootedCall(node, timelineVar)) {
         const method = callee.property.name;
         if (!GSAP_METHODS.has(method)) {
           this.traverse(path2);
@@ -35216,8 +35329,7 @@ function findAllTweenCalls(ast, timelineVar) {
           this.traverse(path2);
           return;
         }
-        const selectorArg = args[0];
-        const selectorValue = selectorArg.type === "StringLiteral" || selectorArg.type === "Literal" ? String(selectorArg.value) : null;
+        const selectorValue = resolveTargetSelector(args[0], path2, scope, targetBindings);
         if (!selectorValue) {
           this.traverse(path2);
           return;
@@ -35316,14 +35428,25 @@ function assignStableIds(anims) {
     return { ...anim, id };
   });
 }
+function parseGsapAst(script) {
+  const ast = parseScript(script);
+  const scope = collectScopeBindings(ast);
+  const targetBindings = collectTargetBindings(ast, scope);
+  const detection = findTimelineVar(ast);
+  const timelineVar = detection.timelineVar ?? "tl";
+  const calls = findAllTweenCalls(ast, timelineVar, scope, targetBindings);
+  const animations = assignStableIds(calls.map((call) => tweenCallToAnimation(call, scope)));
+  const located = animations.map((animation, i2) => ({
+    id: animation.id,
+    call: calls[i2],
+    animation
+  }));
+  return { ast, scope, timelineVar, detection, located };
+}
 function parseGsapScript(script) {
   try {
-    const ast = parseScript(script);
-    const scope = collectScopeBindings(ast);
-    const detection = findTimelineVar(ast);
-    const timelineVar = detection.timelineVar ?? "tl";
-    const calls = findAllTweenCalls(ast, timelineVar);
-    const animations = assignStableIds(calls.map((call) => tweenCallToAnimation(call, scope)));
+    const { detection, timelineVar, located } = parseGsapAst(script);
+    const animations = located.map((l) => l.animation);
     const timelineMatch = script.match(
       new RegExp(
         `^[\\s\\S]*?(?:const|let|var)\\s+${timelineVar}\\s*=\\s*gsap\\.timeline\\s*\\([^)]*\\)\\s*;?`
@@ -35348,52 +35471,203 @@ function parseGsapScript(script) {
     return { animations: [], timelineVar: "tl", preamble: "", postamble: "" };
   }
 }
-function isParseFailure(parsed) {
-  return parsed.animations.length === 0 && !parsed.preamble;
+function valueToCode(value) {
+  if (typeof value === "string" && value.startsWith("__raw:")) return value.slice(6);
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
 }
-function updateAnimationInScript(script, animationId, updates) {
-  const parsed = parseGsapScript(script);
-  if (isParseFailure(parsed)) return script;
-  const updated = parsed.animations.map(
-    (anim) => anim.id === animationId ? { ...anim, ...updates } : anim
+function safeKey(key2) {
+  return /^[A-Za-z_$][\w$]*$/.test(key2) ? key2 : JSON.stringify(key2);
+}
+function parseExpr(code) {
+  return parseScript(`__hf__ = ${code};`).program.body[0].expression.right;
+}
+function propKeyName(prop2) {
+  return prop2?.key?.name ?? prop2?.key?.value;
+}
+function isObjectProperty(prop2) {
+  return prop2?.type === "ObjectProperty" || prop2?.type === "Property";
+}
+function isEditablePropertyKey(key2) {
+  return !BUILTIN_VAR_KEYS.has(key2) && !DROPPED_VAR_KEYS.has(key2) && !EXTRAS_KEYS.has(key2);
+}
+function makeObjectProperty(key2, value) {
+  const obj = parseExpr(`{ ${safeKey(key2)}: ${valueToCode(value)} }`);
+  return obj.properties[0];
+}
+function setVarsKey(varsArg, key2, value) {
+  if (varsArg?.type !== "ObjectExpression") return;
+  const existing = varsArg.properties.find(
+    (p2) => isObjectProperty(p2) && propKeyName(p2) === key2
   );
-  return serializeGsapAnimations(updated, parsed.timelineVar, {
-    preamble: parsed.preamble,
-    postamble: parsed.postamble
+  if (existing) {
+    existing.value = parseExpr(valueToCode(value));
+  } else {
+    varsArg.properties.push(makeObjectProperty(key2, value));
+  }
+}
+function reconcileEditableProperties(varsArg, newProps) {
+  if (varsArg?.type !== "ObjectExpression") return;
+  varsArg.properties = varsArg.properties.filter((p2) => {
+    if (!isObjectProperty(p2)) return true;
+    const key2 = propKeyName(p2);
+    if (typeof key2 !== "string") return true;
+    if (!isEditablePropertyKey(key2)) return true;
+    return key2 in newProps;
   });
+  for (const [key2, value] of Object.entries(newProps)) {
+    setVarsKey(varsArg, key2, value);
+  }
+}
+function applyUpdatesToCall(call, updates) {
+  if (updates.properties) reconcileEditableProperties(call.varsArg, updates.properties);
+  if (updates.fromProperties && call.method === "fromTo") {
+    reconcileEditableProperties(call.fromArg, updates.fromProperties);
+  }
+  if (updates.duration !== void 0) setVarsKey(call.varsArg, "duration", updates.duration);
+  if (updates.ease !== void 0) setVarsKey(call.varsArg, "ease", updates.ease);
+  if (updates.position !== void 0) {
+    const posIdx = call.method === "fromTo" ? 3 : 2;
+    call.node.arguments[posIdx] = parseExpr(valueToCode(updates.position));
+  }
+}
+function findStatementPath(path2) {
+  let p2 = path2;
+  while (p2) {
+    if (p2.node?.type === "ExpressionStatement") return p2;
+    p2 = p2.parentPath;
+  }
+  return null;
+}
+function buildTweenStatementCode(timelineVar, anim) {
+  const selector = JSON.stringify(anim.targetSelector);
+  const props = { ...anim.properties };
+  if (anim.method !== "set" && anim.duration !== void 0) props.duration = anim.duration;
+  if (anim.ease) props.ease = anim.ease;
+  const entries2 = Object.entries(props).map(([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`);
+  if (anim.extras) {
+    for (const [k2, v2] of Object.entries(anim.extras)) {
+      entries2.push(`${safeKey(k2)}: ${valueToCode(v2)}`);
+    }
+  }
+  const objCode = `{ ${entries2.join(", ")} }`;
+  const posCode = valueToCode(
+    typeof anim.position === "number" ? anim.position : anim.position ?? 0
+  );
+  if (anim.method === "fromTo") {
+    const fromEntries = Object.entries(anim.fromProperties ?? {}).map(
+      ([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`
+    );
+    const fromCode = `{ ${fromEntries.join(", ")} }`;
+    return `${timelineVar}.fromTo(${selector}, ${fromCode}, ${objCode}, ${posCode});`;
+  }
+  return `${timelineVar}.${anim.method}(${selector}, ${objCode}, ${posCode});`;
+}
+function updateAnimationInScript(script, animationId, updates) {
+  let parsed;
+  try {
+    parsed = parseGsapAst(script);
+  } catch (e3) {
+    console.warn("[gsap-parser] updateAnimationInScript parse failed:", e3);
+    return script;
+  }
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  applyUpdatesToCall(target.call, updates);
+  return recast.print(parsed.ast).code;
 }
 function addAnimationToScript(script, animation) {
-  const parsed = parseGsapScript(script);
-  if (isParseFailure(parsed)) return { script, id: "" };
+  let parsed;
+  try {
+    parsed = parseGsapAst(script);
+  } catch (e3) {
+    console.warn("[gsap-parser] addAnimationToScript parse failed:", e3);
+    return { script, id: "" };
+  }
+  if (parsed.located.length === 0 && parsed.detection.timelineVar === null) {
+    return { script, id: "" };
+  }
   const id = `anim-${Date.now()}`;
-  const newAnim = { ...animation, id };
-  const allAnimations = [...parsed.animations, newAnim];
-  return {
-    script: serializeGsapAnimations(allAnimations, parsed.timelineVar, {
-      preamble: parsed.preamble,
-      postamble: parsed.postamble
-    }),
-    id
-  };
+  const statementCode = buildTweenStatementCode(parsed.timelineVar, animation);
+  const newStatement = parseScript(statementCode).program.body[0];
+  const lastCall = parsed.located[parsed.located.length - 1]?.call;
+  const anchorPath = lastCall ? findStatementPath(lastCall.path) : findTimelineDeclarationPath(parsed.ast, parsed.timelineVar);
+  if (anchorPath) {
+    anchorPath.insertAfter(newStatement);
+  } else {
+    parsed.ast.program.body.push(newStatement);
+  }
+  return { script: recast.print(parsed.ast).code, id };
 }
-function removeAnimationFromScript(script, animationId) {
-  const parsed = parseGsapScript(script);
-  if (isParseFailure(parsed)) return script;
-  const filtered = parsed.animations.filter((a) => a.id !== animationId);
-  return serializeGsapAnimations(filtered, parsed.timelineVar, {
-    preamble: parsed.preamble,
-    postamble: parsed.postamble
+function findTimelineDeclarationPath(ast, timelineVar) {
+  let found = null;
+  recast.types.visit(ast, {
+    visitVariableDeclaration(path2) {
+      if (found) return false;
+      for (const decl of path2.node.declarations ?? []) {
+        if (decl.id?.name === timelineVar && isGsapTimelineCall(decl.init)) {
+          found = path2;
+          return false;
+        }
+      }
+      this.traverse(path2);
+    }
+  });
+  return found;
+}
+function findChainParentCall(stmtNode, targetNode) {
+  let found = null;
+  recast.types.visit(stmtNode, {
+    visitCallExpression(p2) {
+      if (found) return false;
+      if (p2.node.callee?.type === "MemberExpression" && p2.node.callee.object === targetNode) {
+        found = p2.node;
+        return false;
+      }
+      this.traverse(p2);
+    }
   });
+  return found;
 }
-var recast, import_parser, GSAP_METHODS, BUILTIN_VAR_KEYS, DROPPED_VAR_KEYS, EXTRAS_KEYS;
+function removeAnimationFromScript(script, animationId) {
+  let parsed;
+  try {
+    parsed = parseGsapAst(script);
+  } catch (e3) {
+    console.warn("[gsap-parser] removeAnimationFromScript parse failed:", e3);
+    return script;
+  }
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const node = target.call.node;
+  const stmtPath = findStatementPath(target.call.path);
+  if (!stmtPath) return script;
+  const parentCall = findChainParentCall(stmtPath.node, node);
+  if (parentCall) {
+    parentCall.callee.object = node.callee.object;
+  } else if (node.callee?.object?.type === "CallExpression") {
+    stmtPath.node.expression = node.callee.object;
+  } else {
+    stmtPath.prune();
+  }
+  return recast.print(parsed.ast).code;
+}
+var recast, import_parser, GSAP_METHODS, QUERY_METHODS, ITERATION_METHODS, SCOPE_NODE_TYPES, BUILTIN_VAR_KEYS, DROPPED_VAR_KEYS, EXTRAS_KEYS;
 var init_gsapParser = __esm({
   "../core/src/parsers/gsapParser.ts"() {
     "use strict";
     recast = __toESM(require_main2(), 1);
     import_parser = __toESM(require_lib(), 1);
     init_gsapSerialize();
-    init_gsapSerialize();
     GSAP_METHODS = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
+    QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
+    ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map"]);
+    SCOPE_NODE_TYPES = /* @__PURE__ */ new Set([
+      "Program",
+      "FunctionDeclaration",
+      "FunctionExpression",
+      "ArrowFunctionExpression"
+    ]);
     BUILTIN_VAR_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "delay"]);
     DROPPED_VAR_KEYS = /* @__PURE__ */ new Set(["keyframes", "onComplete", "onStart", "onUpdate", "onRepeat"]);
     EXTRAS_KEYS = /* @__PURE__ */ new Set([
@@ -37086,122 +37360,51 @@ function readRegisteredTimelineCompositionId(script) {
   const match = script.match(WINDOW_TIMELINE_ASSIGN_PATTERN);
   return match?.[1] || null;
 }
+function unwrapRaw(value) {
+  if (typeof value === "number") return value;
+  if (typeof value !== "string") return void 0;
+  const code = value.startsWith("__raw:") ? value.slice(6) : value;
+  return code.replace(/^\s*["']|["']\s*$/g, "");
+}
+function extrasNumber(value) {
+  const unwrapped = unwrapRaw(value);
+  const numeric = typeof unwrapped === "number" ? unwrapped : Number(unwrapped);
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+function synthesizeWindowRaw(timelineVar, anim) {
+  const entries2 = Object.entries(anim.properties).map(([k2, v2]) => {
+    if (typeof v2 === "string" && v2.startsWith("__raw:")) return `${k2}: ${v2.slice(6)}`;
+    return `${k2}: ${typeof v2 === "string" ? JSON.stringify(v2) : v2}`;
+  });
+  if (anim.duration !== void 0) entries2.push(`duration: ${anim.duration}`);
+  if (anim.ease) entries2.push(`ease: ${JSON.stringify(anim.ease)}`);
+  const pos = typeof anim.position === "number" ? anim.position : JSON.stringify(anim.position);
+  return `${timelineVar}.${anim.method}("${anim.targetSelector}", { ${entries2.join(", ")} }, ${pos})`;
+}
 async function extractGsapWindows(script) {
   if (!/gsap\.timeline/.test(script)) return [];
   const parseGsapScript2 = await loadParseGsapScript();
   const parsed = parseGsapScript2(script);
   if (parsed.animations.length === 0) return [];
   const windows = [];
-  const timelineVar = parsed.timelineVar;
-  const methodPattern = new RegExp(
-    `${timelineVar}\\.(set|to|from|fromTo)\\s*\\(([^)]+(?:\\{[^}]*\\}[^)]*)+)\\)`,
-    "g"
-  );
-  let match;
-  let index = 0;
-  while ((match = methodPattern.exec(script)) !== null && index < parsed.animations.length) {
-    const raw = match[0];
-    const args = match[2] ?? "";
-    if (!/^\s*["']/.test(args)) continue;
-    const meta = parseGsapWindowMeta(match[1] ?? "", args);
-    const animation = parsed.animations[index];
-    index += 1;
-    if (!animation) continue;
+  for (const animation of parsed.animations) {
     if (typeof animation.position !== "number") continue;
+    const repeat = extrasNumber(animation.extras?.repeat);
+    const cycleCount = repeat > 0 ? repeat + 1 : 1;
+    const effectiveDuration = animation.method === "set" ? 0 : (animation.duration ?? 0) * cycleCount;
     windows.push({
       targetSelector: animation.targetSelector,
       position: animation.position,
-      end: animation.position + meta.effectiveDuration,
-      properties: meta.properties.length > 0 ? meta.properties : Object.keys(animation.properties),
-      propertyValues: meta.propertyValues,
-      overwriteAuto: meta.overwriteAuto,
-      method: match[1] ?? "to",
-      raw
+      end: animation.position + effectiveDuration,
+      properties: Object.keys(animation.properties),
+      propertyValues: animation.properties,
+      overwriteAuto: unwrapRaw(animation.extras?.overwrite) === "auto",
+      method: animation.method,
+      raw: synthesizeWindowRaw(parsed.timelineVar, animation)
     });
   }
   return windows;
 }
-function parseGsapWindowMeta(method, argsStr) {
-  const emptyMeta = {
-    effectiveDuration: 0,
-    properties: [],
-    propertyValues: {},
-    overwriteAuto: false
-  };
-  const selectorMatch = argsStr.match(/^\s*["']([^"']+)["']\s*,/);
-  if (!selectorMatch) return emptyMeta;
-  const afterSelector = argsStr.slice(selectorMatch[0].length);
-  let properties = {};
-  let fromProperties = {};
-  if (method === "fromTo") {
-    const firstBrace = afterSelector.indexOf("{");
-    const firstEnd = findMatchingBrace(afterSelector, firstBrace);
-    if (firstBrace !== -1 && firstEnd !== -1) {
-      fromProperties = parseLooseObjectLiteral(afterSelector.slice(firstBrace, firstEnd + 1));
-      const secondPart = afterSelector.slice(firstEnd + 1);
-      const secondBrace = secondPart.indexOf("{");
-      const secondEnd = findMatchingBrace(secondPart, secondBrace);
-      if (secondBrace !== -1 && secondEnd !== -1) {
-        properties = parseLooseObjectLiteral(secondPart.slice(secondBrace, secondEnd + 1));
-      }
-    }
-  } else {
-    const braceStart = afterSelector.indexOf("{");
-    const braceEnd = findMatchingBrace(afterSelector, braceStart);
-    if (braceStart !== -1 && braceEnd !== -1) {
-      properties = parseLooseObjectLiteral(afterSelector.slice(braceStart, braceEnd + 1));
-    }
-  }
-  const duration = numberValue(properties.duration) || 0;
-  const repeat = numberValue(properties.repeat) || 0;
-  const cycleCount = repeat > 0 ? repeat + 1 : 1;
-  const effectiveDuration = duration * cycleCount;
-  const overwriteAuto = stringValue(properties.overwrite) === "auto";
-  const propertyNames = /* @__PURE__ */ new Set();
-  for (const key2 of Object.keys(fromProperties)) {
-    if (!META_GSAP_KEYS.has(key2)) propertyNames.add(key2);
-  }
-  for (const key2 of Object.keys(properties)) {
-    if (!META_GSAP_KEYS.has(key2)) propertyNames.add(key2);
-  }
-  return {
-    effectiveDuration: method === "set" ? 0 : effectiveDuration,
-    properties: [...propertyNames],
-    propertyValues: properties,
-    overwriteAuto
-  };
-}
-function parseLooseObjectLiteral(source) {
-  const result = {};
-  const cleaned = source.replace(/^\{|\}$/g, "").trim();
-  if (!cleaned) return result;
-  const propertyPattern = /(\w+)\s*:\s*("[^"]*"|'[^']*'|true|false|-?[\d.]+|[a-zA-Z_][\w.]*)/g;
-  let match;
-  while ((match = propertyPattern.exec(cleaned)) !== null) {
-    const key2 = match[1];
-    const rawValue = match[2];
-    if (!key2 || rawValue == null) continue;
-    if (rawValue.startsWith('"') && rawValue.endsWith('"') || rawValue.startsWith("'") && rawValue.endsWith("'")) {
-      result[key2] = rawValue.slice(1, -1);
-      continue;
-    }
-    const numeric = Number(rawValue);
-    result[key2] = Number.isFinite(numeric) ? numeric : rawValue;
-  }
-  return result;
-}
-function findMatchingBrace(source, startIndex) {
-  if (startIndex < 0) return -1;
-  let depth = 0;
-  for (let i2 = startIndex; i2 < source.length; i2++) {
-    if (source[i2] === "{") depth += 1;
-    else if (source[i2] === "}") {
-      depth -= 1;
-      if (depth === 0) return i2;
-    }
-  }
-  return -1;
-}
 function numberValue(value) {
   if (typeof value === "number") return value;
   if (typeof value === "string" && value.trim()) {
@@ -37341,12 +37544,11 @@ function cssTransformToGsapProps(cssTransform) {
   }
   return parts.length > 0 ? parts.join(", ") : null;
 }
-var META_GSAP_KEYS, SCENE_BOUNDARY_EPSILON_SECONDS, gsapRules;
+var SCENE_BOUNDARY_EPSILON_SECONDS, gsapRules;
 var init_gsap = __esm({
   "../core/src/lint/rules/gsap.ts"() {
     "use strict";
     init_utils2();
-    META_GSAP_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "repeat", "yoyo", "overwrite", "delay"]);
     SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
     gsapRules = [
       // overlapping_gsap_tweens + gsap_animates_clip_element + unscoped_gsap_selector
@@ -42355,7 +42557,7 @@ __export(src_exports, {
   generateGsapTimelineScript: () => generateGsapTimelineScript,
   generateHyperframesHtml: () => generateHyperframesHtml,
   generateHyperframesStyles: () => generateHyperframesStyles,
-  getAnimationsForElement: () => getAnimationsForElement,
+  getAnimationsForElementId: () => getAnimationsForElementId,
   getDefaultStageZoom: () => getDefaultStageZoom,
   getHyperframeRuntimeScript: () => getHyperframeRuntimeScript,
   getStageStyles: () => getStageStyles,
@@ -58183,7 +58385,12 @@ function updateReferences(projectDir, oldPath, newPath) {
 }
 function extractGsapScriptBlock(html) {
   const { document: document2 } = parseHTML(html);
-  const scripts = document2.querySelectorAll("script:not([src])");
+  const scripts = [
+    ...document2.querySelectorAll("script:not([src])"),
+    ...Array.from(document2.querySelectorAll("template")).flatMap(
+      (tmpl) => Array.from(tmpl.querySelectorAll("script:not([src])"))
+    )
+  ];
   for (const script of scripts) {
     const content = script.textContent || "";
     if (content.includes("gsap.timeline") || content.includes(".set(") || content.includes(".to(")) {
@@ -66719,6 +66926,101 @@ var init_videoFrameInjector = __esm({
   }
 });
 
+// ../engine/src/services/audioVolumeEnvelope.ts
+import { readFileSync as readFileSync22, renameSync as renameSync3, writeFileSync as writeFileSync14 } from "fs";
+import { randomBytes } from "crypto";
+function parseWavLayout(buffer) {
+  if (buffer.length < 12 || buffer.toString("ascii", 0, 4) !== "RIFF") return null;
+  if (buffer.toString("ascii", 8, 12) !== "WAVE") return null;
+  let offset = 12;
+  let fmt = null;
+  let data = null;
+  while (offset + 8 <= buffer.length) {
+    const chunkId = buffer.toString("ascii", offset, offset + 4);
+    const chunkSize = buffer.readUInt32LE(offset + 4);
+    const body = offset + 8;
+    if (chunkId === "fmt " && body + 16 <= buffer.length) {
+      if (buffer.readUInt16LE(body) !== PCM_FORMAT) return null;
+      fmt = {
+        numChannels: buffer.readUInt16LE(body + 2),
+        sampleRate: buffer.readUInt32LE(body + 4),
+        bitsPerSample: buffer.readUInt16LE(body + 14)
+      };
+    } else if (chunkId === "data") {
+      data = { offset: body, size: Math.min(chunkSize, buffer.length - body) };
+    }
+    offset = body + chunkSize + chunkSize % 2;
+  }
+  if (!fmt || !data) return null;
+  if (fmt.bitsPerSample !== SUPPORTED_BITS || fmt.numChannels < 1) return null;
+  return {
+    numChannels: fmt.numChannels,
+    sampleRate: fmt.sampleRate,
+    dataOffset: data.offset,
+    dataSize: data.size
+  };
+}
+function toRelativeEnvelope(keyframes, trackStart, baseVolume) {
+  const points = keyframes.filter((k2) => Number.isFinite(k2.time) && Number.isFinite(k2.volume)).map((k2) => ({
+    time: Math.max(0, k2.time - trackStart),
+    volume: Math.max(0, Math.min(1, k2.volume))
+  })).sort((a, b2) => a.time - b2.time);
+  const deduped = [];
+  for (const point of points) {
+    const previous = deduped.at(-1);
+    if (previous && Math.abs(previous.time - point.time) < 1e-9) previous.volume = point.volume;
+    else deduped.push(point);
+  }
+  if (deduped.length === 0) return deduped;
+  if (deduped[0].time > 0) {
+    deduped.unshift({ time: 0, volume: Math.max(0, Math.min(1, baseVolume)) });
+  }
+  return deduped;
+}
+function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
+  const envelope = toRelativeEnvelope(keyframes, trackStart, baseVolume);
+  if (envelope.length === 0) return false;
+  try {
+    const buffer = readFileSync22(wavPath);
+    const layout2 = parseWavLayout(buffer);
+    if (!layout2) return false;
+    const { numChannels, sampleRate, dataOffset, dataSize } = layout2;
+    const bytesPerSample = SUPPORTED_BITS / 8;
+    const frameBytes = numChannels * bytesPerSample;
+    const frameCount = Math.floor(dataSize / frameBytes);
+    let segment = 0;
+    for (let frame = 0; frame < frameCount; frame += 1) {
+      const time = frame / sampleRate;
+      while (segment < envelope.length - 2 && time >= envelope[segment + 1].time) segment += 1;
+      const a = envelope[segment];
+      const b2 = envelope[segment + 1] ?? a;
+      const span = b2.time - a.time;
+      const progress = span <= 0 ? 0 : Math.min(1, Math.max(0, (time - a.time) / span));
+      const gain = a.volume + (b2.volume - a.volume) * progress;
+      const base = dataOffset + frame * frameBytes;
+      for (let channel = 0; channel < numChannels; channel += 1) {
+        const at3 = base + channel * bytesPerSample;
+        const scaled = Math.round(buffer.readInt16LE(at3) * gain);
+        buffer.writeInt16LE(scaled < -32768 ? -32768 : scaled > 32767 ? 32767 : scaled, at3);
+      }
+    }
+    const tempPath = `${wavPath}.${randomBytes(6).toString("hex")}.tmp`;
+    writeFileSync14(tempPath, buffer);
+    renameSync3(tempPath, wavPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PCM_FORMAT, SUPPORTED_BITS;
+var init_audioVolumeEnvelope = __esm({
+  "../engine/src/services/audioVolumeEnvelope.ts"() {
+    "use strict";
+    PCM_FORMAT = 1;
+    SUPPORTED_BITS = 16;
+  }
+});
+
 // ../engine/src/services/audioMixer.ts
 import { existsSync as existsSync27, mkdirSync as mkdirSync16, rmSync as rmSync6 } from "fs";
 import { isAbsolute as isAbsolute6, join as join29, dirname as dirname10 } from "path";
@@ -66732,10 +67034,47 @@ function formatFilterNumber(value) {
 function escapeExpressionCommas(expression) {
   return expression.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
 }
-function buildVolumeExpression(track) {
+function simplifyVolumeKeyframes(keyframes) {
+  if (keyframes.length < 3) return keyframes;
+  const keep = new Array(keyframes.length).fill(false);
+  keep[0] = true;
+  keep[keyframes.length - 1] = true;
+  const stack = [[0, keyframes.length - 1]];
+  while (stack.length > 0) {
+    const [startIndex, endIndex] = stack.pop();
+    const start = keyframes[startIndex];
+    const end = keyframes[endIndex];
+    const span = end.time - start.time;
+    let maxDistance = VOLUME_SIMPLIFY_EPSILON;
+    let splitIndex = -1;
+    for (let i2 = startIndex + 1; i2 < endIndex; i2 += 1) {
+      const point = keyframes[i2];
+      const interpolated = span === 0 ? start.volume : start.volume + (end.volume - start.volume) * (point.time - start.time) / span;
+      const distance = Math.abs(point.volume - interpolated);
+      if (distance > maxDistance) {
+        maxDistance = distance;
+        splitIndex = i2;
+      }
+    }
+    if (splitIndex !== -1) {
+      keep[splitIndex] = true;
+      stack.push([startIndex, splitIndex], [splitIndex, endIndex]);
+    }
+  }
+  const simplified = keyframes.filter((_, i2) => keep[i2]);
+  if (simplified.length <= MAX_VOLUME_SEGMENTS) return simplified;
+  const step = (simplified.length - 1) / (MAX_VOLUME_SEGMENTS - 1);
+  const sampled = [];
+  for (let i2 = 0; i2 < MAX_VOLUME_SEGMENTS; i2 += 1) {
+    const point = simplified[Math.round(i2 * step)];
+    if (sampled.length === 0 || point.time > sampled.at(-1).time) sampled.push(point);
+  }
+  return sampled;
+}
+function buildVolumeExpression(track, ignoreKeyframes = false) {
   const trimDuration = track.end - track.start;
   const staticVolume = clampVolume(track.volume);
-  const keyframes = (track.volumeKeyframes ?? []).filter((keyframe) => Number.isFinite(keyframe.time) && Number.isFinite(keyframe.volume)).map((keyframe) => ({
+  const keyframes = (ignoreKeyframes ? [] : track.volumeKeyframes ?? []).filter((keyframe) => Number.isFinite(keyframe.time) && Number.isFinite(keyframe.volume)).map((keyframe) => ({
     time: Math.max(0, Math.min(trimDuration, keyframe.time - track.start)),
     volume: clampVolume(keyframe.volume)
   })).sort((a, b2) => a.time - b2.time);
@@ -66752,13 +67091,14 @@ function buildVolumeExpression(track) {
       deduped.push(keyframe);
     }
   }
-  if (deduped.length === 1) {
-    return `volume=${formatFilterNumber(deduped[0].volume)}`;
+  const simplified = simplifyVolumeKeyframes(deduped);
+  if (simplified.length === 1) {
+    return `volume=${formatFilterNumber(simplified[0].volume)}`;
   }
-  let expression = formatFilterNumber(deduped.at(-1).volume);
-  for (let i2 = deduped.length - 2; i2 >= 0; i2 -= 1) {
-    const current = deduped[i2];
-    const next = deduped[i2 + 1];
+  let expression = formatFilterNumber(simplified.at(-1).volume);
+  for (let i2 = simplified.length - 2; i2 >= 0; i2 -= 1) {
+    const current = simplified[i2];
+    const next = simplified[i2 + 1];
     const currentTime = formatFilterNumber(current.time);
     const nextTime = formatFilterNumber(next.time);
     const currentVolume = formatFilterNumber(current.volume);
@@ -66926,38 +67266,49 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
   }
   const outputDir = dirname10(outputPath);
   if (!existsSync27(outputDir)) mkdirSync16(outputDir, { recursive: true });
-  const inputs = [];
-  const filterParts = [];
-  tracks.forEach((track, i2) => {
-    inputs.push("-i", track.srcPath);
-    const delayMs = Math.round(track.start * 1e3);
-    const trimDuration = track.end - track.start;
-    const volumeFilter = buildVolumeExpression(track);
-    filterParts.push(
-      `[${i2}:a]atrim=0:${trimDuration},${volumeFilter},adelay=${delayMs}|${delayMs},apad=whole_dur=${totalDuration}[a${i2}]`
-    );
-  });
-  const mixInputs = tracks.map((_, i2) => `[a${i2}]`).join("");
-  const weights = tracks.map(() => "1").join(" ");
-  const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0:normalize=0:weights='${weights}'[mixed]`;
-  const postMixGainFilter = `[mixed]volume=${masterOutputGain}[out]`;
-  const fullFilter = [...filterParts, mixFilter, postMixGainFilter].join(";");
-  const args = [
-    ...inputs,
-    "-filter_complex",
-    fullFilter,
-    "-map",
-    "[out]",
-    "-acodec",
-    "aac",
-    "-b:a",
-    "192k",
-    "-t",
-    String(totalDuration),
-    "-y",
-    outputPath
-  ];
-  const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
+  const buildArgs = (ignoreAutomation) => {
+    const inputs = [];
+    const filterParts = [];
+    tracks.forEach((track, i2) => {
+      inputs.push("-i", track.srcPath);
+      const delayMs = Math.round(track.start * 1e3);
+      const trimDuration = track.end - track.start;
+      const volumeFilter = buildVolumeExpression(track, ignoreAutomation);
+      filterParts.push(
+        `[${i2}:a]atrim=0:${trimDuration},${volumeFilter},adelay=${delayMs}|${delayMs},apad=whole_dur=${totalDuration}[a${i2}]`
+      );
+    });
+    const mixInputs = tracks.map((_, i2) => `[a${i2}]`).join("");
+    const weights = tracks.map(() => "1").join(" ");
+    const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0:normalize=0:weights='${weights}'[mixed]`;
+    const postMixGainFilter = `[mixed]volume=${masterOutputGain}[out]`;
+    const fullFilter = [...filterParts, mixFilter, postMixGainFilter].join(";");
+    return [
+      ...inputs,
+      "-filter_complex",
+      fullFilter,
+      "-map",
+      "[out]",
+      "-acodec",
+      "aac",
+      "-b:a",
+      "192k",
+      "-t",
+      String(totalDuration),
+      "-y",
+      outputPath
+    ];
+  };
+  let result = await runFfmpeg(buildArgs(false), { signal, timeout: ffmpegProcessTimeout });
+  let degradedAutomation = false;
+  const hasAutomation = tracks.some((track) => (track.volumeKeyframes?.length ?? 0) > 0);
+  if (!result.success && !signal?.aborted && hasAutomation) {
+    const retry = await runFfmpeg(buildArgs(true), { signal, timeout: ffmpegProcessTimeout });
+    if (retry.success) {
+      result = retry;
+      degradedAutomation = true;
+    }
+  }
   if (signal?.aborted) {
     return {
       success: false,
@@ -66980,7 +67331,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
     success: true,
     outputPath,
     durationMs: result.durationMs,
-    tracksProcessed: tracks.length
+    tracksProcessed: tracks.length,
+    error: degradedAutomation ? "Volume automation exceeded this ffmpeg build's expression limits; rendered at base volume" : void 0
   };
 }
 async function processCompositionAudio(elements, baseDir, workDir, outputPath, totalDuration, signal, config, compiledDir) {
@@ -67052,6 +67404,15 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = trimmedPath;
         }
+        let bakedEnvelope = false;
+        if (element.volumeKeyframes && element.volumeKeyframes.length > 0) {
+          bakedEnvelope = applyVolumeEnvelopeToWav(
+            audioSrcPath,
+            element.volumeKeyframes,
+            element.start,
+            element.volume ?? 1
+          );
+        }
         tracks.push({
           id: element.id,
           srcPath: audioSrcPath,
@@ -67059,8 +67420,9 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           end: element.end,
           mediaStart: element.mediaStart,
           duration: element.end - element.start,
-          volume: element.volume ?? 1,
-          volumeKeyframes: element.volumeKeyframes
+          // Gain is already in the samples when baked, so mix at unity.
+          volume: bakedEnvelope ? 1 : element.volume ?? 1,
+          volumeKeyframes: bakedEnvelope ? void 0 : element.volumeKeyframes
         });
       } catch (err) {
         errors.push(`Error: ${element.id} \u2014 ${err instanceof Error ? err.message : String(err)}`);
@@ -67078,6 +67440,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     error: errors.length > 0 ? `Warnings: ${errors.join(", ")}` : mixResult.error
   };
 }
+var MAX_VOLUME_SEGMENTS, VOLUME_SIMPLIFY_EPSILON;
 var init_audioMixer = __esm({
   "../engine/src/services/audioMixer.ts"() {
     "use strict";
@@ -67088,6 +67451,9 @@ var init_audioMixer = __esm({
     init_runFfmpeg();
     init_htmlTemplate();
     init_videoFrameExtractor();
+    init_audioVolumeEnvelope();
+    MAX_VOLUME_SEGMENTS = 32;
+    VOLUME_SIMPLIFY_EPSILON = 5e-3;
   }
 });
 
@@ -67400,7 +67766,7 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync22, existsSync as existsSync29, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync29, statSync as statSync9 } from "fs";
 import { join as join31, extname as extname7 } from "path";
 function createFileServer(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
@@ -67422,11 +67788,11 @@ function createFileServer(options) {
     const ext = extname7(filePath).toLowerCase();
     const contentType = MIME_TYPES2[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync22(filePath, "utf-8");
+      const rawHtml = readFileSync23(filePath, "utf-8");
       const html = relativePath === "index.html" ? injectScriptsIntoHtml(rawHtml, headScripts, bodyScripts, stripEmbeddedRuntime) : rawHtml;
       return c3.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync22(filePath);
+    const content = readFileSync23(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -69145,7 +69511,7 @@ __export(deterministicFonts_exports, {
   iterateFontFamilyDeclarations: () => iterateFontFamilyDeclarations,
   parseFontFamilyValue: () => parseFontFamilyValue
 });
-import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir8, tmpdir as tmpdir3 } from "os";
 import { join as join33 } from "path";
 function parseFontFamilyValue(value) {
@@ -69329,7 +69695,7 @@ async function fetchGoogleFont(familyName, options) {
           continue;
         }
         const buffer = Buffer.from(await fontRes.arrayBuffer());
-        writeFileSync14(cachePath2, buffer);
+        writeFileSync15(cachePath2, buffer);
       } catch (err) {
         if (err instanceof FontFetchError) throw err;
         if (options.failClosedFontFetch) {
@@ -69338,7 +69704,7 @@ async function fetchGoogleFont(familyName, options) {
         continue;
       }
     }
-    const fontBytes = readFileSync23(cachePath2);
+    const fontBytes = readFileSync24(cachePath2);
     const dataUri = `data:font/woff2;base64,${fontBytes.toString("base64")}`;
     faces.push({ weight, style, dataUri });
   }
@@ -69538,7 +69904,7 @@ var init_deterministicFonts = __esm({
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync32, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync25 } from "fs";
 import { dirname as dirname11, resolve as resolve16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
@@ -69567,7 +69933,7 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync24(manifestPath, "utf8");
+  const manifestRaw = readFileSync25(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -69579,7 +69945,7 @@ function resolveVerifiedHyperframeRuntime() {
   if (!existsSync32(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync24(runtimePath, "utf8");
+  const runtimeSource = readFileSync25(runtimePath, "utf8");
   const runtimeSha = createHash6("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -69618,7 +69984,7 @@ var init_hyperframeRuntimeLoader = __esm({
 // ../producer/src/services/fileServer.ts
 import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { readFileSync as readFileSync25, existsSync as existsSync33, realpathSync, statSync as statSync10 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync33, realpathSync, statSync as statSync10 } from "fs";
 import { join as join34, extname as extname8, resolve as resolve17, sep as sep5 } from "path";
 function isPathInside(child, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
@@ -69813,7 +70179,7 @@ function createFileServer2(options) {
     const ext = extname8(filePath).toLowerCase();
     const contentType = MIME_TYPES3[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync25(filePath, "utf-8");
+      const rawHtml = readFileSync26(filePath, "utf-8");
       const isIndex = relativePath === "index.html";
       let html = rawHtml;
       if (preHeadScripts.length > 0) {
@@ -69822,7 +70188,7 @@ function createFileServer2(options) {
       html = isIndex ? injectScriptsIntoHtml(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
       return c3.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync25(filePath);
+    const content = readFileSync26(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -70169,7 +70535,7 @@ var init_paths = __esm({
 });
 
 // ../producer/src/services/render/shared.ts
-import { copyFileSync as copyFileSync2, cpSync, existsSync as existsSync34, mkdirSync as mkdirSync19, symlinkSync, writeFileSync as writeFileSync15 } from "fs";
+import { copyFileSync as copyFileSync2, cpSync, existsSync as existsSync34, mkdirSync as mkdirSync19, symlinkSync, writeFileSync as writeFileSync16 } from "fs";
 import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute7, join as join36, relative as relative5, resolve as resolve18 } from "path";
 function projectBrowserEndToCompositionTimeline(existingStart, browserStart, browserEnd) {
   return browserEnd + (existingStart - browserStart);
@@ -70208,11 +70574,11 @@ function resolveDeviceScaleFactor(input2) {
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
   const compileDir = join36(workDir, "compiled");
   mkdirSync19(compileDir, { recursive: true });
-  writeFileSync15(join36(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync16(join36(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
     const outPath = join36(compileDir, srcPath);
     mkdirSync19(dirname12(outPath), { recursive: true });
-    writeFileSync15(outPath, html, "utf-8");
+    writeFileSync16(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
     const outPath = resolve18(join36(compileDir, relativePath));
@@ -70246,7 +70612,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       renderModeHints: compiled.renderModeHints,
       hasShaderTransitions: compiled.hasShaderTransitions
     };
-    writeFileSync15(join36(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync16(join36(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(alreadyForced, compiled, log2 = defaultLogger) {
@@ -70926,7 +71292,7 @@ var init_urlDownloader2 = __esm({
 });
 
 // ../producer/src/services/htmlCompiler.ts
-import { readFileSync as readFileSync26, existsSync as existsSync35, mkdirSync as mkdirSync20 } from "fs";
+import { readFileSync as readFileSync27, existsSync as existsSync35, mkdirSync as mkdirSync20 } from "fs";
 import { join as join38, dirname as dirname13, resolve as resolve19 } from "path";
 function dedupeElementsById(elements) {
   const deduped = /* @__PURE__ */ new Map();
@@ -71084,7 +71450,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (!existsSync35(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync26(filePath, "utf-8");
+    const rawSubHtml = readFileSync27(filePath, "utf-8");
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, absoluteStart, absoluteEnd, filePath, rawSubHtml, nestedVisited });
@@ -71270,7 +71636,7 @@ function inlineSubCompositions2(html, subCompositions, projectDir) {
         if (!compHtml) {
           const filePath = resolve19(projectDir, srcPath);
           if (existsSync35(filePath)) {
-            compHtml = readFileSync26(filePath, "utf-8");
+            compHtml = readFileSync27(filePath, "utf-8");
           }
         }
         return compHtml;
@@ -71428,9 +71794,9 @@ function collectExternalAssets(html, projectDir) {
       return null;
     }
     if (!existsSync35(absPath)) return null;
-    const safeKey = toExternalAssetKey(absPath);
-    externalAssets.set(safeKey, absPath);
-    return safeKey;
+    const safeKey2 = toExternalAssetKey(absPath);
+    externalAssets.set(safeKey2, absPath);
+    return safeKey2;
   }
   const { document: document2 } = parseHTML(html);
   for (const el of document2.querySelectorAll("[src], [href]")) {
@@ -71486,7 +71852,7 @@ function rewriteUnresolvableGsapToCdn(html, projectDir) {
   );
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
-  const rawHtml = rewriteUnresolvableGsapToCdn(readFileSync26(htmlPath, "utf-8"), projectDir);
+  const rawHtml = rewriteUnresolvableGsapToCdn(readFileSync27(htmlPath, "utf-8"), projectDir);
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
@@ -72727,7 +73093,7 @@ var init_hdrImageTransferCache = __esm({
 });
 
 // ../producer/src/services/render/stages/captureHdrResources.ts
-import { mkdirSync as mkdirSync21, openSync, readFileSync as readFileSync27, statSync as statSync11 } from "fs";
+import { mkdirSync as mkdirSync21, openSync, readFileSync as readFileSync28, statSync as statSync11 } from "fs";
 import { join as join43 } from "path";
 function planHdrResources(args) {
   const { composition, nativeHdrVideoIds, nativeHdrImageIds, projectDir, compiledDir } = args;
@@ -72872,7 +73238,7 @@ function decodeHdrImageBuffers(args) {
   const out = /* @__PURE__ */ new Map();
   for (const [imageId, srcPath] of hdrImageSrcPaths) {
     try {
-      const decoded = decodePngToRgb48le(readFileSync27(srcPath));
+      const decoded = decodePngToRgb48le(readFileSync28(srcPath));
       const layout2 = prep.hdrExtractionDims.get(imageId);
       const fitInfo = prep.hdrImageFitInfo.get(imageId);
       if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
@@ -73143,7 +73509,7 @@ var init_captureHdrFrameShared = __esm({
 });
 
 // ../producer/src/services/render/stages/captureHdrSequentialLoop.ts
-import { writeFileSync as writeFileSync16 } from "fs";
+import { writeFileSync as writeFileSync17 } from "fs";
 import { join as join44 } from "path";
 async function runSequentialLayeredFrameLoop(input2) {
   const {
@@ -73264,7 +73630,7 @@ async function runSequentialLayeredFrameLoop(input2) {
       await compositeHdrFrame(hdrCompositeCtx, normalCanvas, time, stackingInfo, void 0, i2);
       addHdrTiming(hdrPerf, "normalCompositeMs", timingStart);
       if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-        writeFileSync16(
+        writeFileSync17(
           join44(debugDumpDir, `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
@@ -73494,7 +73860,7 @@ var init_shaderTransitionWorkerPool = __esm({
 });
 
 // ../producer/src/services/render/stages/captureHdrHybridLoop.ts
-import { writeFileSync as writeFileSync17 } from "fs";
+import { writeFileSync as writeFileSync18 } from "fs";
 import { join as join46 } from "path";
 async function runHybridLayeredFrameLoop(input2) {
   const {
@@ -73689,7 +74055,7 @@ async function runHybridLayeredFrameLoop(input2) {
           await compositeHdrFrame(wctx, canvas, time, stackingInfo, void 0, i2);
           addHdrTiming(hdrPerf, "normalCompositeMs", timingStart);
           if (debugDumpEnabled && debugDumpDir && i2 % 30 === 0) {
-            writeFileSync17(
+            writeFileSync18(
               join46(debugDumpDir, `frame_${String(i2).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
@@ -74189,13 +74555,13 @@ var init_assembleStage = __esm({
 import {
   existsSync as existsSync40,
   mkdirSync as mkdirSync24,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   readSync,
   closeSync,
   readdirSync as readdirSync16,
   rmSync as rmSync9,
   statSync as statSync12,
-  writeFileSync as writeFileSync18,
+  writeFileSync as writeFileSync19,
   copyFileSync as copyFileSync4,
   appendFileSync
 } from "fs";
@@ -74796,7 +75162,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           const after2 = countNonZeroRgb48(canvas);
           const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
           const dumpPath = join49(debugDumpDir, dumpName);
-          writeFileSync18(dumpPath, domPng);
+          writeFileSync19(dumpPath, domPng);
           log2.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -74926,7 +75292,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync28(htmlPath, "utf-8");
+    const rawEntry = readFileSync29(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
       const wrapperPath = join49(workDir, "standalone-entry.html");
       const projectIndexPath = join49(projectDir, "index.html");
@@ -74936,7 +75302,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync28(projectIndexPath, "utf-8"),
+        readFileSync29(projectIndexPath, "utf-8"),
         entryFile
       );
       if (!standaloneHtml) {
@@ -74944,7 +75310,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync18(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync19(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log2.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -75331,7 +75697,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync18(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync19(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log2.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -75468,7 +75834,7 @@ var init_config3 = __esm({
 });
 
 // ../producer/src/services/hyperframeLint.ts
-import { existsSync as existsSync41, readFileSync as readFileSync29, statSync as statSync13 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync30, statSync as statSync13 } from "fs";
 import { resolve as resolve21, join as join50 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -75511,7 +75877,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (existsSync41(absoluteEntryPath) && statSync13(absoluteEntryPath).isFile()) {
       return {
         entryFile,
-        html: readFileSync29(absoluteEntryPath, "utf-8"),
+        html: readFileSync30(absoluteEntryPath, "utf-8"),
         source: "projectDir"
       };
     }
@@ -75610,7 +75976,7 @@ import {
   mkdirSync as mkdirSync25,
   statSync as statSync14,
   mkdtempSync as mkdtempSync2,
-  writeFileSync as writeFileSync19,
+  writeFileSync as writeFileSync20,
   rmSync as rmSync10,
   createReadStream
 } from "fs";
@@ -75669,7 +76035,7 @@ async function prepareRenderBody(body) {
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir4();
   const tempProjectDir = mkdtempSync2(join51(tempRoot, "producer-project-"));
-  writeFileSync19(join51(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  writeFileSync20(join51(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -76161,7 +76527,7 @@ var init_planHash = __esm({
 });
 
 // ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync30, readdirSync as readdirSync17, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync31, readdirSync as readdirSync17, writeFileSync as writeFileSync21 } from "fs";
 import { join as join52, relative as relative6, resolve as resolve23 } from "path";
 function stripUndefined(value) {
   if (Array.isArray(value)) return value.map(stripUndefined);
@@ -76204,11 +76570,11 @@ function collectPlanAssetShas(planDir) {
   const assets = [];
   for (const file of files) {
     if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync30(file.absolutePath);
+      compositionHtml = readFileSync31(file.absolutePath);
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
-    const bytes = readFileSync30(file.absolutePath);
+    const bytes = readFileSync31(file.absolutePath);
     assets.push({ path: file.planRelativePath, sha256: sha256Hex(bytes) });
   }
   if (compositionHtml === null) {
@@ -76227,8 +76593,8 @@ function recomputePlanHashFromPlanDir(planDir) {
   if (!existsSync43(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
-  const planJson = JSON.parse(readFileSync30(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync30(encoderJsonPath, "utf-8");
+  const planJson = JSON.parse(readFileSync31(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync31(encoderJsonPath, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir);
   return computePlanHash({
     compositionHtml,
@@ -76258,7 +76624,7 @@ async function freezePlan(input2) {
   }
   const metaDir = join52(planDir, "meta");
   if (!existsSync43(metaDir)) mkdirSync26(metaDir, { recursive: true });
-  writeFileSync20(
+  writeFileSync21(
     join52(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
@@ -76266,8 +76632,8 @@ async function freezePlan(input2) {
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync20(join52(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync20(join52(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync21(join52(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync21(join52(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir);
   const planHash = computePlanHash({
@@ -76291,7 +76657,7 @@ async function freezePlan(input2) {
     hasAudio
   };
   const planJsonPath = join52(planDir, "plan.json");
-  writeFileSync20(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+  writeFileSync21(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
 }
@@ -76399,7 +76765,7 @@ var init_runtimeEnvSnapshot = __esm({
 // ../producer/src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "child_process";
 import { dirname as dirname17, join as join53 } from "path";
-import { existsSync as existsSync44, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync32 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { promisify as promisify2 } from "util";
 async function readFfmpegVersion() {
@@ -76439,7 +76805,7 @@ function readProducerVersion() {
     const candidate = join53(current, "package.json");
     if (existsSync44(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync31(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync32(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
           cachedProducerVersion = pkg.version;
           return pkg.version;
@@ -76473,10 +76839,10 @@ import {
   existsSync as existsSync45,
   mkdirSync as mkdirSync27,
   readdirSync as readdirSync18,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   rmSync as rmSync11,
   statSync as statSync15,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync22
 } from "fs";
 import { join as join54, relative as relative7, sep as sep6 } from "path";
 function formatBytes(bytes) {
@@ -76756,12 +77122,12 @@ async function plan(projectDir, config, planDir) {
   const videoFramesDst = join54(planDir, "video-frames");
   if (existsSync45(videoFramesDst)) rmSync11(videoFramesDst, { recursive: true, force: true });
   if (existsSync45(stagedVideoFrames)) {
-    renameSync3(stagedVideoFrames, videoFramesDst);
+    renameSync4(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync27(videoFramesDst, { recursive: true });
   }
   if (existsSync45(finalCompiledDir)) rmSync11(finalCompiledDir, { recursive: true, force: true });
-  renameSync3(compiledDir, finalCompiledDir);
+  renameSync4(compiledDir, finalCompiledDir);
   const planVideosJson = {
     videos: composition.videos,
     extracted: (extractResult.extractionResult?.extracted ?? []).map((ext) => ({
@@ -76774,14 +77140,14 @@ async function plan(projectDir, config, planDir) {
     }))
   };
   mkdirSync27(join54(planDir, "meta"), { recursive: true });
-  writeFileSync21(
+  writeFileSync22(
     join54(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
   const planAudioPath = join54(planDir, "audio.aac");
   if (audioResult.hasAudio && existsSync45(audioResult.audioOutputPath)) {
-    renameSync3(audioResult.audioOutputPath, planAudioPath);
+    renameSync4(audioResult.audioOutputPath, planAudioPath);
   }
   const maxParallel = config.maxParallelChunks ?? DEFAULT_MAX_PARALLEL_CHUNKS;
   const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
@@ -76918,8 +77284,8 @@ var init_plan = __esm({
 });
 
 // ../producer/src/services/distributed/renderChunk.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync46, mkdirSync as mkdirSync28, readFileSync as readFileSync32, readdirSync as readdirSync19, rmSync as rmSync12, writeFileSync as writeFileSync22 } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync46, mkdirSync as mkdirSync28, readFileSync as readFileSync33, readdirSync as readdirSync19, rmSync as rmSync12, writeFileSync as writeFileSync23 } from "fs";
 import { extname as extname9, join as join55 } from "path";
 function rebuildExtractedFramesFromPlanDir(planDir, videos) {
   const result = [];
@@ -76958,10 +77324,10 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos) {
   return result;
 }
 function hashChunkOutput(outputPath, kind) {
-  if (kind === "file") return sha256Hex(readFileSync32(outputPath));
+  if (kind === "file") return sha256Hex(readFileSync33(outputPath));
   const entries2 = readdirSync19(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries2.map(
-    (name) => `${name}\0${sha256Hex(readFileSync32(join55(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync33(join55(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -76985,14 +77351,14 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       );
     }
   }
-  const plan2 = JSON.parse(readFileSync32(planJsonPath, "utf-8"));
-  const encoder = JSON.parse(readFileSync32(encoderJsonPath, "utf-8"));
-  const chunks = JSON.parse(readFileSync32(chunksJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync33(planJsonPath, "utf-8"));
+  const encoder = JSON.parse(readFileSync33(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync33(chunksJsonPath, "utf-8"));
   const videosJsonPath = join55(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync46(videosJsonPath)) {
     try {
-      planVideos = JSON.parse(readFileSync32(videosJsonPath, "utf-8"));
+      planVideos = JSON.parse(readFileSync33(videosJsonPath, "utf-8"));
     } catch (err) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
@@ -77074,7 +77440,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         rebuildExtractedFramesFromPlanDir(planDir, planVideos.extracted)
       )
     ) : null;
-    const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
+    const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes2(4).toString("hex")}`;
     mkdirSync28(workDir, { recursive: true });
     const framesDir = join55(workDir, "captured-frames");
     mkdirSync28(framesDir, { recursive: true });
@@ -77205,7 +77571,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       producerVersion: plan2.producerVersion,
       ffmpegVersion
     };
-    writeFileSync22(perfPath, `${JSON.stringify(perfPayload2, null, 2)}
+    writeFileSync23(perfPath, `${JSON.stringify(perfPayload2, null, 2)}
 `, "utf-8");
     try {
       rmSync12(workDir, { recursive: true, force: true });
@@ -77468,11 +77834,11 @@ import {
   cpSync as cpSync3,
   existsSync as existsSync47,
   mkdirSync as mkdirSync29,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   readdirSync as readdirSync20,
   rmSync as rmSync13,
   statSync as statSync16,
-  writeFileSync as writeFileSync23
+  writeFileSync as writeFileSync24
 } from "fs";
 import { dirname as dirname18, join as join56 } from "path";
 async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
@@ -77488,8 +77854,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   if (!existsSync47(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync33(planJsonPath, "utf-8"));
-  const chunks = JSON.parse(readFileSync33(chunksJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync34(planJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync34(chunksJsonPath, "utf-8"));
   if (chunkPaths.length !== chunks.length) {
     throw new Error(
       `[assemble] chunkPaths length (${chunkPaths.length}) does not match chunks.json length (${chunks.length}). Adapters must pass one path per chunk, ordered by index.`
@@ -77526,7 +77892,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     } else {
       const concatListPath = join56(workDir, "concat-list.txt");
       const concatBody = chunkPaths.map((path2) => `file '${path2.replace(/'/g, "'\\''")}'`).join("\n");
-      writeFileSync23(concatListPath, `${concatBody}
+      writeFileSync24(concatListPath, `${concatBody}
 `, "utf-8");
       const concatArgs = [
         "-r",
@@ -77560,7 +77926,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       if (!existsSync47(encoderJsonPath)) {
         throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
       }
-      const encoderJson = JSON.parse(readFileSync33(encoderJsonPath, "utf-8"));
+      const encoderJson = JSON.parse(readFileSync34(encoderJsonPath, "utf-8"));
       if (encoderJson.encoder === "libx265-software") {
         throw new Error(
           `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`
@@ -77821,7 +78187,7 @@ __export(studioServer_exports, {
 });
 import { Hono as Hono5 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { existsSync as existsSync48, readFileSync as readFileSync34, writeFileSync as writeFileSync24, statSync as statSync17 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync35, writeFileSync as writeFileSync25, statSync as statSync17 } from "fs";
 import { resolve as resolve24, join as join57, basename as basename5 } from "path";
 function resolveDistDir() {
   return resolveStudioBundle().dir;
@@ -77870,7 +78236,7 @@ function readStudioManualEditManifestContent(projectDir) {
   const manifestPath = join57(projectDir, STUDIO_MANUAL_EDITS_PATH2);
   if (!existsSync48(manifestPath)) return "";
   try {
-    return readFileSync34(manifestPath, "utf-8");
+    return readFileSync35(manifestPath, "utf-8");
   } catch {
     return "";
   }
@@ -77935,7 +78301,7 @@ async function closeThumbnailBrowser() {
 async function loadPreviewServerBuildSignature() {
   const runtimeSignature = await loadRuntimeSourceSignature();
   const studioBundle = resolveStudioBundle();
-  const studioIndex = studioBundle.available && existsSync48(studioBundle.indexPath) ? readFileSync34(studioBundle.indexPath, "utf-8") : "";
+  const studioIndex = studioBundle.available && existsSync48(studioBundle.indexPath) ? readFileSync35(studioBundle.indexPath, "utf-8") : "";
   return hashSignatureParts([
     VERSION,
     runtimeSignature,
@@ -78029,7 +78395,7 @@ function createStudioServer(options) {
           state.status = "complete";
           state.progress = 100;
           const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-          writeFileSync24(
+          writeFileSync25(
             metaPath,
             JSON.stringify({ status: "complete", durationMs: Date.now() - startTime })
           );
@@ -78040,7 +78406,7 @@ function createStudioServer(options) {
           emitStudioRenderError(opts, Date.now() - startTime, state.stage, err);
           try {
             const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
-            writeFileSync24(metaPath, JSON.stringify({ status: "failed" }));
+            writeFileSync25(metaPath, JSON.stringify({ status: "failed" }));
           } catch {
           }
         }
@@ -78125,19 +78491,19 @@ function createStudioServer(options) {
     async installRegistryBlock(opts) {
       const { resolveItem: resolveItem2 } = await Promise.resolve().then(() => (init_resolver(), resolver_exports));
       const { installItem: installItem2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
-      const { readFileSync: readFileSync57, writeFileSync: writeFileSync39, existsSync: existsSync81 } = await import("fs");
+      const { readFileSync: readFileSync58, writeFileSync: writeFileSync40, existsSync: existsSync81 } = await import("fs");
       const { join: join91 } = await import("path");
       const item = await resolveItem2(opts.blockName);
       const { written } = await installItem2(item, { destDir: opts.project.dir });
       const indexPath = join91(opts.project.dir, "index.html");
       if (existsSync81(indexPath)) {
-        const indexHtml = readFileSync57(indexPath, "utf-8");
+        const indexHtml = readFileSync58(indexPath, "utf-8");
         const hostW = indexHtml.match(/data-width="(\d+)"/)?.[1];
         const hostH = indexHtml.match(/data-height="(\d+)"/)?.[1];
         if (hostW && hostH) {
           for (const absPath of written) {
             if (!absPath.endsWith(".html")) continue;
-            let content = readFileSync57(absPath, "utf-8");
+            let content = readFileSync58(absPath, "utf-8");
             content = content.replace(
               /(<meta\s+name="viewport"\s+content="width=)\d+(,\s*height=)\d+/i,
               `$1${hostW}$2${hostH}`
@@ -78151,7 +78517,7 @@ function createStudioServer(options) {
                 return match;
               }
             );
-            writeFileSync39(absPath, content, "utf-8");
+            writeFileSync40(absPath, content, "utf-8");
           }
         }
       }
@@ -78178,7 +78544,7 @@ function createStudioServer(options) {
   });
   app.get("/api/runtime.js", (c3) => {
     const serve4 = async () => {
-      const runtimeSource = await loadRuntimeSource() ?? (existsSync48(runtimePath) ? readFileSync34(runtimePath, "utf-8") : null);
+      const runtimeSource = await loadRuntimeSource() ?? (existsSync48(runtimePath) ? readFileSync35(runtimePath, "utf-8") : null);
       if (!runtimeSource) return c3.text("runtime not available", 404);
       return c3.body(runtimeSource, 200, {
         "Content-Type": "text/javascript",
@@ -78226,7 +78592,7 @@ function createStudioServer(options) {
   const serveStudioStaticFile = (c3) => {
     const filePath = resolve24(studioDir, c3.req.path.slice(1));
     if (!existsSync48(filePath) || !statSync17(filePath).isFile()) return c3.text("not found", 404);
-    const content = readFileSync34(filePath);
+    const content = readFileSync35(filePath);
     return new Response(content, {
       headers: { "Content-Type": getMimeType(filePath), "Cache-Control": "no-store" }
     });
@@ -78302,7 +78668,7 @@ function createStudioServer(options) {
         500
       );
     }
-    let html = readFileSync34(indexPath, "utf-8");
+    let html = readFileSync35(indexPath, "utf-8");
     const envScript = buildRuntimeEnvScript();
     if (envScript) {
       html = html.replace("<head>", `<head>${envScript}`);
@@ -78817,8 +79183,8 @@ import {
   mkdirSync as mkdirSync31,
   copyFileSync as copyFileSync5,
   cpSync as cpSync4,
-  writeFileSync as writeFileSync25,
-  readFileSync as readFileSync35,
+  writeFileSync as writeFileSync26,
+  readFileSync as readFileSync36,
   readdirSync as readdirSync21
 } from "fs";
 import { resolve as resolve26, basename as basename7, join as join59, dirname as dirname20 } from "path";
@@ -78922,7 +79288,7 @@ function buildPackageScripts() {
 function writeDefaultPackageJson(destDir, projectName) {
   const packageJsonPath = resolve26(destDir, "package.json");
   if (existsSync50(packageJsonPath)) return;
-  writeFileSync25(
+  writeFileSync26(
     packageJsonPath,
     `${JSON.stringify(
       {
@@ -78983,14 +79349,14 @@ ${html}`;
 }
 function writeTailwindSupport(destDir) {
   for (const file of listHtmlFiles(destDir)) {
-    const html = readFileSync35(file, "utf-8");
-    writeFileSync25(file, injectTailwindBrowserScript(html), "utf-8");
+    const html = readFileSync36(file, "utf-8");
+    writeFileSync26(file, injectTailwindBrowserScript(html), "utf-8");
   }
 }
 function patchVideoSrc(dir, videoFilename, durationSeconds) {
   const htmlFiles = readdirSync21(dir, { withFileTypes: true, recursive: true }).filter((e3) => e3.isFile() && e3.name.endsWith(".html")).map((e3) => join59(e3.parentPath, e3.name));
   for (const file of htmlFiles) {
-    let content = readFileSync35(file, "utf-8");
+    let content = readFileSync36(file, "utf-8");
     if (videoFilename) {
       content = content.replaceAll("__VIDEO_SRC__", videoFilename);
     } else {
@@ -79001,7 +79367,7 @@ function patchVideoSrc(dir, videoFilename, durationSeconds) {
     }
     const dur = durationSeconds ? String(Math.round(durationSeconds * 100) / 100) : "10";
     content = content.replaceAll("__VIDEO_DURATION__", dur);
-    writeFileSync25(file, content, "utf-8");
+    writeFileSync26(file, content, "utf-8");
   }
 }
 async function patchTranscript(dir, transcriptPath) {
@@ -79095,7 +79461,7 @@ async function handleVideoFile(videoPath, destDir, interactive) {
 function applyResolutionPreset(destDir, resolution) {
   const { width, height } = CANVAS_DIMENSIONS[resolution];
   for (const file of listHtmlFiles(destDir)) {
-    let html = readFileSync35(file, "utf-8");
+    let html = readFileSync36(file, "utf-8");
     let changed = false;
     const dataWidthRe = /(data-width=)["'](\d+)["']/g;
     if (dataWidthRe.test(html)) {
@@ -79137,7 +79503,7 @@ function applyResolutionPreset(destDir, resolution) {
       html = html.replace(viewportRe, `$1width=${width}, height=${height}`);
       changed = true;
     }
-    if (changed) writeFileSync25(file, html, "utf-8");
+    if (changed) writeFileSync26(file, html, "utf-8");
   }
 }
 async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds, tailwind = false, resolution) {
@@ -79151,7 +79517,7 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
   patchVideoSrc(destDir, localVideoName, durationSeconds);
   if (tailwind) writeTailwindSupport(destDir);
   if (resolution) applyResolutionPreset(destDir, resolution);
-  writeFileSync25(
+  writeFileSync26(
     resolve26(destDir, "meta.json"),
     JSON.stringify(
       {
@@ -80090,7 +80456,7 @@ __export(play_exports, {
   default: () => play_default,
   examples: () => examples5
 });
-import { existsSync as existsSync53, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync37 } from "fs";
 import { resolve as resolve30, dirname as dirname21 } from "path";
 function commandDir() {
   return dirname21(new URL(import.meta.url).pathname);
@@ -80257,13 +80623,13 @@ var init_play = __esm({
         const { createAdaptorServer } = await import("@hono/node-server");
         const app = new Hono6();
         app.get("/player.js", (ctx) => {
-          return ctx.body(readFileSync36(playerPath, "utf-8"), 200, {
+          return ctx.body(readFileSync37(playerPath, "utf-8"), 200, {
             "Content-Type": "application/javascript",
             "Cache-Control": "no-cache"
           });
         });
         app.get("/runtime.js", (ctx) => {
-          return ctx.body(readFileSync36(runtimePath, "utf-8"), 200, {
+          return ctx.body(readFileSync37(runtimePath, "utf-8"), 200, {
             "Content-Type": "application/javascript",
             "Cache-Control": "no-cache"
           });
@@ -80273,7 +80639,7 @@ var init_play = __esm({
           const filePath = resolve30(project.dir, reqPath);
           if (!filePath.startsWith(project.dir)) return ctx.text("Forbidden", 403);
           if (!existsSync53(filePath)) return ctx.text("Not found", 404);
-          const content = readFileSync36(filePath, "utf-8");
+          const content = readFileSync37(filePath, "utf-8");
           if (filePath.endsWith(".html")) {
             const injected = injectRuntime(content);
             return ctx.html(injected);
@@ -80292,7 +80658,7 @@ var init_play = __esm({
             mp3: "audio/mpeg",
             wav: "audio/wav"
           };
-          return ctx.body(readFileSync36(filePath), 200, {
+          return ctx.body(readFileSync37(filePath), 200, {
             "Content-Type": types4[ext] ?? "application/octet-stream"
           });
         });
@@ -80354,7 +80720,7 @@ var init_play = __esm({
 
 // src/utils/publishProject.ts
 import { basename as basename9, join as join60, relative as relative9 } from "path";
-import { readdirSync as readdirSync22, readFileSync as readFileSync37, statSync as statSync19 } from "fs";
+import { readdirSync as readdirSync22, readFileSync as readFileSync38, statSync as statSync19 } from "fs";
 import AdmZip from "adm-zip";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -80473,7 +80839,7 @@ function createPublishArchive(projectDir) {
   }
   const archive = new AdmZip();
   for (const filePath of filePaths) {
-    archive.addFile(filePath, readFileSync37(join60(projectDir, filePath)));
+    archive.addFile(filePath, readFileSync38(join60(projectDir, filePath)));
   }
   return {
     buffer: archive.toBuffer(),
@@ -80701,9 +81067,9 @@ var init_dom = __esm({
 });
 
 // src/utils/variables.ts
-import { readFileSync as readFileSync38 } from "fs";
+import { readFileSync as readFileSync39 } from "fs";
 import { resolve as resolve32 } from "path";
-function parseVariablesArg(inline, filePath, readFile = (p2) => readFileSync38(resolve32(p2), "utf8")) {
+function parseVariablesArg(inline, filePath, readFile = (p2) => readFileSync39(resolve32(p2), "utf8")) {
   if (inline != null && filePath != null) {
     return { ok: false, error: { kind: "conflict" } };
   }
@@ -80786,7 +81152,7 @@ function validateVariablesAgainstProject(indexPath, values) {
 function loadProjectVariableSchema(indexPath) {
   let html;
   try {
-    html = readFileSync38(indexPath, "utf8");
+    html = readFileSync39(indexPath, "utf8");
   } catch {
     return [];
   }
@@ -81050,7 +81416,7 @@ __export(render_exports, {
   renderLocal: () => renderLocal,
   resolveBrowserGpuForCli: () => resolveBrowserGpuForCli
 });
-import { mkdirSync as mkdirSync32, readdirSync as readdirSync23, readFileSync as readFileSync39, statSync as statSync20, writeFileSync as writeFileSync26, rmSync as rmSync14 } from "fs";
+import { mkdirSync as mkdirSync32, readdirSync as readdirSync23, readFileSync as readFileSync40, statSync as statSync20, writeFileSync as writeFileSync27, rmSync as rmSync14 } from "fs";
 import { cpus as cpus4, freemem as freemem4, tmpdir as tmpdir5 } from "os";
 import { resolve as resolve33, dirname as dirname22, join as join62, basename as basename11 } from "path";
 import { execFileSync as execFileSync6, spawn as spawn13 } from "child_process";
@@ -81111,7 +81477,7 @@ function ensureDockerImage(version, quiet) {
   const dockerfilePath = resolveDockerfilePath();
   const tmpDir = join62(tmpdir5(), `hyperframes-docker-${Date.now()}`);
   mkdirSync32(tmpDir, { recursive: true });
-  writeFileSync26(join62(tmpDir, "Dockerfile"), readFileSync39(dockerfilePath));
+  writeFileSync27(join62(tmpDir, "Dockerfile"), readFileSync40(dockerfilePath));
   try {
     execFileSync6(
       "docker",
@@ -81976,7 +82342,7 @@ var init_lint3 = __esm({
 
 // src/utils/staticProjectServer.ts
 import { createServer } from "http";
-import { existsSync as existsSync55, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync55, readFileSync as readFileSync41 } from "fs";
 import { isAbsolute as isAbsolute9, relative as relative10, resolve as resolve34 } from "path";
 async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Failed to bind local HTTP server") {
   const server = createServer((req, res) => {
@@ -81995,7 +82361,7 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
     }
     if (existsSync55(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType(filePath) });
-      res.end(readFileSync40(filePath));
+      res.end(readFileSync41(filePath));
       return;
     }
     res.writeHead(404);
@@ -82171,7 +82537,7 @@ __export(layout_exports, {
   default: () => layout_default,
   examples: () => examples9
 });
-import { existsSync as existsSync56, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync56, readFileSync as readFileSync42 } from "fs";
 import { dirname as dirname23, join as join63 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 async function getCompositionDuration2(page) {
@@ -82322,7 +82688,7 @@ function loadLayoutAuditScript() {
     join63(__dirname2, "commands", "layout-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync56(candidate)) return readFileSync41(candidate, "utf-8");
+    if (existsSync56(candidate)) return readFileSync42(candidate, "utf-8");
   }
   throw new Error("Missing layout audit browser script");
 }
@@ -82530,7 +82896,7 @@ __export(info_exports, {
   default: () => info_default,
   examples: () => examples11
 });
-import { readFileSync as readFileSync42, readdirSync as readdirSync24, statSync as statSync21 } from "fs";
+import { readFileSync as readFileSync43, readdirSync as readdirSync24, statSync as statSync21 } from "fs";
 import { join as join64 } from "path";
 function totalSize(dir) {
   let total = 0;
@@ -82567,7 +82933,7 @@ var init_info = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync42(project.indexPath, "utf-8");
+        const html = readFileSync43(project.indexPath, "utf-8");
         ensureDOMParser();
         const parsed = parseHtml(html);
         const tracks = new Set(parsed.elements.map((el) => el.zIndex));
@@ -82625,7 +82991,7 @@ __export(compositions_exports, {
   examples: () => examples12,
   parseSubComposition: () => parseSubComposition
 });
-import { existsSync as existsSync57, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync44 } from "fs";
 import { resolve as resolve35, dirname as dirname24 } from "path";
 function countRenderableDescendants(root) {
   return Array.from(root.querySelectorAll("*")).filter(
@@ -82660,7 +83026,7 @@ function parseCompositions(html, baseDir) {
     if (compositionSrc) {
       const subPath = resolve35(baseDir, compositionSrc);
       if (existsSync57(subPath)) {
-        const subHtml = readFileSync43(subPath, "utf-8");
+        const subHtml = readFileSync44(subPath, "utf-8");
         const subInfo = parseSubComposition(subHtml, id, width, height);
         compositions.push({ ...subInfo, source: compositionSrc });
         return;
@@ -82763,7 +83129,7 @@ var init_compositions = __esm({
       },
       async run({ args }) {
         const project = resolveProject(args.dir);
-        const html = readFileSync43(project.indexPath, "utf-8");
+        const html = readFileSync44(project.indexPath, "utf-8");
         ensureDOMParser();
         const compositions = parseCompositions(html, dirname24(project.indexPath));
         if (compositions.length === 0) {
@@ -83891,7 +84257,7 @@ __export(transcribe_exports2, {
   default: () => transcribe_default,
   examples: () => examples16
 });
-import { existsSync as existsSync61, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync61, writeFileSync as writeFileSync28 } from "fs";
 import { resolve as resolve38, join as join67, extname as extname11, dirname as dirname25 } from "path";
 async function importTranscript(inputPath, dir, json) {
   const { loadTranscript: loadTranscript2, patchCaptionHtml: patchCaptionHtml2 } = await Promise.resolve().then(() => (init_normalize(), normalize_exports));
@@ -83901,7 +84267,7 @@ async function importTranscript(inputPath, dir, json) {
     process.exit(1);
   }
   const outPath = join67(dir, "transcript.json");
-  writeFileSync27(outPath, JSON.stringify(words, null, 2));
+  writeFileSync28(outPath, JSON.stringify(words, null, 2));
   patchCaptionHtml2(dir, words);
   if (json) {
     console.log(
@@ -83936,7 +84302,7 @@ async function transcribeAudio(inputPath, dir, opts) {
         );
       }
     }
-    writeFileSync27(result.transcriptPath, JSON.stringify(words, null, 2));
+    writeFileSync28(result.transcriptPath, JSON.stringify(words, null, 2));
     patchCaptionHtml2(dir, words);
     if (opts.json) {
       console.log(
@@ -84144,7 +84510,7 @@ __export(synthesize_exports, {
   synthesize: () => synthesize
 });
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync63, writeFileSync as writeFileSync28, mkdirSync as mkdirSync35, readdirSync as readdirSync25, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync63, writeFileSync as writeFileSync29, mkdirSync as mkdirSync35, readdirSync as readdirSync25, unlinkSync as unlinkSync6 } from "fs";
 import { join as join69, dirname as dirname26, basename as basename12 } from "path";
 import { homedir as homedir11 } from "os";
 function findPython() {
@@ -84183,7 +84549,7 @@ function hasPythonPackage(python, pkg) {
 function ensureSynthScript() {
   if (!existsSync63(SCRIPT_PATH)) {
     mkdirSync35(SCRIPT_DIR, { recursive: true });
-    writeFileSync28(SCRIPT_PATH, SYNTH_SCRIPT);
+    writeFileSync29(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename12(SCRIPT_PATH);
     try {
       for (const entry of readdirSync25(SCRIPT_DIR)) {
@@ -84310,7 +84676,7 @@ __export(tts_exports, {
   default: () => tts_default,
   examples: () => examples17
 });
-import { existsSync as existsSync64, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync64, readFileSync as readFileSync45 } from "fs";
 import { resolve as resolve39, extname as extname12 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v2) => ({ ...v2, defaultLang: inferLangFromVoiceId(v2.id) }));
@@ -84421,7 +84787,7 @@ var init_tts = __esm({
         let text;
         const maybeFile = resolve39(args.input);
         if (existsSync64(maybeFile) && extname12(maybeFile).toLowerCase() === ".txt") {
-          text = readFileSync44(maybeFile, "utf-8").trim();
+          text = readFileSync45(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c2.error("File is empty."));
             process.exit(1);
@@ -84513,7 +84879,7 @@ __export(docs_exports, {
   default: () => docs_default,
   examples: () => examples18
 });
-import { readFileSync as readFileSync45, existsSync as existsSync65 } from "fs";
+import { readFileSync as readFileSync46, existsSync as existsSync65 } from "fs";
 import { resolve as resolve40, dirname as dirname27, join as join70 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 function docsDir() {
@@ -84623,7 +84989,7 @@ var init_docs = __esm({
           console.error(c2.error(`Doc file not found: ${filePath}`));
           process.exit(1);
         }
-        const content = readFileSync45(filePath, "utf-8");
+        const content = readFileSync46(filePath, "utf-8");
         console.log();
         renderMarkdown(content);
       }
@@ -85176,7 +85542,7 @@ __export(validate_exports, {
   default: () => validate_default,
   shouldIgnoreRequestFailure: () => shouldIgnoreRequestFailure
 });
-import { existsSync as existsSync66, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync47 } from "fs";
 import { join as join71, dirname as dirname28 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 function shouldIgnoreRequestFailure(url, errorText) {
@@ -85233,7 +85599,7 @@ function loadContrastAuditScript() {
     join71(__dirname3, "commands", "contrast-audit.browser.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync66(candidate)) return readFileSync46(candidate, "utf-8");
+    if (existsSync66(candidate)) return readFileSync47(candidate, "utf-8");
   }
   throw new Error("Missing contrast audit browser script");
 }
@@ -85253,7 +85619,7 @@ async function validateInBrowser(projectDir, opts) {
     const filePath = join71(projectDir, decodeURIComponent(url));
     if (existsSync66(filePath)) {
       res.writeHead(200, { "Content-Type": getMimeType2(filePath) });
-      res.end(readFileSync46(filePath));
+      res.end(readFileSync47(filePath));
       return;
     }
     res.writeHead(404);
@@ -85455,7 +85821,7 @@ __export(contactSheet_exports, {
   createSvgContactSheet: () => createSvgContactSheet
 });
 import sharp from "sharp";
-import { readdirSync as readdirSync26, readFileSync as readFileSync47, writeFileSync as writeFileSync29, unlinkSync as unlinkSync7, existsSync as existsSync67 } from "fs";
+import { readdirSync as readdirSync26, readFileSync as readFileSync48, writeFileSync as writeFileSync30, unlinkSync as unlinkSync7, existsSync as existsSync67 } from "fs";
 import { join as join72, extname as extname13, basename as basename13, dirname as dirname29 } from "path";
 async function createContactSheet(imagePaths, outputPath, opts = {}) {
   const {
@@ -85606,12 +85972,12 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir) {
     const svgPath = svgPaths[i2];
     const tmpPath = join72(tmpDir, `.thumb-${i2}.png`);
     try {
-      const svgBuf = readFileSync47(svgPath);
+      const svgBuf = readFileSync48(svgPath);
       const thumb = await sharp(svgBuf).resize(thumbSize, thumbSize, {
         fit: "contain",
         background: { r: 245, g: 245, b: 245, alpha: 1 }
       }).flatten({ background: { r: 245, g: 245, b: 245 } }).png().toBuffer();
-      writeFileSync29(tmpPath, thumb);
+      writeFileSync30(tmpPath, thumb);
       tmpPaths.push(tmpPath);
       labels.push(svgFileNames[i2].replace(".svg", ""));
     } catch {
@@ -106390,7 +106756,7 @@ var require_websocket = __commonJS({
     var http4 = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash9 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash9 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -106920,7 +107286,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key2 = randomBytes3(16).toString("base64");
+      const key2 = randomBytes4(16).toString("base64");
       const request = isSecure ? https2.request : http4.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -126164,7 +126530,7 @@ __export(snapshot_exports, {
   examples: () => examples23
 });
 import { spawn as spawn15 } from "child_process";
-import { existsSync as existsSync68, mkdtempSync as mkdtempSync3, readFileSync as readFileSync48, mkdirSync as mkdirSync36, rmSync as rmSync15, writeFileSync as writeFileSync30 } from "fs";
+import { existsSync as existsSync68, mkdtempSync as mkdtempSync3, readFileSync as readFileSync49, mkdirSync as mkdirSync36, rmSync as rmSync15, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { resolve as resolve41, join as join73, relative as relative11, isAbsolute as isAbsolute10 } from "path";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
@@ -126210,7 +126576,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
       }
     );
     if (result.code !== 0 || result.timedOut || !existsSync68(outPath)) return null;
-    return readFileSync48(outPath);
+    return readFileSync49(outPath);
   } finally {
     try {
       rmSync15(tmp, { recursive: true, force: true });
@@ -126547,7 +126913,7 @@ ${c2.success("\u25C7")}  ${paths.length} snapshots saved to snapshots/`);
                     const filename = p2.replace("snapshots/", "");
                     const filePath = join73(snapshotDir, filename);
                     if (!existsSync68(filePath)) return { filename, desc: "file not found" };
-                    const raw = readFileSync48(filePath);
+                    const raw = readFileSync49(filePath);
                     let imageData;
                     let mimeType = "image/png";
                     if (sharpFn) {
@@ -126584,7 +126950,7 @@ ${c2.success("\u25C7")}  ${paths.length} snapshots saved to snapshots/`);
                   }
                 }
                 const descPath = join73(snapshotDir, "descriptions.md");
-                writeFileSync30(descPath, descriptions.join("\n"));
+                writeFileSync31(descPath, descriptions.join("\n"));
                 console.log(`   ${c2.dim("descriptions.md")} (Gemini frame analysis)`);
               }
             } catch (descErr) {
@@ -126604,7 +126970,7 @@ ${c2.error("\u2717")} Snapshot failed: ${msg}`);
 });
 
 // src/capture/assetDownloader.ts
-import { writeFileSync as writeFileSync31, mkdirSync as mkdirSync37 } from "fs";
+import { writeFileSync as writeFileSync32, mkdirSync as mkdirSync37 } from "fs";
 import { join as join74, extname as extname14 } from "path";
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
   const assetsDir = join74(outputDir, "assets");
@@ -126628,7 +126994,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
     const name = `${finalSlug}.svg`;
     const localPath = `assets/svgs/${name}`;
     try {
-      writeFileSync31(join74(outputDir, localPath), svg.outerHTML, "utf-8");
+      writeFileSync32(join74(outputDir, localPath), svg.outerHTML, "utf-8");
       assets.push({ url: "", localPath, type: "svg" });
     } catch {
     }
@@ -126641,7 +127007,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
       if (buffer) {
-        writeFileSync31(join74(outputDir, localPath), buffer);
+        writeFileSync32(join74(outputDir, localPath), buffer);
         assets.push({ url: icon.href, localPath, type: "favicon" });
         break;
       }
@@ -126698,7 +127064,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
         const name = `${slug}${ext}`;
         usedNames.add(slug);
         const localPath = `assets/${name}`;
-        writeFileSync31(join74(outputDir, localPath), buffer);
+        writeFileSync32(join74(outputDir, localPath), buffer);
         assets.push({ url, localPath, type: "image" });
         imgIdx++;
       } catch {
@@ -126711,7 +127077,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
       const localPath = `assets/og-image${ext}`;
       const buffer = await fetchBuffer(tokens.ogImage);
       if (buffer && buffer.length > 5e3) {
-        writeFileSync31(join74(outputDir, localPath), buffer);
+        writeFileSync32(join74(outputDir, localPath), buffer);
         assets.push({ url: tokens.ogImage, localPath, type: "image" });
       }
     } catch {
@@ -126774,7 +127140,7 @@ async function downloadAndRewriteFonts(css, outputDir) {
       const relativePath = `assets/fonts/${filename}`;
       const buffer = await fetchBuffer(fontUrl);
       if (buffer) {
-        writeFileSync31(localPath, buffer);
+        writeFileSync32(localPath, buffer);
         rewritten = rewritten.split(fontUrl).join(relativePath);
         familyCounts.set(family, familyCount + 1);
         count++;
@@ -127741,7 +128107,7 @@ var init_designStyleExtractor = __esm({
 });
 
 // src/capture/fontMetadataExtractor.ts
-import { readdirSync as readdirSync27, readFileSync as readFileSync49, writeFileSync as writeFileSync32, existsSync as existsSync69 } from "fs";
+import { readdirSync as readdirSync27, readFileSync as readFileSync50, writeFileSync as writeFileSync33, existsSync as existsSync69 } from "fs";
 import { join as join75 } from "path";
 import * as fontkit from "fontkit";
 function isFontCollection(value) {
@@ -127775,7 +128141,7 @@ function extractFontMetadata(fontsDir, outputPath) {
       tool: "fontkit"
     }
   };
-  writeFileSync32(outputPath, JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync33(outputPath, JSON.stringify(manifest, null, 2), "utf-8");
   return manifest;
 }
 function readSingleFont(fullPath, filename) {
@@ -127791,7 +128157,7 @@ function readSingleFont(fullPath, filename) {
     identified: false
   };
   try {
-    const buf = readFileSync49(fullPath);
+    const buf = readFileSync50(fullPath);
     const created = fontkit.create(buf);
     const font = isFontCollection(created) ? created.fonts[0] : created;
     if (!font) return empty;
@@ -128047,7 +128413,7 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync38, writeFileSync as writeFileSync33, readdirSync as readdirSync28, readFileSync as readFileSync50, statSync as statSync24 } from "fs";
+import { mkdirSync as mkdirSync38, writeFileSync as writeFileSync34, readdirSync as readdirSync28, readFileSync as readFileSync51, statSync as statSync24 } from "fs";
 import { join as join76 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
@@ -128081,7 +128447,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
             const hash2 = buf.toString("base64").slice(0, 100);
             if (savedHashes.has(hash2)) continue;
             savedHashes.add(hash2);
-            writeFileSync33(join76(lottieDir, `animation-${savedCount}.lottie`), buf);
+            writeFileSync34(join76(lottieDir, `animation-${savedCount}.lottie`), buf);
             savedCount++;
             continue;
           }
@@ -128099,7 +128465,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
         } catch {
           continue;
         }
-        writeFileSync33(join76(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
+        writeFileSync34(join76(lottieDir, `animation-${savedCount}.json`), jsonData, "utf-8");
         savedCount++;
       }
     } catch {
@@ -128114,7 +128480,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   for (const file of readdirSync28(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = JSON.parse(readFileSync50(join76(lottieDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync51(join76(lottieDir, file), "utf-8"));
       const fr = raw.fr || 30;
       const dur = ((raw.op || 0) - (raw.ip || 0)) / fr;
       const previewName = file.replace(".json", "-preview.png");
@@ -128124,7 +128490,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
       try {
         previewPage = await chromeBrowser.newPage();
         await previewPage.setViewport({ width: 400, height: 400 });
-        const animData = JSON.parse(readFileSync50(join76(lottieDir, file), "utf-8"));
+        const animData = JSON.parse(readFileSync51(join76(lottieDir, file), "utf-8"));
         const midFrame = Math.floor(((raw.op || 0) - (raw.ip || 0)) * 0.3);
         await previewPage.setContent(
           `<!DOCTYPE html>
@@ -128177,7 +128543,7 @@ async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
     }
   }
   if (manifest.length > 0) {
-    writeFileSync33(
+    writeFileSync34(
       join76(outputDir, "extracted", "lottie-manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
@@ -128286,7 +128652,7 @@ async function captureVideoManifest(page, outputDir, progress) {
       });
     }
     if (videoManifest.length > 0) {
-      writeFileSync33(
+      writeFileSync34(
         join76(outputDir, "extracted", "video-manifest.json"),
         JSON.stringify(videoManifest, null, 2),
         "utf-8"
@@ -128303,7 +128669,7 @@ var init_mediaCapture = __esm({
 });
 
 // src/capture/contentExtractor.ts
-import { existsSync as existsSync70, readdirSync as readdirSync29, statSync as statSync25, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync70, readdirSync as readdirSync29, statSync as statSync25, readFileSync as readFileSync52 } from "fs";
 import { join as join77 } from "path";
 async function detectLibraries(page, capturedShaders) {
   let detectedLibraries = [];
@@ -128436,7 +128802,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings) {
           const filePath = join77(outputDir, "assets", file);
           const stat3 = statSync25(filePath);
           if (stat3.size > 4e6) return { file, caption: "" };
-          const buffer = readFileSync51(filePath);
+          const buffer = readFileSync52(filePath);
           const base64 = buffer.toString("base64");
           const ext = file.split(".").pop()?.toLowerCase() || "png";
           const mimeType = ext === "jpg" ? "image/jpeg" : `image/${ext}`;
@@ -128492,7 +128858,7 @@ async function captionImagesWithGemini(outputDir, progress, warnings) {
         const results = await Promise.allSettled(
           batch.map(async ({ relPath }) => {
             const filePath = join77(assetsDir, relPath);
-            let svgText = readFileSync51(filePath, "utf-8");
+            let svgText = readFileSync52(filePath, "utf-8");
             if (svgText.length > MAX_SVG_CHARS) {
               svgText = svgText.slice(0, MAX_SVG_CHARS) + "\n<!-- truncated -->";
             }
@@ -128610,7 +128976,7 @@ var agentPromptGenerator_exports = {};
 __export(agentPromptGenerator_exports, {
   generateAgentPrompt: () => generateAgentPrompt
 });
-import { writeFileSync as writeFileSync34, readdirSync as readdirSync30, existsSync as existsSync71 } from "fs";
+import { writeFileSync as writeFileSync35, readdirSync as readdirSync30, existsSync as existsSync71 } from "fs";
 import { join as join78 } from "path";
 function inferColorRole(hex) {
   const r2 = parseInt(hex.slice(1, 3), 16) / 255;
@@ -128630,9 +128996,9 @@ function inferColorRole(hex) {
 }
 function generateAgentPrompt(outputDir, url, tokens, _animations, hasScreenshot, hasLottie, hasShaders, _catalogedAssets, _detectedLibraries) {
   const prompt = buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShaders);
-  writeFileSync34(join78(outputDir, "AGENTS.md"), prompt, "utf-8");
-  writeFileSync34(join78(outputDir, "CLAUDE.md"), prompt, "utf-8");
-  writeFileSync34(join78(outputDir, ".cursorrules"), prompt, "utf-8");
+  writeFileSync35(join78(outputDir, "AGENTS.md"), prompt, "utf-8");
+  writeFileSync35(join78(outputDir, "CLAUDE.md"), prompt, "utf-8");
+  writeFileSync35(join78(outputDir, ".cursorrules"), prompt, "utf-8");
 }
 function buildPrompt(outputDir, url, tokens, hasScreenshot, hasLottie, hasShaders) {
   const title = tokens.title || new URL(url).hostname.replace(/^www\./, "");
@@ -128745,7 +129111,7 @@ var init_agentPromptGenerator = __esm({
 });
 
 // src/capture/scaffolding.ts
-import { existsSync as existsSync72, writeFileSync as writeFileSync35, readFileSync as readFileSync52 } from "fs";
+import { existsSync as existsSync72, writeFileSync as writeFileSync36, readFileSync as readFileSync53 } from "fs";
 import { join as join79, resolve as resolve42 } from "path";
 function loadEnvFile(startDir) {
   try {
@@ -128753,7 +129119,7 @@ function loadEnvFile(startDir) {
     for (let i2 = 0; i2 < 5; i2++) {
       const envPath = resolve42(dir, ".env");
       try {
-        const envContent = readFileSync52(envPath, "utf-8");
+        const envContent = readFileSync53(envPath, "utf-8");
         for (const line of envContent.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -128775,7 +129141,7 @@ async function generateProjectScaffold(outputDir, url, tokens, animationCatalog,
   const metaPath = join79(outputDir, "meta.json");
   if (!existsSync72(metaPath)) {
     const hostname = new URL(url).hostname.replace(/^www\./, "");
-    writeFileSync35(
+    writeFileSync36(
       metaPath,
       JSON.stringify({ id: hostname + "-video", name: tokens.title || hostname }, null, 2),
       "utf-8"
@@ -128810,7 +129176,7 @@ var screenshotCapture_exports = {};
 __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
-import { writeFileSync as writeFileSync36, mkdirSync as mkdirSync39 } from "fs";
+import { writeFileSync as writeFileSync37, mkdirSync as mkdirSync39 } from "fs";
 import { join as join80 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
   const screenshotsDir = join80(outputDir, "screenshots");
@@ -128907,7 +129273,7 @@ async function captureScrollScreenshots(page, outputDir) {
       const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
       const filePath = join80(screenshotsDir, filename);
       const buffer = await page.screenshot({ type: "png" });
-      writeFileSync36(filePath, buffer);
+      writeFileSync37(filePath, buffer);
       filePaths.push(`screenshots/${filename}`);
     }
     await page.evaluate(`window.scrollTo(0, 0)`);
@@ -129180,7 +129546,7 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync40, writeFileSync as writeFileSync37, existsSync as existsSync73 } from "fs";
+import { mkdirSync as mkdirSync40, writeFileSync as writeFileSync38, existsSync as existsSync73 } from "fs";
 import { join as join81 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
@@ -129375,7 +129741,7 @@ async function captureWebsite(opts, onProgress) {
           return true;
         });
         capturedShaders = unique;
-        writeFileSync37(
+        writeFileSync38(
           join81(outputDir, "extracted", "shaders.json"),
           JSON.stringify(unique, null, 2),
           "utf-8"
@@ -129390,7 +129756,7 @@ async function captureWebsite(opts, onProgress) {
       ...tokens,
       svgs: tokens.svgs.map(({ outerHTML: _, ...rest }) => rest)
     };
-    writeFileSync37(
+    writeFileSync38(
       join81(outputDir, "extracted", "tokens.json"),
       JSON.stringify(tokensForDisk, null, 2),
       "utf-8"
@@ -129398,7 +129764,7 @@ async function captureWebsite(opts, onProgress) {
     progress("style", "Extracting design styles...");
     try {
       const designStyles = await extractDesignStyles(page1);
-      writeFileSync37(
+      writeFileSync38(
         join81(outputDir, "extracted", "design-styles.json"),
         JSON.stringify(designStyles, null, 2),
         "utf-8"
@@ -129502,7 +129868,7 @@ ${err.stack}` : String(err);
         scrollTriggeredElements: (animationCatalog.scrollTargets || []).length,
         representativeAnimations: representativeAnims
       };
-      writeFileSync37(
+      writeFileSync38(
         join81(outputDir, "extracted", "animations.json"),
         JSON.stringify(leanCatalog, null, 2),
         "utf-8"
@@ -129514,14 +129880,14 @@ ${err.stack}` : String(err);
       assets = await downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks);
     }
     if (visibleTextContent) {
-      writeFileSync37(join81(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
+      writeFileSync38(join81(outputDir, "extracted", "visible-text.txt"), visibleTextContent, "utf-8");
     }
     const geminiCaptions = await captionImagesWithGemini(outputDir, progress, warnings);
     progress("design", "Generating asset descriptions...");
     try {
       const lines = generateAssetDescriptions(outputDir, tokens, catalogedAssets, geminiCaptions);
       if (lines.length > 0) {
-        writeFileSync37(
+        writeFileSync38(
           join81(outputDir, "extracted", "asset-descriptions.md"),
           "# Asset Descriptions\n\nOne line per file. Read this instead of opening every image individually.\n\n" + lines.map((l) => "- " + l).join("\n") + "\n",
           "utf-8"
@@ -129753,11 +130119,11 @@ var init_capture2 = __esm({
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           try {
-            const { mkdirSync: mkdirSync44, writeFileSync: writeFileSync39 } = await import("fs");
+            const { mkdirSync: mkdirSync44, writeFileSync: writeFileSync40 } = await import("fs");
             mkdirSync44(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}`;
-            writeFileSync39(
+            writeFileSync40(
               `${outputDir}/BLOCKED.md`,
               `# Capture Failed
 
@@ -129800,7 +130166,7 @@ __export(state_exports, {
   stateFilePath: () => stateFilePath,
   writeStackOutputs: () => writeStackOutputs
 });
-import { existsSync as existsSync74, mkdirSync as mkdirSync41, readdirSync as readdirSync31, readFileSync as readFileSync53, rmSync as rmSync16, writeFileSync as writeFileSync38 } from "fs";
+import { existsSync as existsSync74, mkdirSync as mkdirSync41, readdirSync as readdirSync31, readFileSync as readFileSync54, rmSync as rmSync16, writeFileSync as writeFileSync39 } from "fs";
 import { dirname as dirname30, join as join82 } from "path";
 function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   return join82(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
@@ -129808,14 +130174,14 @@ function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
 function writeStackOutputs(outputs, cwd = process.cwd()) {
   const path2 = stateFilePath(outputs.stackName, cwd);
   mkdirSync41(dirname30(path2), { recursive: true });
-  writeFileSync38(path2, JSON.stringify(outputs, null, 2) + "\n");
+  writeFileSync39(path2, JSON.stringify(outputs, null, 2) + "\n");
   return path2;
 }
 function readStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   const path2 = stateFilePath(stackName, cwd);
   if (!existsSync74(path2)) return null;
   try {
-    return JSON.parse(readFileSync53(path2, "utf-8"));
+    return JSON.parse(readFileSync54(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -130137,14 +130503,14 @@ var init_sites = __esm({
 });
 
 // src/commands/lambda/_dimensions.ts
-import { readFileSync as readFileSync54 } from "fs";
+import { readFileSync as readFileSync55 } from "fs";
 import { join as join85 } from "path";
 function warnOnDimensionMismatch(args) {
   if (args.quiet) return;
   if (args.outputResolution) return;
   let html;
   try {
-    html = readFileSync54(join85(args.projectDir, "index.html"), "utf-8");
+    html = readFileSync55(join85(args.projectDir, "index.html"), "utf-8");
   } catch {
     return;
   }
@@ -130313,7 +130679,7 @@ __export(render_batch_exports, {
   runRenderBatch: () => runRenderBatch,
   runWithConcurrencyLimit: () => runWithConcurrencyLimit
 });
-import { existsSync as existsSync79, readFileSync as readFileSync55 } from "fs";
+import { existsSync as existsSync79, readFileSync as readFileSync56 } from "fs";
 import { join as join87, resolve as resolvePath3 } from "path";
 async function loadSDK3() {
   return import("@hyperframes/aws-lambda/sdk");
@@ -130465,7 +130831,7 @@ function makePlaceholderSiteHandle(siteId, bucketName) {
   };
 }
 function parseBatchFile(path2) {
-  const raw = readFileSync55(path2, "utf8");
+  const raw = readFileSync56(path2, "utf8");
   const lines = raw.split(/\r?\n/);
   const out = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
@@ -130659,7 +131025,7 @@ __export(policies_exports, {
   runPolicies: () => runPolicies,
   validatePolicy: () => validatePolicy
 });
-import { readFileSync as readFileSync56 } from "fs";
+import { readFileSync as readFileSync57 } from "fs";
 function allRequiredActions() {
   const set = /* @__PURE__ */ new Set();
   for (const group of Object.values(REQUIRED_ACTIONS)) {
@@ -130765,7 +131131,7 @@ async function runPolicies(args) {
   }
 }
 function validatePolicy(policyPath) {
-  const raw = readFileSync56(policyPath, "utf-8");
+  const raw = readFileSync57(policyPath, "utf-8");
   const parsed = JSON.parse(raw);
   const statements = Array.isArray(parsed.Statement) ? parsed.Statement : parsed.Statement ? [
     parsed.Statement
@@ -131875,14 +132241,14 @@ var init_client3 = __esm({
 });
 
 // src/auth/pkce.ts
-import { createHash as createHash8, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash8, randomBytes as randomBytes3 } from "crypto";
 function generatePkcePair() {
-  const verifier = base64UrlEncode(randomBytes2(VERIFIER_BYTES));
+  const verifier = base64UrlEncode(randomBytes3(VERIFIER_BYTES));
   const challenge = base64UrlEncode(createHash8("sha256").update(verifier).digest());
   return { verifier, challenge, method: "S256" };
 }
 function generateState() {
-  return base64UrlEncode(randomBytes2(32));
+  return base64UrlEncode(randomBytes3(32));
 }
 function base64UrlEncode(buf) {
   return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
@@ -134571,10 +134937,10 @@ if (rootVersionRequested) {
   process.exit(0);
 }
 try {
-  const { readFileSync: readFileSync57 } = await import("fs");
+  const { readFileSync: readFileSync58 } = await import("fs");
   const { resolve: resolve46 } = await import("path");
   const envPath = resolve46(process.cwd(), ".env");
-  const envContent = readFileSync57(envPath, "utf-8");
+  const envContent = readFileSync58(envPath, "utf-8");
   for (const rawLine of envContent.split("\n")) {
     let line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;