@barefootjs/jsx 0.17.0 → 0.18.0

package/dist/index.js

@@ -352,6 +352,7 @@ function tsNodeToParsedExpr(node) {
 }
 var CALLBACK_METHODS = new Set([
   "filter",
+  "map",
   "every",
   "some",
   "find",
@@ -440,6 +441,7 @@ function convertNode(node, raw) {
       if (callee.property === "flat") {
         const depthNode = node.arguments[0];
         let flatDepth;
+        let depthExpr;
         if (depthNode === undefined) {
           flatDepth = 1;
         } else if (ts2.isIdentifier(depthNode) && depthNode.text === "Infinity") {
@@ -452,16 +454,23 @@ function convertNode(node, raw) {
             n = -Number(depthNode.operand.text);
           }
           if (n === undefined || Number.isNaN(n)) {
-            return {
-              kind: "unsupported",
-              raw,
-              reason: `\`.flat(depth)\` needs a literal integer or \`Infinity\` depth — a computed depth can't be resolved at template time. Use a literal depth, or pre-compute the value before the template.`
-            };
+            const parsedDepth = convertNode(depthNode, raw);
+            if (checkSupport(parsedDepth).supported) {
+              depthExpr = parsedDepth;
+              flatDepth = 1;
+            } else {
+              return {
+                kind: "unsupported",
+                raw,
+                reason: `\`.flat(depth)\` needs a literal integer, \`Infinity\`, or a supported dynamic depth expression — this depth can't be resolved. Use a literal depth, a supported expression (prop/signal/arithmetic), or pre-compute the value before the template.`
+              };
+            }
+          } else {
+            const truncated = Math.trunc(n);
+            flatDepth = truncated < 0 ? 0 : truncated;
           }
-          const truncated = Math.trunc(n);
-          flatDepth = truncated < 0 ? 0 : truncated;
         }
-        return { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
+        return depthExpr !== undefined ? { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth, depthExpr } : { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
       }
       if (callee.property === "toLowerCase") {
         return { kind: "array-method", method: "toLowerCase", object: callee.object, args };
@@ -1006,6 +1015,8 @@ function validateRestUsage(expr, restName, excludedTopKeys) {
         walk(e.object);
         for (const a of e.args)
           walk(a);
+        if (e.method === "flat" && e.depthExpr)
+          walk(e.depthExpr);
         return;
       case "literal":
       case "unsupported":
@@ -1091,6 +1102,8 @@ function collectIdentifiers(expr, out) {
     case "array-method":
       collectIdentifiers(expr.object, out);
       expr.args.forEach((e) => collectIdentifiers(e, out));
+      if (expr.method === "flat" && expr.depthExpr)
+        collectIdentifiers(expr.depthExpr, out);
       return;
     case "literal":
     case "regex":
@@ -1148,7 +1161,14 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         return { kind: "array-literal", elements: e.elements.map(walk) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object), args: e.args.map(walk) };
       case "literal":
@@ -1245,6 +1265,11 @@ function checkSupport(expr) {
         if (!argSupport.supported)
           return argSupport;
       }
+      if (expr.method === "flat" && expr.depthExpr) {
+        const depthSupport = checkSupport(expr.depthExpr);
+        if (!depthSupport.supported)
+          return depthSupport;
+      }
       return { supported: true, level: "L2" };
     }
     case "call": {
@@ -1344,6 +1369,9 @@ function checkSupport(expr) {
       const leftSupport = checkSupport(expr.left);
       if (!leftSupport.supported)
         return leftSupport;
+      if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
+        return { supported: true, level: "L4" };
+      }
       const rightSupport = checkSupport(expr.right);
       if (!rightSupport.supported)
         return rightSupport;
@@ -1398,7 +1426,7 @@ function containsHigherOrder(expr) {
     case "array-literal":
       return expr.elements.some(containsHigherOrder);
     case "array-method":
-      return containsHigherOrder(expr.object) || expr.args.some(containsHigherOrder);
+      return containsHigherOrder(expr.object) || expr.args.some(containsHigherOrder) || expr.method === "flat" && expr.depthExpr !== undefined && containsHigherOrder(expr.depthExpr);
     default:
       return false;
   }
@@ -1566,7 +1594,10 @@ function usesPerPath(name, expr) {
       case "array-literal":
         return sum(e.elements);
       case "array-method":
-        return add(walk(e.object), e.method === "flat" ? { min: 0, max: 0 } : sum(e.args));
+        if (e.method === "flat") {
+          return add(walk(e.object), e.depthExpr ? walk(e.depthExpr) : { min: 0, max: 0 });
+        }
+        return add(walk(e.object), sum(e.args));
       case "object-literal":
         return sum(e.properties.map((p) => p.value));
       case "arrow":
@@ -1621,7 +1652,14 @@ function inlineBinding(expr, name, value) {
         return { kind: "array-literal", elements: e.elements.map((el) => walk(el, enclosing)) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object, enclosing), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object, enclosing),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr, enclosing) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "object-literal":
@@ -1752,6 +1790,9 @@ function exprToString(expr) {
       return `[${expr.elements.map(exprToString).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${exprToString(expr.object)}.flat(${exprToString(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${exprToString(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -1803,6 +1844,9 @@ function stringifyParsedExpr(expr) {
       return `[${expr.elements.map(stringifyParsedExpr).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${stringifyParsedExpr(expr.object)}.flat(${stringifyParsedExpr(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${stringifyParsedExpr(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -1813,66 +1857,195 @@ function stringifyParsedExpr(expr) {
       return expr.raw;
   }
 }
+function materializeGetterCalls(expr, names) {
+  const rw = (e) => materializeGetterCalls(e, names);
+  switch (expr.kind) {
+    case "call":
+      if (expr.args.length === 0 && expr.callee.kind === "identifier" && names.has(expr.callee.name)) {
+        return { kind: "identifier", name: expr.callee.name };
+      }
+      return { kind: "call", callee: rw(expr.callee), args: expr.args.map(rw) };
+    case "binary":
+      return { kind: "binary", op: expr.op, left: rw(expr.left), right: rw(expr.right) };
+    case "logical":
+      return { kind: "logical", op: expr.op, left: rw(expr.left), right: rw(expr.right) };
+    case "unary":
+      return { kind: "unary", op: expr.op, argument: rw(expr.argument) };
+    case "conditional":
+      return {
+        kind: "conditional",
+        test: rw(expr.test),
+        consequent: rw(expr.consequent),
+        alternate: rw(expr.alternate)
+      };
+    case "member":
+      return { kind: "member", object: rw(expr.object), property: expr.property, computed: expr.computed };
+    case "index-access":
+      return { kind: "index-access", object: rw(expr.object), index: rw(expr.index) };
+    case "template-literal":
+      return {
+        kind: "template-literal",
+        parts: expr.parts.map((p) => p.type === "string" ? p : { type: "expression", expr: rw(p.expr) })
+      };
+    case "array-literal":
+      return { kind: "array-literal", elements: expr.elements.map(rw) };
+    case "array-method":
+      if (expr.method === "flat") {
+        return { ...expr, object: rw(expr.object), ...expr.depthExpr ? { depthExpr: rw(expr.depthExpr) } : {} };
+      }
+      return { ...expr, object: rw(expr.object), args: expr.args.map(rw) };
+    case "object-literal":
+      return {
+        kind: "object-literal",
+        raw: expr.raw,
+        properties: expr.properties.map((p) => ({ ...p, value: rw(p.value) }))
+      };
+    case "arrow":
+      return { kind: "arrow", params: expr.params, body: rw(expr.body) };
+    case "identifier":
+    case "literal":
+    case "regex":
+    case "unsupported":
+      return expr;
+  }
+}
 function serializeParsedExpr(expr) {
   const node = toEvalNode(expr);
   return node === null ? null : JSON.stringify(node);
 }
 function freeVarsInBody(body, params) {
   const found = new Set;
-  const visit = (e) => {
+  const visit = (e, bound) => {
     switch (e.kind) {
       case "identifier":
-        if (!params.has(e.name))
+        if (!bound.has(e.name))
           found.add(e.name);
         return;
       case "binary":
       case "logical":
-        visit(e.left);
-        visit(e.right);
+        visit(e.left, bound);
+        visit(e.right, bound);
         return;
       case "unary":
-        visit(e.argument);
+        visit(e.argument, bound);
         return;
       case "conditional":
-        visit(e.test);
-        visit(e.consequent);
-        visit(e.alternate);
+        visit(e.test, bound);
+        visit(e.consequent, bound);
+        visit(e.alternate, bound);
         return;
       case "member":
-        visit(e.object);
+        visit(e.object, bound);
         return;
       case "index-access":
-        visit(e.object);
-        visit(e.index);
+        visit(e.object, bound);
+        visit(e.index, bound);
         return;
       case "call":
         if (evalBuiltinCalleeName(e.callee) === null)
-          visit(e.callee);
-        e.args.forEach(visit);
+          visit(e.callee, bound);
+        e.args.forEach((a) => visit(a, bound));
         return;
       case "template-literal":
         for (const p of e.parts)
           if (p.type === "expression")
-            visit(p.expr);
+            visit(p.expr, bound);
         return;
       case "array-literal":
-        e.elements.forEach(visit);
+        e.elements.forEach((el) => visit(el, bound));
         return;
       case "object-literal":
         for (const p of e.properties)
-          visit(p.value);
+          visit(p.value, bound);
         return;
-      case "literal":
       case "array-method":
-      case "arrow":
+        if (e.method === "includes" || e.method === "join") {
+          visit(e.object, bound);
+          e.args.forEach((a) => visit(a, bound));
+        }
+        return;
+      case "arrow": {
+        const inner = e.params.length === 0 ? bound : new Set([...bound, ...e.params]);
+        visit(e.body, inner);
+        return;
+      }
+      case "literal":
       case "regex":
       case "unsupported":
         return;
     }
   };
-  visit(body);
+  visit(body, params);
   return [...found].sort();
 }
+function freeIdentifiers(expr) {
+  const free = new Set;
+  function visit(e, bound) {
+    switch (e.kind) {
+      case "literal":
+      case "regex":
+        return true;
+      case "identifier":
+        if (!bound.has(e.name))
+          free.add(e.name);
+        return true;
+      case "call": {
+        const isBuiltinCallee = evalBuiltinCalleeName(e.callee) !== null;
+        if (!isBuiltinCallee && !visit(e.callee, bound))
+          return false;
+        for (const a of e.args)
+          if (!visit(a, bound))
+            return false;
+        return true;
+      }
+      case "member":
+        return visit(e.object, bound);
+      case "index-access":
+        return visit(e.object, bound) && visit(e.index, bound);
+      case "binary":
+      case "logical":
+        return visit(e.left, bound) && visit(e.right, bound);
+      case "unary":
+        return visit(e.argument, bound);
+      case "conditional":
+        return visit(e.test, bound) && visit(e.consequent, bound) && visit(e.alternate, bound);
+      case "template-literal":
+        for (const p of e.parts) {
+          if (p.type === "expression" && !visit(p.expr, bound))
+            return false;
+        }
+        return true;
+      case "array-literal":
+        for (const el of e.elements)
+          if (!visit(el, bound))
+            return false;
+        return true;
+      case "array-method":
+        if (!visit(e.object, bound))
+          return false;
+        for (const a of e.args)
+          if (!visit(a, bound))
+            return false;
+        if (e.method === "flat" && e.depthExpr && !visit(e.depthExpr, bound))
+          return false;
+        return true;
+      case "object-literal":
+        for (const p of e.properties)
+          if (!visit(p.value, bound))
+            return false;
+        return true;
+      case "arrow": {
+        const inner = new Set(bound);
+        for (const p of e.params)
+          inner.add(p);
+        return visit(e.body, inner);
+      }
+      case "unsupported":
+        return false;
+    }
+  }
+  return visit(expr, new Set) ? free : null;
+}
 var EVAL_BINARY_OPS = new Set([
   "+",
   "-",
@@ -1950,6 +2123,20 @@ function toEvalNode(e) {
       return object && index ? { kind: "index-access", object, index } : null;
     }
     case "call": {
+      const cb = asCallbackMethodCall(e);
+      if (cb && (cb.method === "map" || cb.method === "filter")) {
+        const object = toEvalNode(cb.object);
+        if (!object)
+          return null;
+        const body = toEvalNode(cb.arrow.body);
+        if (!body)
+          return null;
+        return {
+          kind: "call",
+          callee: { kind: "member", object, property: cb.method, computed: false },
+          args: [{ kind: "arrow", params: cb.arrow.params, body }]
+        };
+      }
       if (evalBuiltinCalleeName(e.callee) === null)
         return null;
       const callee = toEvalNode(e.callee);
@@ -1998,7 +2185,23 @@ function toEvalNode(e) {
       }
       return { kind: "object-literal", properties };
     }
-    case "array-method":
+    case "array-method": {
+      if (e.method === "includes" && e.args.length === 1) {
+        const object = toEvalNode(e.object);
+        const arg = toEvalNode(e.args[0]);
+        return object && arg ? { kind: "array-method", method: "includes", object, args: [arg] } : null;
+      }
+      if (e.method === "join" && e.args.length <= 1) {
+        const object = toEvalNode(e.object);
+        if (!object)
+          return null;
+        if (e.args.length === 0)
+          return { kind: "array-method", method: "join", object, args: [] };
+        const sep = toEvalNode(e.args[0]);
+        return sep ? { kind: "array-method", method: "join", object, args: [sep] } : null;
+      }
+      return null;
+    }
     case "arrow":
     case "regex":
     case "unsupported":
@@ -3152,6 +3355,89 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       return assertNever(node);
   }
 }
+function buildLoopSkeletonTemplate(node, safe) {
+  switch (node.type) {
+    case "element": {
+      const attrParts = [];
+      for (const a of node.attrs) {
+        if (a.name === "...")
+          return null;
+        if (a.name === "dangerouslySetInnerHTML")
+          return null;
+        if (a.name === "key") {
+          attrParts.push(`${keyAttrName(0)}=""`);
+          continue;
+        }
+        const v = a.value;
+        switch (v.kind) {
+          case "literal":
+            attrParts.push(`${toHtmlAttrName(a.name)}="${v.value}"`);
+            break;
+          case "boolean-attr":
+            attrParts.push(toHtmlAttrName(a.name));
+            break;
+          case "boolean-shorthand":
+          case "jsx-children":
+            break;
+          case "expression":
+          case "template": {
+            const attrKey = node.slotId ? `${node.slotId}::${a.name}` : null;
+            if (!attrKey || !safe.reactiveAttrKeys.has(attrKey))
+              return null;
+            break;
+          }
+          case "spread":
+            return null;
+        }
+      }
+      if (node.slotId)
+        attrParts.push(`bf="${node.slotId}"`);
+      const attrs = attrParts.join(" ");
+      let children = "";
+      for (const child of node.children) {
+        const rendered = buildLoopSkeletonTemplate(child, safe);
+        if (rendered === null)
+          return null;
+        children += rendered;
+      }
+      if (children || !VOID_ELEMENTS.has(node.tag)) {
+        return `<${node.tag}${attrs ? " " + attrs : ""}>${children}</${node.tag}>`;
+      }
+      return `<${node.tag}${attrs ? " " + attrs : ""} />`;
+    }
+    case "text":
+      return node.value;
+    case "expression":
+      if (node.expr === "null" || node.expr === "undefined")
+        return "";
+      if (!node.slotId) {
+        return null;
+      }
+      if (!safe.reactiveTextSlotIds.has(node.slotId))
+        return null;
+      return `<!--bf:${node.slotId}--><!--/-->`;
+    case "fragment": {
+      let out = "";
+      for (const child of node.children) {
+        const rendered = buildLoopSkeletonTemplate(child, safe);
+        if (rendered === null)
+          return null;
+        out += rendered;
+      }
+      return out;
+    }
+    case "conditional":
+    case "component":
+    case "loop":
+    case "if-statement":
+    case "provider":
+    case "async":
+    case "slot":
+      return null;
+    default:
+      return assertNever(node);
+  }
+}
 function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParams) {
   const recurse = (n) => irToPlaceholderTemplate(n, restSpreadNames, loopDepth, loopParams);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
@@ -3551,7 +3837,23 @@ function generateCsrTemplate(node, inlinableConstants, ctx, insideLoop, restSpre
       }
     }
   }
-  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+  const effectiveUnsafeLocalNames = mergeCsrNullUnsafe(ctx, unsafeLocalNames);
+  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+}
+function mergeCsrNullUnsafe(ctx, unsafeLocalNames) {
+  let merged = null;
+  let exemptNames = null;
+  for (const [name, entry] of ctx.csrInlinable) {
+    if (entry !== null || unsafeLocalNames?.has(name))
+      continue;
+    exemptNames ??= new Set(ctx.localConstants.filter((c) => c.isJsx || c.systemConstructKind).map((c) => c.name));
+    if (exemptNames.has(name))
+      continue;
+    if (!merged)
+      merged = new Set(unsafeLocalNames ?? []);
+    merged.add(name);
+  }
+  return merged ?? unsafeLocalNames;
 }
 function buildCsrEnvForCtx(ctx, inlinableConstants, propsObjectName) {
   const base = buildSignalMemoEnv(ctx.signals, ctx.memos, propsObjectName ?? null);
@@ -3582,8 +3884,8 @@ function propResolvesUnsafe(prop, env, unsafeLocalNames) {
   }
   if (!source)
     return false;
-  const { freeIdentifiers } = csrSubstitute(source, env);
-  return setIntersects(freeIdentifiers, unsafeLocalNames);
+  const { freeIdentifiers: freeIdentifiers2 } = csrSubstitute(source, env);
+  return setIntersects(freeIdentifiers2, unsafeLocalNames);
 }
 function computeDeferredChildSlots(node, ctx, inlinableConstants, unsafeLocalNames, propsObjectName) {
   const deferred = new Set;
@@ -3636,8 +3938,8 @@ function generateCsrTemplateWithOpts(node, opts) {
     const source = templateExpr ?? expr;
     if (!source)
       return source;
-    const { rewritten, freeIdentifiers } = csrSubstitute(source, env);
-    if (unsafeLocalNames && unsafeLocalNames.size > 0 && setIntersects(freeIdentifiers, unsafeLocalNames)) {
+    const { rewritten, freeIdentifiers: freeIdentifiers2 } = csrSubstitute(source, env);
+    if (unsafeLocalNames && unsafeLocalNames.size > 0 && setIntersects(freeIdentifiers2, unsafeLocalNames)) {
       return UNSAFE_TEMPLATE_EXPR;
     }
     return applyPropsRewrite(rewritten, propsObjectName ?? null);
@@ -4139,6 +4441,15 @@ function createAnalyzerContext(sourceFile, filePath) {
     checker: null,
     componentBodyBlock: null,
     getJS(node) {
+      let ownSourceFile;
+      try {
+        ownSourceFile = node.getSourceFile();
+      } catch {
+        ownSourceFile = undefined;
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile);
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges);
     }
   };
@@ -6301,7 +6612,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
       const baseValue = `${propsName}.${sourceKey}`;
       const value2 = defaultValueExpr ? `${baseValue} ?? ${defaultValueExpr}` : baseValue;
       const containsArrow2 = el.initializer ? nodeContainsArrow(el.initializer) : false;
-      const freeIdentifiers2 = el.initializer ? extractFreeIdentifiersFromNode(el.initializer) : new Set([propsName]);
+      const freeIdentifiers3 = el.initializer ? extractFreeIdentifiersFromNode(el.initializer) : new Set([propsName]);
       ctx.localConstants.push({
         name: localName,
         value: value2,
@@ -6309,7 +6620,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
         isExported,
         type: null,
         loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
-        freeIdentifiers: freeIdentifiers2,
+        freeIdentifiers: freeIdentifiers3,
         containsArrow: containsArrow2 || undefined,
         origin: { phase: "hydrate", scope: "init", effect: "pure" }
       });
@@ -6393,7 +6704,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   } else if (value) {
     type = inferTypeFromValue(value);
   }
-  const freeIdentifiers = node.initializer ? extractFreeIdentifiersFromNode(node.initializer) : undefined;
+  const freeIdentifiers2 = node.initializer ? extractFreeIdentifiersFromNode(node.initializer) : undefined;
   const containsArrow = node.initializer ? nodeContainsArrow(node.initializer) : false;
   const systemConstructKind = node.initializer ? getSystemConstructKind(node.initializer) : undefined;
   let templateValue;
@@ -6442,7 +6753,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     isModule: isModule || undefined,
     type,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
-    freeIdentifiers,
+    freeIdentifiers: freeIdentifiers2,
     isJsx,
     isJsxFunction: isJsxFunction || undefined,
     containsArrow: containsArrow || undefined,
@@ -6492,6 +6803,7 @@ function extractProps(param, ctx) {
       loc: getSourceLocation(param, ctx.sourceFile, ctx.filePath),
       hasIgnoreDirective: ignored
     };
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null;
     for (const element of param.name.elements) {
       if (ts8.isBindingElement(element) && ts8.isIdentifier(element.name)) {
         const localName = element.name.text;
@@ -6500,10 +6812,12 @@ function extractProps(param, ctx) {
           ctx.restPropsName = localName;
           continue;
         }
+        const sourcePropName = element.propertyName && ts8.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
+        const resolvedType = memberTypes?.get(sourcePropName) ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
         ctx.propsParams.push({
           name: localName,
-          type: { kind: "unknown", raw: "unknown" },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined
@@ -6564,6 +6878,37 @@ function collectKeysFromMembers(members, ctx) {
   }
   return keys;
 }
+function collectMemberTypes(typeNode, ctx) {
+  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean");
+  const fromMembers = (members) => {
+    const map = new Map;
+    for (const member of members) {
+      if (ts8.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile);
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx.sourceFile), info);
+        }
+      }
+    }
+    return map;
+  };
+  if (ts8.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members);
+  }
+  if (ts8.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx.sourceFile);
+    const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
+    if (!typeDecl)
+      return null;
+    if (ts8.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members);
+    }
+    if (ts8.isTypeAliasDeclaration(typeDecl) && ts8.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members);
+    }
+  }
+  return null;
+}
 function extractPropsFromType(typeNode, ctx) {
   if (ts8.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
@@ -7258,58 +7603,171 @@ function pickAttrMetaFromIR(src) {
   };
 }
 
-// src/builtins.ts
-var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
-function isClientBuiltinName(name) {
-  return name === "Async" || name === "Region";
-}
-function stripClientBuiltinImports(imports) {
-  const result = [];
-  for (const imp of imports) {
-    if (imp.source !== CLIENT_BUILTIN_SOURCE || imp.isTypeOnly || imp.specifiers.length === 0) {
-      result.push(imp);
+// src/module-exports.ts
+function generateModuleExports(ir, extraInlineExported = new Set, rewriteRelativeImport) {
+  const lines = [];
+  for (const constant of ir.metadata.localConstants) {
+    if (!constant.isExported)
+      continue;
+    const keyword = constant.declarationKind ?? "const";
+    if (!constant.value) {
+      lines.push(`export ${keyword} ${constant.name}`);
       continue;
     }
-    const kept = imp.specifiers.filter((spec) => spec.isDefault || spec.isNamespace || spec.isTypeOnly || !isClientBuiltinName(spec.name));
-    if (kept.length === 0)
+    const value = constant.value.trim();
+    if (/^createContext\b/.test(value) || /^new WeakMap\b/.test(value))
       continue;
-    result.push(kept.length === imp.specifiers.length ? imp : { ...imp, specifiers: kept });
+    lines.push(`export ${keyword} ${constant.name} = ${constant.value}`);
   }
-  return result;
-}
-
-// src/reactivity-checker.ts
-import ts9 from "typescript";
-var REACTIVE_BRAND = "__reactive";
-function queryType(checker, node) {
-  incrementCounter("typeCheckerQueries");
-  return checker.getTypeAtLocation(node);
-}
-function isReactiveType(type) {
-  return type.getProperty(REACTIVE_BRAND) !== undefined;
-}
-var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
-function safeGetText(node) {
-  try {
-    return node.getText();
-  } catch {
-    return "";
+  for (const func of ir.metadata.localFunctions) {
+    if (!func.isExported)
+      continue;
+    const params = func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
+    const returnAnnotation = func.typedReturnType ? `: ${func.typedReturnType}` : "";
+    const body = func.typedBody ?? func.body;
+    const asyncKw = func.isAsync ? "async " : "";
+    lines.push(`export ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
   }
-}
-function analyze(node, checker) {
-  if (ts9.isPropertyAccessExpression(node)) {
-    try {
-      const type = queryType(checker, node);
-      if (isReactiveType(type)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {}
-    const sub = analyze(node.expression, checker);
-    if (sub.isReactive) {
-      return {
+  const inlineExported = collectInlineExportedNames(ir);
+  for (const name of extraInlineExported)
+    inlineExported.add(name);
+  for (const block of ir.metadata.namedExports) {
+    const isReexportFrom = block.source !== null;
+    const survivingSpecs = block.specifiers.filter((spec) => {
+      if (isReexportFrom)
+        return true;
+      return !(inlineExported.has(spec.name) && spec.alias == null);
+    });
+    if (survivingSpecs.length === 0)
+      continue;
+    const specText = survivingSpecs.map((s) => {
+      const prefix = s.isTypeOnly ? "type " : "";
+      return s.alias ? `${prefix}${s.name} as ${s.alias}` : `${prefix}${s.name}`;
+    }).join(", ");
+    const typeKw = block.isTypeOnly ? "type " : "";
+    if (isReexportFrom) {
+      const source = rewriteRelativeImport && block.source.startsWith(".") ? rewriteRelativeImport(block.source) : block.source;
+      lines.push(`export ${typeKw}{ ${specText} } from '${source}'`);
+    } else {
+      lines.push(`export ${typeKw}{ ${specText} }`);
+    }
+  }
+  return lines.length > 0 ? lines.join(`
+`) : null;
+}
+function collectInlineExportedNames(ir) {
+  const names = new Set;
+  for (const c of ir.metadata.localConstants) {
+    if (c.isExported)
+      names.add(c.name);
+  }
+  for (const f of ir.metadata.localFunctions) {
+    if (f.isExported)
+      names.add(f.name);
+  }
+  if (ir.metadata.isExported && ir.metadata.componentName) {
+    names.add(ir.metadata.componentName);
+  }
+  return names;
+}
+function formatParamWithType(p) {
+  const rest = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
+  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = new Set;
+  const queue = [];
+  for (const name of allNames) {
+    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+      reachable.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body = bodyMap.get(current) || "";
+    for (const name of allNames) {
+      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+        reachable.add(name);
+        queue.push(name);
+      }
+    }
+  }
+  return reachable;
+}
+function extractFunctionParams(value) {
+  const arrowMatch = value.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
+  if (arrowMatch) {
+    return arrowMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
+  }
+  const singleMatch = value.match(/^(?:async\s*)?(\w+)\s*=>/);
+  if (singleMatch) {
+    return singleMatch[1];
+  }
+  const funcMatch = value.match(/^(?:async\s*)?function\s*\w*\s*\(([^)]*)\)/);
+  if (funcMatch) {
+    return funcMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
+  }
+  return "";
+}
+
+// src/builtins.ts
+var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
+function isClientBuiltinName(name) {
+  return name === "Async" || name === "Region";
+}
+function stripClientBuiltinImports(imports) {
+  const result = [];
+  for (const imp of imports) {
+    if (imp.source !== CLIENT_BUILTIN_SOURCE || imp.isTypeOnly || imp.specifiers.length === 0) {
+      result.push(imp);
+      continue;
+    }
+    const kept = imp.specifiers.filter((spec) => spec.isDefault || spec.isNamespace || spec.isTypeOnly || !isClientBuiltinName(spec.name));
+    if (kept.length === 0)
+      continue;
+    result.push(kept.length === imp.specifiers.length ? imp : { ...imp, specifiers: kept });
+  }
+  return result;
+}
+
+// src/reactivity-checker.ts
+import ts9 from "typescript";
+var REACTIVE_BRAND = "__reactive";
+function queryType(checker, node) {
+  incrementCounter("typeCheckerQueries");
+  return checker.getTypeAtLocation(node);
+}
+function isReactiveType(type) {
+  return type.getProperty(REACTIVE_BRAND) !== undefined;
+}
+var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
+function safeGetText(node) {
+  try {
+    return node.getText();
+  } catch {
+    return "";
+  }
+}
+function analyze(node, checker) {
+  if (ts9.isPropertyAccessExpression(node)) {
+    try {
+      const type = queryType(checker, node);
+      if (isReactiveType(type)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {}
+    const sub = analyze(node.expression, checker);
+    if (sub.isReactive) {
+      return {
         isReactive: true,
         reason: {
           kind: "child",
@@ -8379,6 +8837,7 @@ function transformExpression(node, ctx) {
   return transformExpressionInner(expr, ctx, node, isClientOnly);
 }
 function transformExpressionInner(expr, ctx, node, isClientOnly) {
+  expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
   checkBareSignalOrMemoIdentifier(expr, ctx);
   if (ts11.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
@@ -8920,11 +9379,10 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name };
 }
 function extractSortComparator(callback, _method, ctx) {
-  const unsupported = () => {
-    const raw = ctx.getJS(callback);
-    return {
-      result: null,
-      unsupportedReason: `Sort comparator '${raw}' is not a supported shape. Accepted:
+  const outerRaw = ctx.getJS(callback);
+  const unsupported = () => ({
+    result: null,
+    unsupportedReason: `Sort comparator '${outerRaw}' is not a supported shape. Accepted:
 ` + `  (a, b) => a - b
 ` + `  (a, b) => a.field - b.field
 ` + `  (a, b) => a.localeCompare(b)
@@ -8932,15 +9390,25 @@ function extractSortComparator(callback, _method, ctx) {
 ` + `  (a, b) => a.field > b.field ? 1 : a.field < b.field ? -1 : 0
 ` + `  any of the above '||'-chained for multi-key tie-breaks
 ` + `(reverse the operands for descending order).`
-    };
-  };
-  if (!ts11.isArrowFunction(callback) && !ts11.isFunctionExpression(callback)) {
+  });
+  let resolvedNode = callback;
+  if (ts11.isIdentifier(callback)) {
+    const resolved = resolveSortComparatorIdentifier(callback.text, ctx);
+    if (!resolved) {
+      return {
+        result: null,
+        unsupportedReason: `Sort comparator '${outerRaw}' could not be resolved to a local function — ` + `declare it in the same file or inline it.`
+      };
+    }
+    resolvedNode = resolved;
+  }
+  if (!ts11.isArrowFunction(resolvedNode) && !ts11.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
     };
   }
-  const arrow = tsNodeToParsedExpr(callback);
+  const arrow = tsNodeToParsedExpr(resolvedNode);
   if (arrow.kind !== "arrow" || arrow.params.length !== 2)
     return unsupported();
   if (sortComparatorFromArrow(arrow) === null)
@@ -8954,6 +9422,21 @@ function extractSortComparator(callback, _method, ctx) {
     }
   };
 }
+function resolveSortComparatorIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
 function extractFilterPredicate(callback, ctx) {
   if (!ts11.isArrowFunction(callback))
     return { result: null };
@@ -9026,7 +9509,7 @@ function extractLoopParamBindings(pattern) {
   const appendDotAccess = (prefix, key) => {
     return isIdent(key) ? `${prefix}.${key}` : `${prefix}[${JSON.stringify(key)}]`;
   };
-  const walk = (p, prefix) => {
+  const walk = (p, prefix, segments) => {
     if (unsupported)
       return;
     if (ts11.isArrayBindingPattern(p)) {
@@ -9043,15 +9526,17 @@ function extractLoopParamBindings(pattern) {
           bindings.push({
             name: el.name.text,
             path: prefix,
-            rest: { kind: "array", from: index }
+            rest: { kind: "array", from: index },
+            segments
           });
           return;
         }
         const path = `${prefix}[${index}]`;
+        const nextSegments = [...segments, { kind: "index", index }];
         if (ts11.isIdentifier(el.name)) {
-          bindings.push({ name: el.name.text, path });
+          bindings.push({ name: el.name.text, path, segments: nextSegments });
         } else {
-          walk(el.name, path);
+          walk(el.name, path, nextSegments);
         }
       }
       return;
@@ -9068,7 +9553,8 @@ function extractLoopParamBindings(pattern) {
         bindings.push({
           name: el.name.text,
           path: prefix,
-          rest: { kind: "object", exclude: collectedKeys }
+          rest: { kind: "object", exclude: collectedKeys },
+          segments
         });
         return;
       }
@@ -9091,17 +9577,19 @@ function extractLoopParamBindings(pattern) {
         unsupported = true;
         return;
       }
-      collectedKeys.push({ key: keyText, isIdent: isIdent(keyText) });
+      const keyIsIdent = isIdent(keyText);
+      collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path = appendDotAccess(prefix, keyText);
+      const nextSegments = [...segments, { kind: "field", key: keyText, isIdent: keyIsIdent }];
       if (ts11.isIdentifier(el.name)) {
-        bindings.push({ name: el.name.text, path });
+        bindings.push({ name: el.name.text, path, segments: nextSegments });
       } else {
-        walk(el.name, path);
+        walk(el.name, path, nextSegments);
       }
     }
   };
   if (ts11.isArrayBindingPattern(pattern) || ts11.isObjectBindingPattern(pattern)) {
-    walk(pattern, "");
+    walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
     return bindings;
@@ -9843,14 +10331,14 @@ function processAttributes(attributes, ctx) {
         clientOnly = true;
       }
     }
-    const freeIdentifiers = attrFreeIdentifiers(attr);
+    const freeIdentifiers2 = attrFreeIdentifiers(attr);
     attrs.push({
       name,
       value,
       clientOnly,
       loc: getSourceLocation(attr, ctx.sourceFile, ctx.filePath),
       ...computeReactivityFlags(attr, ctx),
-      ...freeIdentifiers !== undefined && { freeIdentifiers }
+      ...freeIdentifiers2 !== undefined && { freeIdentifiers: freeIdentifiers2 }
     });
   }
   return { attrs, events, ref };
@@ -9870,6 +10358,7 @@ function getAttributeValue(attr, ctx) {
         expr = branchInit;
       }
     }
+    expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
     if (ts11.isAwaitExpression(expr)) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
@@ -10005,6 +10494,14 @@ function findLocalConst(name, ctx) {
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
+function findLocalFunction(name, ctx) {
+  const matches = ctx.analyzer.localFunctions.filter((f) => f.name === name);
+  if (matches.length === 0)
+    return;
+  const fnScoped = matches.filter((f) => !f.isModule);
+  const pool = fnScoped.length > 0 ? fnScoped : matches;
+  return pool[pool.length - 1];
+}
 function isDynamicTagLocal(name, ctx) {
   if (!hasDynamicTagBinding(name, ctx.sourceFile))
     return false;
@@ -10099,6 +10596,147 @@ function parseConstInitializerImpl(c) {
 function astText(node) {
   return node.getText(node.getSourceFile());
 }
+var functionInfoExprCache = new WeakMap;
+function parseFunctionInfoAsExpr(fn) {
+  const cached = functionInfoExprCache.get(fn);
+  if (cached !== undefined)
+    return cached;
+  const result = parseFunctionInfoAsExprImpl(fn);
+  functionInfoExprCache.set(fn, result);
+  return result;
+}
+function parseFunctionInfoAsExprImpl(fn) {
+  if (!fn.body)
+    return null;
+  const params = fn.typedParams !== undefined ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
+  const body = fn.typedBody ?? fn.body;
+  const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body}`;
+  const sf = ts11.createSourceFile("__bf_resolve_fn.ts", wrapped, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts11.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  return decl.initializer;
+}
+function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
+  if (!ts11.isTaggedTemplateExpression(expr))
+    return expr;
+  if (!ts11.isIdentifier(expr.tag))
+    return expr;
+  const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx);
+  if (!resolvedTag)
+    return expr;
+  if (!isInterleaveTagFunction(resolvedTag))
+    return expr;
+  const rewritten = buildUntaggedTemplateLiteral(expr, ctx);
+  return rewritten ?? expr;
+}
+function resolveInterleaveTagIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function isInterleaveTagFunction(fn) {
+  if (!ts11.isArrowFunction(fn) && !ts11.isFunctionExpression(fn))
+    return false;
+  if (fn.parameters.length !== 2)
+    return false;
+  const [partsParam, argsParam] = fn.parameters;
+  if (!ts11.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
+    return false;
+  if (!ts11.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
+    return false;
+  const parsed = tsNodeToParsedExpr(fn);
+  if (parsed.kind !== "arrow")
+    return false;
+  return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
+}
+function isInterleaveReduceCall(body, partsName, argsName) {
+  if (body.kind !== "call" || body.args.length !== 2)
+    return false;
+  const { callee, args } = body;
+  if (callee.kind !== "member" || callee.computed || callee.property !== "reduce")
+    return false;
+  if (callee.object.kind !== "identifier" || callee.object.name !== partsName)
+    return false;
+  const [callback, init] = args;
+  if (init.kind !== "literal" || init.literalType !== "string" || init.value !== "")
+    return false;
+  if (callback.kind !== "arrow" || callback.params.length !== 3)
+    return false;
+  const [acc, p, i] = callback.params;
+  return isInterleaveReduceCallbackBody(callback.body, acc, p, i, argsName);
+}
+function isInterleaveReduceCallbackBody(body, acc, p, i, argsName) {
+  if (body.kind !== "binary" || body.op !== "+")
+    return false;
+  const { left, right } = body;
+  if (left.kind !== "binary" || left.op !== "+")
+    return false;
+  if (left.left.kind !== "identifier" || left.left.name !== acc)
+    return false;
+  if (left.right.kind !== "identifier" || left.right.name !== p)
+    return false;
+  return isInterleaveSpanExpr(right, i, argsName);
+}
+function isInterleaveSpanExpr(expr, i, argsName) {
+  let inner = expr;
+  if (inner.kind === "call" && inner.args.length === 1 && inner.callee.kind === "identifier" && inner.callee.name === "String") {
+    inner = inner.args[0];
+  }
+  if (inner.kind !== "logical" || inner.op !== "??")
+    return false;
+  if (inner.right.kind !== "literal" || inner.right.literalType !== "string" || inner.right.value !== "") {
+    return false;
+  }
+  const idx = inner.left;
+  if (idx.kind !== "index-access")
+    return false;
+  if (idx.object.kind !== "identifier" || idx.object.name !== argsName)
+    return false;
+  if (idx.index.kind !== "identifier" || idx.index.name !== i)
+    return false;
+  return true;
+}
+function buildUntaggedTemplateLiteral(node, ctx) {
+  const template = node.template;
+  let text;
+  if (ts11.isNoSubstitutionTemplateLiteral(template)) {
+    text = "`" + (template.rawText ?? template.text) + "`";
+  } else {
+    let body = template.head.rawText ?? template.head.text;
+    for (const span of template.templateSpans) {
+      const spanText = ctx.getJS(span.expression);
+      body += "${(" + spanText + ") ?? ''}";
+      body += span.literal.rawText ?? span.literal.text;
+    }
+    text = "`" + body + "`";
+  }
+  const wrapped = `const __bf_resolve_tagged__ = (${text})`;
+  const sf = ts11.createSourceFile("__bf_resolve_tagged.tsx", wrapped, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts11.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  const result = ts11.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!ts11.isTemplateExpression(result) && !ts11.isNoSubstitutionTemplateLiteral(result))
+    return null;
+  return result;
+}
 function parseTernary(expr, ctx) {
   const whenTrueValue = getStringValue(expr.whenTrue);
   const whenFalseValue = getStringValue(expr.whenFalse);
@@ -10173,14 +10811,14 @@ function processComponentProps(attributes, ctx) {
         clientOnly = true;
       }
     }
-    const freeIdentifiers = attrFreeIdentifiers(attr);
+    const freeIdentifiers2 = attrFreeIdentifiers(attr);
     props.push({
       name,
       value,
       clientOnly,
       loc: getSourceLocation(attr, ctx.sourceFile, ctx.filePath),
       ...computeReactivityFlags(attr, ctx),
-      ...freeIdentifiers !== undefined && { freeIdentifiers }
+      ...freeIdentifiers2 !== undefined && { freeIdentifiers: freeIdentifiers2 }
     });
   }
   return props;
@@ -10596,7 +11234,7 @@ function decideWrapForChildProp(expandedValue, ctx, prop) {
     return { wrap: true, reason: "props-access" };
   return decideWrapForAttr(expandedValue, ctx, prop);
 }
-function needsEffectWrapper(expr, ctx, freeIdentifiers) {
+function needsEffectWrapper(expr, ctx, freeIdentifiers2) {
   for (const signal of ctx.signals) {
     if (new RegExp(`\\b${signal.getter}\\s*\\(`).test(expr)) {
       return true;
@@ -10610,7 +11248,7 @@ function needsEffectWrapper(expr, ctx, freeIdentifiers) {
   for (const prop of ctx.propsParams) {
     if (prop.name === "children")
       continue;
-    if (freeIdentifiers ? freeIdentifiers.has(prop.name) : tokenContainsIdent(expr, prop.name)) {
+    if (freeIdentifiers2 ? freeIdentifiers2.has(prop.name) : tokenContainsIdent(expr, prop.name)) {
       return true;
     }
   }
@@ -10621,8 +11259,8 @@ function needsEffectWrapper(expr, ctx, freeIdentifiers) {
   }
   return false;
 }
-function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentifiers) {
-  const has = (name) => freeIdentifiers ? freeIdentifiers.has(name) : tokenContainsIdent(expr, name);
+function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentifiers2) {
+  const has = (name) => freeIdentifiers2 ? freeIdentifiers2.has(name) : tokenContainsIdent(expr, name);
   if (loopParamBindings && loopParamBindings.length > 0) {
     for (const b of loopParamBindings) {
       if (has(b.name)) {
@@ -10632,7 +11270,7 @@ function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentif
   } else if (loopParam && has(loopParam)) {
     return { kind: "loop-param", param: loopParam };
   }
-  if (needsEffectWrapper(expr, ctx, freeIdentifiers)) {
+  if (needsEffectWrapper(expr, ctx, freeIdentifiers2)) {
     return { kind: "signal-or-memo-or-prop" };
   }
   return { kind: "none" };
@@ -11214,6 +11852,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       const { useElementReconciliation, innerLoops } = decideLoopRendering(l, siblingOffsets, ctx);
       let template = "";
       let staticItemTemplate;
+      let skeletonTemplate;
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
@@ -11224,6 +11863,11 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, loopParamSpec);
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0);
+        } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
+          skeletonTemplate = buildLoopSkeletonTemplate(l.children[0], {
+            reactiveAttrKeys: new Set(bindings.reactiveAttrs.map((a) => `${a.childSlotId}::${a.attrName}`)),
+            reactiveTextSlotIds: new Set(bindings.reactiveTexts.map((t) => t.slotId))
+          }) ?? undefined;
         }
       }
       ctx.loopElements.push({
@@ -11241,6 +11885,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         iterationShape: l.iterationShape,
         template,
         staticItemTemplate,
+        skeletonTemplate,
         childEventHandlers: childHandlers,
         bindings,
         childComponent: l.childComponent,
@@ -12129,31 +12774,70 @@ function collectComponentNames(node) {
 
 // src/relocate.ts
 import ts13 from "typescript";
-function classify(name, env) {
-  return env.bindings.get(name) ?? "global";
+
+// src/lowering-registry.ts
+var plugins = [];
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0)
+    plugins[existing] = plugin;
+  else
+    plugins.push(plugin);
 }
-function collectFreeRefs(node) {
-  const refs = new Map;
-  function visit3(n, parent) {
-    if (ts13.isIdentifier(n)) {
-      if (parent && ts13.isPropertyAccessExpression(parent) && parent.name === n)
-        return;
-      if (parent && ts13.isPropertyAssignment(parent) && parent.name === n)
-        return;
-      if (parent && ts13.isShorthandPropertyAssignment(parent) && parent.name === n)
-        return;
-      const list = refs.get(n.text) ?? [];
-      list.push(n);
-      refs.set(n.text, list);
-      return;
-    }
-    ts13.forEachChild(n, (child) => visit3(child, n));
-  }
-  visit3(node);
-  return refs;
+function getLoweringPlugins() {
+  return [...plugins];
 }
-function decideAction(kind, toScope, env, name) {
-  if (isVisibleIn(toScope, kind)) {
+function prepareLoweringMatchers(metadata) {
+  const matchers = [];
+  for (const plugin of plugins) {
+    const matcher = plugin.prepare(metadata);
+    if (matcher)
+      matchers.push(matcher);
+  }
+  return matchers;
+}
+function matchLoweringCall(callee, args, metadata) {
+  for (const matcher of prepareLoweringMatchers(metadata)) {
+    const node = matcher(callee, args);
+    if (node)
+      return node;
+  }
+  return null;
+}
+function isValidHelperId(helper) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(helper);
+}
+function __resetLoweringPluginsForTest(next = []) {
+  plugins.length = 0;
+  plugins.push(...next);
+}
+
+// src/relocate.ts
+function classify(name, env) {
+  return env.bindings.get(name) ?? "global";
+}
+function collectFreeRefs(node) {
+  const refs = new Map;
+  function visit3(n, parent) {
+    if (ts13.isIdentifier(n)) {
+      if (parent && ts13.isPropertyAccessExpression(parent) && parent.name === n)
+        return;
+      if (parent && ts13.isPropertyAssignment(parent) && parent.name === n)
+        return;
+      if (parent && ts13.isShorthandPropertyAssignment(parent) && parent.name === n)
+        return;
+      const list = refs.get(n.text) ?? [];
+      list.push(n);
+      refs.set(n.text, list);
+      return;
+    }
+    ts13.forEachChild(n, (child) => visit3(child, n));
+  }
+  visit3(node);
+  return refs;
+}
+function decideAction(kind, toScope, env, name) {
+  if (isVisibleIn(toScope, kind)) {
     return { action: "pass-through", rewrittenAs: name };
   }
   if (kind === "prop" && toScope === "template") {
@@ -12163,6 +12847,14 @@ function decideAction(kind, toScope, env, name) {
     return { action: "lift-to-prop", rewrittenAs: `${PROPS_PARAM}.${name}` };
   }
   if ((kind === "init-local" || kind === "sub-init-local") && toScope === "template") {
+    const aliasTarget = env.aliasTargets?.get(name);
+    if (aliasTarget !== undefined) {
+      const targetLeftmost = aliasTarget.includes(".") ? aliasTarget.split(".")[0] : aliasTarget;
+      const targetKind = classify(targetLeftmost, env);
+      if (isVisibleIn(toScope, targetKind)) {
+        return { action: "inline", rewrittenAs: aliasTarget };
+      }
+    }
     const inlineForm = env.inlinable.get(name);
     if (inlineForm !== undefined) {
       return { action: "inline", rewrittenAs: inlineForm };
@@ -12242,6 +12934,8 @@ function isInlinableInTemplate(value, env) {
   return { ok: true, rewrittenValue: r.text, decisions: r.decisions };
 }
 function getCalleeIdentifierPath(callee) {
+  if (ts13.isParenthesizedExpression(callee))
+    return getCalleeIdentifierPath(callee.expression);
   if (ts13.isIdentifier(callee))
     return callee.text;
   if (ts13.isPropertyAccessExpression(callee)) {
@@ -12253,6 +12947,8 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
+  if (ts13.isParenthesizedExpression(callee))
+    return getCalleeLeftmostIdentifier(callee.expression);
   if (ts13.isIdentifier(callee))
     return callee.text;
   if (ts13.isPropertyAccessExpression(callee)) {
@@ -12266,20 +12962,39 @@ var REGISTRY_SAFE_BINDING_KINDS = new Set([
   "module-local"
 ]);
 function isCallAcceptedByAdapter(call, env) {
-  const name = getCalleeIdentifierPath(call.expression);
-  if (name === null)
+  const originalPath = getCalleeIdentifierPath(call.expression);
+  if (originalPath === null)
     return false;
   const leftmost = getCalleeLeftmostIdentifier(call.expression);
+  let resolvedPath = originalPath;
+  let resolvedLeftmost = leftmost;
   if (leftmost !== null) {
-    const kind = env.bindings.get(leftmost);
+    const aliasTarget = env.aliasTargets?.get(leftmost);
+    if (aliasTarget !== undefined) {
+      resolvedPath = originalPath === leftmost ? aliasTarget : `${aliasTarget}${originalPath.slice(leftmost.length)}`;
+      resolvedLeftmost = aliasTarget.includes(".") ? aliasTarget.split(".")[0] : aliasTarget;
+    }
+  }
+  if (resolvedLeftmost !== null) {
+    const kind = env.bindings.get(resolvedLeftmost);
     if (kind !== undefined && !REGISTRY_SAFE_BINDING_KINDS.has(kind)) {
       return false;
     }
   }
-  if (env.templatePrimitives && env.templatePrimitives[name])
+  if (env.templatePrimitives && env.templatePrimitives[resolvedPath])
     return true;
-  if (env.acceptsTemplateCall && env.acceptsTemplateCall(name))
+  if (env.acceptsTemplateCall && env.acceptsTemplateCall(resolvedPath))
     return true;
+  if (env.loweringMatchers && env.loweringMatchers.length > 0) {
+    const parsed = tsNodeToParsedExpr(call);
+    if (parsed.kind === "call") {
+      const calleeForMatch = resolvedPath !== originalPath && !resolvedPath.includes(".") && parsed.callee.kind === "identifier" ? { kind: "identifier", name: resolvedPath } : parsed.callee;
+      for (const matcher of env.loweringMatchers) {
+        if (matcher(calleeForMatch, parsed.args))
+          return true;
+      }
+    }
+  }
   return false;
 }
 function parseExpressionNode(text) {
@@ -12425,6 +13140,7 @@ function buildRelocateEnvFromIR(metadata, options) {
     env.templatePrimitives = options.templatePrimitives;
   if (options?.acceptsTemplateCall)
     env.acceptsTemplateCall = options.acceptsTemplateCall;
+  env.loweringMatchers = prepareLoweringMatchers(metadata);
   return env;
 }
 function buildRelocateEnvFromFields(src) {
@@ -12473,14 +13189,35 @@ function buildRelocateEnvFromFields(src) {
     if (kind === "prop")
       propsForLift.add(name);
   }
+  const aliasTargets = new Map;
+  for (const c of src.localConstants) {
+    const kind = bindings.get(c.name);
+    if (kind !== "init-local" && kind !== "module-local")
+      continue;
+    const target = identifierPathFromParsed(c.parsed);
+    if (target !== null)
+      aliasTargets.set(c.name, target);
+  }
   return {
     bindings,
     inlinable: new Map,
     propsForLift,
     propsObjectName,
-    allowFallback: true
+    allowFallback: true,
+    aliasTargets
   };
 }
+function identifierPathFromParsed(expr) {
+  if (!expr)
+    return null;
+  if (expr.kind === "identifier")
+    return expr.name;
+  if (expr.kind === "member" && !expr.computed) {
+    const object = identifierPathFromParsed(expr.object);
+    return object === null ? null : `${object}.${expr.property}`;
+  }
+  return null;
+}
 
 // src/ir-to-client-js/compute-inlinability.ts
 function buildEnvFromCtx(ctx) {
@@ -12500,7 +13237,7 @@ function buildEnvFromCtx(ctx) {
     effects: ctx.effects,
     onMounts: ctx.onMounts,
     initStatements: ctx.initStatements,
-    imports: [],
+    imports: ctx.imports,
     templateImports: [],
     namedExports: [],
     localFunctions: ctx.localFunctions,
@@ -12634,9 +13371,9 @@ function populateCsrInlinable(ctx, relocateEnv) {
         continue;
       const env = buildEnvWithConsts();
       const source = c.value.trim();
-      const { rewritten, freeIdentifiers } = csrSubstitute(source, env);
+      const { rewritten, freeIdentifiers: freeIdentifiers2 } = csrSubstitute(source, env);
       let pendingDependency = false;
-      for (const id of freeIdentifiers) {
+      for (const id of freeIdentifiers2) {
         if (id === c.name)
           continue;
         const dep = ctx.localConstants.find((o) => o.name === id);
@@ -12652,7 +13389,7 @@ function populateCsrInlinable(ctx, relocateEnv) {
         ctx.csrInlinable.set(c.name, null);
       } else {
         const bridgedRewritten = inlineResult.rewrittenValue;
-        const bridgedFreeIdentifiers = recomputeFreeIdentifiers(bridgedRewritten, freeIdentifiers);
+        const bridgedFreeIdentifiers = recomputeFreeIdentifiers(bridgedRewritten, freeIdentifiers2);
         ctx.csrInlinable.set(c.name, { rewrittenValue: bridgedRewritten, freeIdentifiers: bridgedFreeIdentifiers });
         constSubs.set(c.name, {
           kind: "identifier",
@@ -13199,14 +13936,26 @@ function sortDeclarations(declarations, declNameSet, graph) {
 var ENV_SIGNAL_CLIENT_FACTORY = {
   search: "createSearchParams"
 };
-function searchParamsLocalNames(metadata) {
+var ENV_SIGNAL_READERS = new Map([
+  ["search", { key: "search", canonicalName: "searchParams", methods: new Set(["get"]) }]
+]);
+function envSignalReaderFor(key) {
+  if (key === undefined)
+    return null;
+  return ENV_SIGNAL_READERS.get(key) ?? null;
+}
+function envSignalLocalNames(metadata, key) {
   const names = new Set;
   for (const s of metadata.signals) {
-    if (s.envReader === "search")
+    if (s.envReader !== undefined && (key === undefined || s.envReader === key)) {
       names.add(s.getter);
+    }
   }
   return names;
 }
+function searchParamsLocalNames(metadata) {
+  return envSignalLocalNames(metadata, "search");
+}
 function importsSearchParams(metadata) {
   return searchParamsLocalNames(metadata).size > 0;
 }
@@ -15249,6 +15998,15 @@ function emitTemplateCloneInline(template) {
   }
   return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`${template}\`; return __tpl.content.firstElementChild.cloneNode(true)`;
 }
+function emitHoistedTemplateDecl(lines, indent, tplVar, skeletonTemplate) {
+  const isSvg = templateRootIsSvg(skeletonTemplate);
+  const html = isSvg ? `<svg>${skeletonTemplate}</svg>` : skeletonTemplate;
+  lines.push(`${indent}const ${tplVar} = document.createElement('template')`);
+  lines.push(`${indent}${tplVar}.innerHTML = \`${html}\``);
+}
+function hoistedCloneExpr(tplVar, skeletonTemplate) {
+  return templateRootIsSvg(skeletonTemplate) ? `${tplVar}.content.firstElementChild.firstElementChild.cloneNode(true)` : `${tplVar}.content.firstElementChild.cloneNode(true)`;
+}
 function emitTemplateCloneLines(template, indent) {
   if (templateRootIsSvg(template)) {
     return [
@@ -15547,6 +16305,7 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     indexParam,
     mapPreambleWrapped,
     template,
+    skeletonTemplate,
     reactiveEffects,
     childRefs,
     bodyIsMultiRoot,
@@ -15557,11 +16316,16 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr);
     return;
   }
+  const hoistedTpl = !bodyIsMultiRoot && skeletonTemplate ? skeletonTemplate : null;
+  const tplVar = `__tpl_${markerId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+  if (hoistedTpl) {
+    emitHoistedTemplateDecl(lines, topIndent, tplVar, hoistedTpl);
+  }
   const loopBfId = plan.profileLoopId ? `, ${JSON.stringify(plan.profileLoopId)}` : "";
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0) {
     const unwrapInline = paramUnwrap ? `${paramUnwrap} ` : "";
     const preamble = mapPreambleWrapped ? `${mapPreambleWrapped}; ` : "";
-    const cloneExpr = emitTemplateCloneInline(template);
+    const cloneExpr = hoistedTpl ? `return ${hoistedCloneExpr(tplVar, hoistedTpl)}` : emitTemplateCloneInline(template);
     lines.push(`${topIndent}mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}${preamble}if (__existing) return __existing; ${cloneExpr} }, '${markerId}'${loopBfId})`);
     return;
   }
@@ -15571,12 +16335,16 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     lines.push(`${bodyIndent}${paramUnwrap}`);
   if (mapPreambleWrapped)
     lines.push(`${bodyIndent}${mapPreambleWrapped}`);
-  emitLoopItemElementSetup(lines, {
-    template,
-    bodyIsMultiRoot,
-    indent: bodyIndent,
-    singleRootLayout: "inline"
-  });
+  if (hoistedTpl) {
+    lines.push(`${bodyIndent}const __el = __existing ?? ${hoistedCloneExpr(tplVar, hoistedTpl)}`);
+  } else {
+    emitLoopItemElementSetup(lines, {
+      template,
+      bodyIsMultiRoot,
+      indent: bodyIndent,
+      singleRootLayout: "inline"
+    });
+  }
   if (reactiveEffects !== null) {
     stringifyReactiveEffects(lines, reactiveEffects, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
   }
@@ -16262,6 +17030,7 @@ function buildPlainLoopPlan(elem, profileComponentName) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.mapPreamble ? wrap(elem.mapPreamble) : "",
     template: elem.template,
+    skeletonTemplate: elem.skeletonTemplate,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
@@ -16868,6 +17637,7 @@ function createContext(ir, scope, adapterCapabilities, profile) {
     initStatements: ir.metadata.initStatements ?? [],
     localFunctions: ir.metadata.localFunctions,
     localConstants: ir.metadata.localConstants,
+    imports: ir.metadata.imports,
     propsParams: ir.metadata.propsParams,
     propsObjectName: ir.metadata.propsObjectName,
     restPropsName: ir.metadata.restPropsName,
@@ -16951,119 +17721,6 @@ ${externalImports.join(`
   return generatedCode.replace(IMPORT_PLACEHOLDER, allImports);
 }
 
-// src/module-exports.ts
-function generateModuleExports(ir, extraInlineExported = new Set, rewriteRelativeImport) {
-  const lines = [];
-  for (const constant of ir.metadata.localConstants) {
-    if (!constant.isExported)
-      continue;
-    const keyword = constant.declarationKind ?? "const";
-    if (!constant.value) {
-      lines.push(`export ${keyword} ${constant.name}`);
-      continue;
-    }
-    const value = constant.value.trim();
-    if (/^createContext\b/.test(value) || /^new WeakMap\b/.test(value))
-      continue;
-    lines.push(`export ${keyword} ${constant.name} = ${constant.value}`);
-  }
-  for (const func of ir.metadata.localFunctions) {
-    if (!func.isExported)
-      continue;
-    const params = func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
-    const returnAnnotation = func.typedReturnType ? `: ${func.typedReturnType}` : "";
-    const body = func.typedBody ?? func.body;
-    const asyncKw = func.isAsync ? "async " : "";
-    lines.push(`export ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
-  }
-  const inlineExported = collectInlineExportedNames(ir);
-  for (const name of extraInlineExported)
-    inlineExported.add(name);
-  for (const block of ir.metadata.namedExports) {
-    const isReexportFrom = block.source !== null;
-    const survivingSpecs = block.specifiers.filter((spec) => {
-      if (isReexportFrom)
-        return true;
-      return !(inlineExported.has(spec.name) && spec.alias == null);
-    });
-    if (survivingSpecs.length === 0)
-      continue;
-    const specText = survivingSpecs.map((s) => {
-      const prefix = s.isTypeOnly ? "type " : "";
-      return s.alias ? `${prefix}${s.name} as ${s.alias}` : `${prefix}${s.name}`;
-    }).join(", ");
-    const typeKw = block.isTypeOnly ? "type " : "";
-    if (isReexportFrom) {
-      const source = rewriteRelativeImport && block.source.startsWith(".") ? rewriteRelativeImport(block.source) : block.source;
-      lines.push(`export ${typeKw}{ ${specText} } from '${source}'`);
-    } else {
-      lines.push(`export ${typeKw}{ ${specText} }`);
-    }
-  }
-  return lines.length > 0 ? lines.join(`
-`) : null;
-}
-function collectInlineExportedNames(ir) {
-  const names = new Set;
-  for (const c of ir.metadata.localConstants) {
-    if (c.isExported)
-      names.add(c.name);
-  }
-  for (const f of ir.metadata.localFunctions) {
-    if (f.isExported)
-      names.add(f.name);
-  }
-  if (ir.metadata.isExported && ir.metadata.componentName) {
-    names.add(ir.metadata.componentName);
-  }
-  return names;
-}
-function formatParamWithType(p) {
-  const rest = p.isRest ? "..." : "";
-  const optional = p.optional ? "?" : "";
-  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
-  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
-  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
-}
-function findReachableNames(primaryRefs, declarations) {
-  const allNames = new Set(declarations.map((d) => d.name));
-  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
-  const reachable = new Set;
-  const queue = [];
-  for (const name of allNames) {
-    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
-      reachable.add(name);
-      queue.push(name);
-    }
-  }
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const body = bodyMap.get(current) || "";
-    for (const name of allNames) {
-      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
-        reachable.add(name);
-        queue.push(name);
-      }
-    }
-  }
-  return reachable;
-}
-function extractFunctionParams(value) {
-  const arrowMatch = value.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
-  if (arrowMatch) {
-    return arrowMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
-  }
-  const singleMatch = value.match(/^(?:async\s*)?(\w+)\s*=>/);
-  if (singleMatch) {
-    return singleMatch[1];
-  }
-  const funcMatch = value.match(/^(?:async\s*)?function\s*\w*\s*\(([^)]*)\)/);
-  if (funcMatch) {
-    return funcMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
-  }
-  return "";
-}
-
 // src/css-layer-prefixer.ts
 function prefixClass(cls, layerName) {
   if (!cls || cls.startsWith("layer-"))
@@ -17571,16 +18228,14 @@ function extractSsrDefaults(metadata) {
     propsLike.add(metadata.propsObjectName);
   for (const p of metadata.propsParams)
     propsLike.add(p.name);
-  if (metadata.propsObjectName === null) {
-    for (const p of metadata.propsParams) {
-      if (p.isRest)
-        continue;
-      if (p.defaultValue !== undefined) {
-        const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
-        out[p.name] = { propName: p.name, value: resultToJsonable(value) };
-      } else {
-        out[p.name] = { propName: p.name, value: null };
-      }
+  for (const p of metadata.propsParams) {
+    if (p.isRest)
+      continue;
+    if (metadata.propsObjectName === null && p.defaultValue !== undefined) {
+      const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
+      out[p.name] = { propName: p.name, value: resultToJsonable(value) };
+    } else {
+      out[p.name] = { propName: p.name, value: null };
     }
   }
   if (metadata.restPropsName) {
@@ -17897,47 +18552,501 @@ function evalNode(node, ctx) {
   return UNRESOLVED;
 }
 
-// src/compiler.ts
-function mergeTemplateImports(lines) {
-  const result = [];
-  const valueIdx = new Map;
-  const valueNames = new Map;
-  const typeIdx = new Map;
-  const typeNames = new Map;
-  const seenOther = new Set;
-  const fold = (src, rawNames, idx, names, render) => {
-    if (!idx.has(src)) {
-      idx.set(src, result.length);
-      names.set(src, new Set);
-      result.push("");
-    }
-    const set = names.get(src);
-    for (const n of rawNames.split(",").map((s) => s.trim()).filter(Boolean))
-      set.add(n);
-    result[idx.get(src)] = render(src, set);
-  };
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line)
+// src/augment-inherited-props.ts
+import ts17 from "typescript";
+function collectContextConsumers(metadata) {
+  const constants = metadata.localConstants ?? [];
+  const contextDefaults = new Map;
+  const contextDefaultKinds = new Map;
+  for (const c of constants) {
+    if (c.systemConstructKind !== "createContext" || c.value === undefined)
       continue;
-    const typeMatch = line.match(/^import\s+type\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
-    const valueMatch = line.match(/^import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
-    if (valueMatch) {
-      fold(valueMatch[2], valueMatch[1], valueIdx, valueNames, (s, n) => `import { ${[...n].join(", ")} } from '${s}'`);
-    } else if (typeMatch) {
-      fold(typeMatch[2], typeMatch[1], typeIdx, typeNames, (s, n) => `import type { ${[...n].join(", ")} } from '${s}'`);
-    } else if (!seenOther.has(line)) {
-      seenOther.add(line);
-      result.push(line);
-    }
+    contextDefaults.set(c.name, parseCreateContextDefault(c.value));
+    if (isObjectLiteralCreateContextDefault(c.value))
+      contextDefaultKinds.set(c.name, "object");
   }
-  return result.filter(Boolean).join(`
-`);
-}
-function compileMultipleComponents(source, filePath, componentNames, options) {
-  const files = [];
-  const errors = [];
-  const adapter = options.adapter;
+  if (contextDefaults.size === 0)
+    return [];
+  const consumers = [];
+  for (const c of constants) {
+    if (c.value === undefined)
+      continue;
+    const ctxName = parseUseContextArg(c.value);
+    if (ctxName === null || !contextDefaults.has(ctxName))
+      continue;
+    consumers.push({
+      localName: c.name,
+      contextName: ctxName,
+      defaultValue: contextDefaults.get(ctxName) ?? null,
+      defaultKind: contextDefaultKinds.get(ctxName)
+    });
+  }
+  return consumers;
+}
+function parseUseContextArg(source) {
+  const expr = parseSingleExpression(source);
+  if (!expr || !ts17.isCallExpression(expr))
+    return null;
+  if (!ts17.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+    return null;
+  if (expr.arguments.length !== 1)
+    return null;
+  const arg = expr.arguments[0];
+  return ts17.isIdentifier(arg) ? arg.text : null;
+}
+function parseCreateContextDefault(source) {
+  const expr = parseSingleExpression(source);
+  if (!expr || !ts17.isCallExpression(expr))
+    return null;
+  if (expr.arguments.length === 0)
+    return null;
+  const arg = expr.arguments[0];
+  if (ts17.isStringLiteral(arg) || ts17.isNoSubstitutionTemplateLiteral(arg))
+    return arg.text;
+  if (ts17.isNumericLiteral(arg))
+    return Number(arg.text);
+  if (arg.kind === ts17.SyntaxKind.TrueKeyword)
+    return true;
+  if (arg.kind === ts17.SyntaxKind.FalseKeyword)
+    return false;
+  return null;
+}
+function isObjectLiteralCreateContextDefault(source) {
+  const expr = parseSingleExpression(source);
+  if (!expr || !ts17.isCallExpression(expr))
+    return false;
+  if (expr.arguments.length === 0)
+    return false;
+  return ts17.isObjectLiteralExpression(expr.arguments[0]);
+}
+function parseSingleExpression(source) {
+  const sf = ts17.createSourceFile("__ctx.ts", `(${source})`, ts17.ScriptTarget.Latest, false);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts17.isExpressionStatement(stmt))
+    return null;
+  let e = stmt.expression;
+  while (ts17.isParenthesizedExpression(e))
+    e = e.expression;
+  return e;
+}
+function augmentInheritedPropAccesses(ir) {
+  const propsObj = ir.metadata.propsObjectName;
+  if (!propsObj)
+    return;
+  const existing = new Set(ir.metadata.propsParams.map((p) => p.name));
+  const bareRefProps = new Set;
+  const booleanAttrProps = new Set;
+  const accessed = new Set;
+  const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, "g");
+  const scan = (s, also) => {
+    if (!s)
+      return;
+    for (const m of s.matchAll(accessRe)) {
+      accessed.add(m[1]);
+      also?.add(m[1]);
+    }
+  };
+  const coalesceLiteralTypes = new Map;
+  const pinCoalesceLiterals = (s) => {
+    if (!s || !s.includes(propsObj))
+      return;
+    const sf = ts17.createSourceFile("__aug.ts", `(${s})`, ts17.ScriptTarget.Latest, false);
+    const visit3 = (n) => {
+      if (ts17.isBinaryExpression(n) && (n.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts17.SyntaxKind.BarBarToken)) {
+        let left = n.left;
+        while (ts17.isParenthesizedExpression(left))
+          left = left.expression;
+        if (ts17.isPropertyAccessExpression(left) && ts17.isIdentifier(left.expression) && left.expression.text === propsObj) {
+          const name = left.name.text;
+          let right = n.right;
+          while (ts17.isParenthesizedExpression(right))
+            right = right.expression;
+          if (ts17.isPrefixUnaryExpression(right))
+            right = right.operand;
+          const kind = ts17.isNumericLiteral(right) ? "number" : right.kind === ts17.SyntaxKind.TrueKeyword || right.kind === ts17.SyntaxKind.FalseKeyword ? "boolean" : ts17.isStringLiteralLike(right) ? "string" : null;
+          if (kind && !coalesceLiteralTypes.has(name))
+            coalesceLiteralTypes.set(name, kind);
+        }
+      }
+      ts17.forEachChild(n, visit3);
+    };
+    visit3(sf);
+  };
+  for (const memo of ir.metadata.memos) {
+    scan(memo.computation);
+    pinCoalesceLiterals(memo.computation);
+  }
+  for (const signal of ir.metadata.signals) {
+    scan(signal.initialValue);
+    pinCoalesceLiterals(signal.initialValue);
+  }
+  for (const stmt of ir.metadata.initStatements ?? [])
+    scan(stmt.body);
+  for (const eff of ir.metadata.effects ?? [])
+    scan(eff.body);
+  for (const c of ir.metadata.localConstants ?? []) {
+    if (c.isModule)
+      continue;
+    scan(c.value);
+    pinCoalesceLiterals(c.value);
+  }
+  const walk = (node) => {
+    if (!node)
+      return;
+    const carrier = node;
+    if (carrier.type === "expression") {
+      scan(carrier.expr);
+      pinCoalesceLiterals(carrier.expr);
+    }
+    scan(carrier.condition, bareRefProps);
+    pinCoalesceLiterals(carrier.condition);
+    scan(carrier.array, bareRefProps);
+    const el = node;
+    for (const prop of node.props ?? []) {
+      const v = prop.value;
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === "string")
+            scan(part.value);
+          else if (part.type === "ternary") {
+            scan(part.condition);
+            scan(part.whenTrue);
+            scan(part.whenFalse);
+          } else if (part.type === "lookup")
+            scan(part.key);
+        }
+      }
+      if (v?.kind === "expression" && typeof v.expr === "string") {
+        scan(v.expr, bareRefProps);
+        pinCoalesceLiterals(v.expr);
+      }
+    }
+    for (const attr of el.attrs ?? []) {
+      const v = attr.value;
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === "string")
+            scan(part.value);
+          else if (part.type === "ternary") {
+            scan(part.condition);
+            scan(part.whenTrue);
+            scan(part.whenFalse);
+          } else if (part.type === "lookup")
+            scan(part.key);
+        }
+      }
+      if (v?.kind === "expression" && typeof v.expr === "string") {
+        scan(v.expr);
+        const expr = v.expr.trim();
+        const prefix = `${propsObj}.`;
+        if (isBooleanAttr(attr.name) || v.presenceOrUndefined) {
+          const m = expr.match(new RegExp(`^${propsObj}\\.([A-Za-z_$][\\w$]*)`));
+          if (m)
+            booleanAttrProps.add(m[1]);
+        } else if (expr.startsWith(prefix)) {
+          const rest = expr.slice(prefix.length);
+          if (/^[A-Za-z_$][\w$]*$/.test(rest))
+            bareRefProps.add(rest);
+        }
+      }
+    }
+    for (const child of el.children ?? []) {
+      const c = child;
+      walk(c.element ?? child);
+    }
+    const branchy = node;
+    walk(branchy.whenTrue);
+    walk(branchy.whenFalse);
+    walk(branchy.consequent);
+    walk(branchy.alternate);
+  };
+  walk(ir.root);
+  for (const name of accessed) {
+    if (existing.has(name))
+      continue;
+    let raw;
+    if (booleanAttrProps.has(name))
+      raw = "boolean";
+    else if (coalesceLiteralTypes.has(name))
+      raw = coalesceLiteralTypes.get(name);
+    else if (bareRefProps.has(name))
+      raw = "unknown";
+    else
+      raw = "string";
+    const type = raw === "unknown" ? { kind: "unknown", raw: "unknown" } : { kind: "primitive", raw, primitive: raw };
+    ir.metadata.propsParams.push({ name, type, optional: true });
+    existing.add(name);
+  }
+}
+function parseStaticStringConst(source) {
+  const sf = ts17.createSourceFile("__const.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts17.isVariableStatement(stmt))
+    return null;
+  let init = stmt.declarationList.declarations[0]?.initializer;
+  while (init && ts17.isParenthesizedExpression(init))
+    init = init.expression;
+  if (!init)
+    return null;
+  if (ts17.isStringLiteral(init) || ts17.isNoSubstitutionTemplateLiteral(init)) {
+    return init.text;
+  }
+  return evalStringArrayJoin(source);
+}
+function evalTemplateOfStringConsts(source, resolved) {
+  const sf = ts17.createSourceFile("__const.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts17.isVariableStatement(stmt))
+    return null;
+  let init = stmt.declarationList.declarations[0]?.initializer;
+  while (init && ts17.isParenthesizedExpression(init))
+    init = init.expression;
+  if (!init || !ts17.isTemplateExpression(init))
+    return null;
+  let out = init.head.text;
+  for (const span of init.templateSpans) {
+    if (!ts17.isIdentifier(span.expression))
+      return null;
+    const value = resolved.get(span.expression.text);
+    if (value === undefined)
+      return null;
+    out += value + span.literal.text;
+  }
+  return out;
+}
+function collectModuleStringConsts(constants) {
+  const map = new Map;
+  const candidates = (constants ?? []).filter((c) => c.isModule && c.value !== undefined);
+  let progressed = true;
+  while (progressed) {
+    progressed = false;
+    for (const c of candidates) {
+      if (map.has(c.name))
+        continue;
+      const literal = parseStaticStringConst(c.value) ?? evalTemplateOfStringConsts(c.value, map);
+      if (literal !== null) {
+        map.set(c.name, literal);
+        progressed = true;
+      }
+    }
+  }
+  return map;
+}
+function lookupStaticRecordLiteral(objectName, key, constants) {
+  const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
+  if (constInfo?.value === undefined)
+    return null;
+  const sf = ts17.createSourceFile("__rec.ts", `(${constInfo.value})`, ts17.ScriptTarget.Latest, true);
+  if (sf.statements.length !== 1)
+    return null;
+  const stmt = sf.statements[0];
+  if (!ts17.isExpressionStatement(stmt))
+    return null;
+  let parsed = stmt.expression;
+  while (ts17.isParenthesizedExpression(parsed))
+    parsed = parsed.expression;
+  if (!ts17.isObjectLiteralExpression(parsed))
+    return null;
+  for (const prop of parsed.properties) {
+    if (!ts17.isPropertyAssignment(prop))
+      continue;
+    const name = prop.name;
+    const propKey = ts17.isIdentifier(name) || ts17.isStringLiteral(name) || ts17.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    if (propKey !== key)
+      continue;
+    let v = prop.initializer;
+    while (ts17.isParenthesizedExpression(v))
+      v = v.expression;
+    if (ts17.isNumericLiteral(v))
+      return { kind: "number", text: v.text };
+    if (ts17.isStringLiteral(v) || ts17.isNoSubstitutionTemplateLiteral(v)) {
+      return { kind: "string", text: v.text };
+    }
+    return null;
+  }
+  return null;
+}
+function evalStringArrayJoin(source) {
+  const sf = ts17.createSourceFile("__join.ts", `const __x = (${source});`, ts17.ScriptTarget.Latest, false);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts17.isVariableStatement(stmt))
+    return null;
+  let node = stmt.declarationList.declarations[0]?.initializer;
+  while (node && ts17.isParenthesizedExpression(node))
+    node = node.expression;
+  if (!node || !ts17.isCallExpression(node))
+    return null;
+  const callee = node.expression;
+  if (!ts17.isPropertyAccessExpression(callee))
+    return null;
+  if (callee.name.text !== "join")
+    return null;
+  let recv = callee.expression;
+  while (ts17.isParenthesizedExpression(recv))
+    recv = recv.expression;
+  if (!ts17.isArrayLiteralExpression(recv))
+    return null;
+  const parts = [];
+  for (const el of recv.elements) {
+    if (ts17.isStringLiteral(el) || ts17.isNoSubstitutionTemplateLiteral(el)) {
+      parts.push(el.text);
+    } else {
+      return null;
+    }
+  }
+  let sep2 = ",";
+  if (node.arguments.length >= 1) {
+    const arg = node.arguments[0];
+    if (ts17.isStringLiteral(arg) || ts17.isNoSubstitutionTemplateLiteral(arg))
+      sep2 = arg.text;
+    else
+      return null;
+  }
+  return parts.join(sep2);
+}
+function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
+  if (!ts17.isElementAccessExpression(val))
+    return null;
+  const obj = val.expression;
+  const arg = val.argumentExpression;
+  if (!ts17.isIdentifier(obj) || !ts17.isIdentifier(arg))
+    return null;
+  let indexPropName;
+  let defaultKey;
+  const resolved = resolveKey?.(arg.text);
+  if (resolved) {
+    indexPropName = resolved.propName;
+    defaultKey = resolved.defaultLiteral;
+  } else if (propsParams.some((p) => p.name === arg.text)) {
+    indexPropName = arg.text;
+  } else {
+    return null;
+  }
+  const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
+  if (constInfo?.value === undefined)
+    return null;
+  const sf = ts17.createSourceFile("__rec.ts", `(${constInfo.value})`, ts17.ScriptTarget.Latest, true);
+  if (sf.statements.length !== 1)
+    return null;
+  const stmt = sf.statements[0];
+  if (!ts17.isExpressionStatement(stmt))
+    return null;
+  let parsed = stmt.expression;
+  while (ts17.isParenthesizedExpression(parsed))
+    parsed = parsed.expression;
+  if (!ts17.isObjectLiteralExpression(parsed))
+    return null;
+  const entries = [];
+  for (const prop of parsed.properties) {
+    if (!ts17.isPropertyAssignment(prop))
+      return null;
+    let key;
+    if (ts17.isIdentifier(prop.name)) {
+      key = prop.name.text;
+    } else if (ts17.isStringLiteral(prop.name) || ts17.isNoSubstitutionTemplateLiteral(prop.name)) {
+      key = prop.name.text;
+    } else {
+      return null;
+    }
+    let v = prop.initializer;
+    while (ts17.isParenthesizedExpression(v))
+      v = v.expression;
+    if (ts17.isNumericLiteral(v)) {
+      entries.push({ key, value: { kind: "number", text: v.text } });
+    } else if (ts17.isStringLiteral(v) || ts17.isNoSubstitutionTemplateLiteral(v)) {
+      entries.push({ key, value: { kind: "string", text: v.text } });
+    } else {
+      return null;
+    }
+  }
+  return { indexPropName, entries, defaultKey };
+}
+
+// src/ssr-seed-plan.ts
+function classify2(name, origin, expr, parsed, available) {
+  if (!isSupported(parsed).supported)
+    return { kind: "opaque", name, origin };
+  const frees = freeIdentifiers(parsed);
+  if (frees === null)
+    return { kind: "opaque", name, origin };
+  for (const free of frees) {
+    if (!available.has(free))
+      return { kind: "opaque", name, origin };
+  }
+  return { kind: "derived", name, origin, expr, parsed, frees: [...frees] };
+}
+function computeSsrSeedPlan(metadata) {
+  const baseScope = metadata.propsParams.map((p) => p.name);
+  if (metadata.propsObjectName)
+    baseScope.push(metadata.propsObjectName);
+  for (const name of collectModuleStringConsts(metadata.localConstants).keys()) {
+    baseScope.push(name);
+  }
+  const available = new Set(baseScope);
+  const steps = [];
+  for (const signal of metadata.signals) {
+    if (signal.envReader) {
+      const reader = envSignalReaderFor(signal.envReader);
+      if (reader) {
+        steps.push({ kind: "env-reader", name: signal.getter, reader });
+        available.add(signal.getter);
+        continue;
+      }
+    }
+    const expr = signal.initialValue.trim();
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify2(signal.getter, "signal", expr, parseExpression(expr), available));
+    available.add(signal.getter);
+  }
+  for (const memo of metadata.memos) {
+    const body = extractArrowBodyExpression(memo.computation);
+    const expr = body?.trim() ?? "";
+    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify2(memo.name, "memo", expr, memo.parsed ?? parseExpression(expr), available));
+    available.add(memo.name);
+  }
+  return { baseScope, steps };
+}
+
+// src/compiler.ts
+function mergeTemplateImports(lines) {
+  const result = [];
+  const valueIdx = new Map;
+  const valueNames = new Map;
+  const typeIdx = new Map;
+  const typeNames = new Map;
+  const seenOther = new Set;
+  const fold = (src, rawNames, idx, names, render) => {
+    if (!idx.has(src)) {
+      idx.set(src, result.length);
+      names.set(src, new Set);
+      result.push("");
+    }
+    const set = names.get(src);
+    for (const n of rawNames.split(",").map((s) => s.trim()).filter(Boolean))
+      set.add(n);
+    result[idx.get(src)] = render(src, set);
+  };
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const typeMatch = line.match(/^import\s+type\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
+    const valueMatch = line.match(/^import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
+    if (valueMatch) {
+      fold(valueMatch[2], valueMatch[1], valueIdx, valueNames, (s, n) => `import { ${[...n].join(", ")} } from '${s}'`);
+    } else if (typeMatch) {
+      fold(typeMatch[2], typeMatch[1], typeIdx, typeNames, (s, n) => `import type { ${[...n].join(", ")} } from '${s}'`);
+    } else if (!seenOther.has(line)) {
+      seenOther.add(line);
+      result.push(line);
+    }
+  }
+  return result.filter(Boolean).join(`
+`);
+}
+function compileMultipleComponents(source, filePath, componentNames, options) {
+  const files = [];
+  const errors = [];
+  const adapter = options.adapter;
   const entries = [];
   const program = options.program ?? (needsTypeBasedDetection(source) ? createProgramForFile(source, filePath)?.program : undefined);
   for (const componentName of componentNames) {
@@ -18036,7 +19145,8 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
       files.push({
         path: dir + output.componentName + adapter.extension,
         content: output.rawTemplate,
-        type: "markedTemplate"
+        type: "markedTemplate",
+        componentName: output.componentName
       });
       const ir = entries.find((e) => e.componentIR.metadata.componentName === output.componentName);
       const ssrDefaults = ir ? extractSsrDefaults(ir.componentIR.metadata) : undefined;
@@ -18044,7 +19154,8 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
         files.push({
           path: dir + output.componentName + ".ssr-defaults.json",
           content: JSON.stringify(ssrDefaults),
-          type: "ssrDefaults"
+          type: "ssrDefaults",
+          componentName: output.componentName
         });
       }
     }
@@ -18209,7 +19320,7 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   return { files, errors };
 }
 function buildMetadata(ctx) {
-  return {
+  const metadata = {
     componentName: ctx.componentName || "Unknown",
     hasDefaultExport: ctx.hasDefaultExport,
     isExported: ctx.isExported,
@@ -18231,6 +19342,8 @@ function buildMetadata(ctx) {
     localFunctions: ctx.localFunctions,
     localConstants: ctx.localConstants
   };
+  metadata.ssrSeedPlan = computeSsrSeedPlan(metadata);
+  return metadata;
 }
 function compileJSX(source, filePath, options) {
   const files = [];
@@ -18338,7 +19451,8 @@ function compileJSX(source, filePath, options) {
   files.push({
     path: filePath.replace(/\.tsx?$/, adapter.extension),
     content,
-    type: "markedTemplate"
+    type: "markedTemplate",
+    componentName: componentIR.metadata.componentName
   });
   {
     const ssrDefaults = extractSsrDefaults(componentIR.metadata);
@@ -18346,7 +19460,8 @@ function compileJSX(source, filePath, options) {
       files.push({
         path: filePath.replace(/\.tsx?$/, ".ssr-defaults.json"),
         content: JSON.stringify(ssrDefaults),
-        type: "ssrDefaults"
+        type: "ssrDefaults",
+        componentName: componentIR.metadata.componentName
       });
     }
   }
@@ -18393,7 +19508,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -18414,10 +19529,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts17.ScriptTarget.Latest,
-    module: ts17.ModuleKind.ESNext,
-    moduleResolution: ts17.ModuleResolutionKind.Bundler,
-    jsx: ts17.JsxEmit.ReactJSX,
+    target: ts18.ScriptTarget.Latest,
+    module: ts18.ModuleKind.ESNext,
+    moduleResolution: ts18.ModuleResolutionKind.Bundler,
+    jsx: ts18.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -18427,7 +19542,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts17.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts18.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -18915,7 +20030,7 @@ function emitParsedExpr(expr, emitter) {
       return emitter.objectLiteral(expr.properties, expr.raw, emit);
     case "array-method":
       if (expr.method === "flat") {
-        return emitter.flatMethod(expr.object, expr.flatDepth, emit);
+        return emitter.flatMethod(expr.object, expr.depthExpr ? { expr: expr.depthExpr } : expr.flatDepth, emit);
       }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit);
     case "unsupported":
@@ -18984,42 +20099,9 @@ function isOmitBranch(node) {
   if (node.kind === "identifier")
     return node.name === "undefined";
   if (node.kind === "literal") {
-    return node.literalType === "null" || node.literalType === "string" && node.value === "";
-  }
-  return false;
-}
-// src/lowering-registry.ts
-var plugins = [];
-function registerLoweringPlugin(plugin) {
-  const existing = plugins.findIndex((p) => p.name === plugin.name);
-  if (existing >= 0)
-    plugins[existing] = plugin;
-  else
-    plugins.push(plugin);
-}
-function getLoweringPlugins() {
-  return [...plugins];
-}
-function prepareLoweringMatchers(metadata) {
-  const matchers = [];
-  for (const plugin of plugins) {
-    const matcher = plugin.prepare(metadata);
-    if (matcher)
-      matchers.push(matcher);
-  }
-  return matchers;
-}
-function matchLoweringCall(callee, args, metadata) {
-  for (const matcher of prepareLoweringMatchers(metadata)) {
-    const node = matcher(callee, args);
-    if (node)
-      return node;
-  }
-  return null;
-}
-function __resetLoweringPluginsForTest(next = []) {
-  plugins.length = 0;
-  plugins.push(...next);
+    return node.literalType === "null" || node.literalType === "string" && node.value === "";
+  }
+  return false;
 }
 // src/builtin-lowering-plugins.ts
 var queryHrefPlugin = {
@@ -19095,7 +20177,7 @@ function emitAttrValue(value, emitter, name) {
   }
 }
 // src/combine-client-js.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -19152,10 +20234,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts18.createSourceFile("combine.js", content, ts18.ScriptTarget.Latest, false, ts18.ScriptKind.JS);
+  const sourceFile = ts19.createSourceFile("combine.js", content, ts19.ScriptTarget.Latest, false, ts19.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts18.isImportDeclaration(stmt))
+    if (!ts19.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -19165,8 +20247,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts18.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts18.isNamedImports(bindings)) {
+    const specifier = ts19.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts19.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -19194,8 +20276,7 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
   }
 }
 // src/loop-destructure.ts
-var SIMPLE_FIELD = /^\.[A-Za-z_$][\w$]*$/;
-function isLowerableObjectRestDestructure(loop) {
+function isLowerableLoopDestructure(loop) {
   const bindings = loop.paramBindings;
   if (!bindings || bindings.length === 0)
     return false;
@@ -19207,18 +20288,20 @@ function isLowerableObjectRestDestructure(loop) {
   }
   for (const b of bindings) {
     if (b.rest) {
-      if (b.rest.kind !== "object")
+      if (!b.segments)
         return false;
-    } else if (!SIMPLE_FIELD.test(b.path)) {
+    } else if (!b.segments || b.segments.length === 0) {
       return false;
     }
   }
-  const restNames = bindings.filter((b) => b.rest).map((b) => b.name);
-  if (restNames.length === 0)
+  const objectRestNames = bindings.filter((b) => b.rest?.kind === "object").map((b) => b.name);
+  if (objectRestNames.length === 0)
     return true;
-  return !restNamesMisused(loop, restNames);
+  return !restNamesMisused(loop, objectRestNames);
 }
+var isLowerableObjectRestDestructure = isLowerableLoopDestructure;
 function restNamesMisused(loop, names) {
+  const nameSet = new Set(names);
   const valueUse = names.map((n) => new RegExp(`(?<![\\w.$])${escapeRe(n)}(?!\\s*\\??\\.)(?![\\w$])`));
   let misused = false;
   const check = (s) => {
@@ -19231,7 +20314,10 @@ function restNamesMisused(loop, names) {
       }
     }
   };
-  const attr = (v) => {
+  const attr = (v, isIntrinsicElementAttrs) => {
+    if (v.kind === "spread" && isIntrinsicElementAttrs && nameSet.has(v.expr.trim())) {
+      return;
+    }
     if (v.kind === "expression" || v.kind === "spread") {
       check(v.expr);
       check(v.templateExpr);
@@ -19291,16 +20377,16 @@ function restNamesMisused(loop, names) {
           visit3(node.alternate);
         break;
       case "element":
-        node.attrs.forEach((a) => attr(a.value));
+        node.attrs.forEach((a) => attr(a.value, true));
         node.events.forEach((e) => check(e.handler));
         node.children.forEach(visit3);
         break;
       case "component":
-        node.props.forEach((p) => attr(p.value));
+        node.props.forEach((p) => attr(p.value, false));
         node.children.forEach(visit3);
         break;
       case "provider":
-        attr(node.valueProp.value);
+        attr(node.valueProp.value, false);
         node.children.forEach(visit3);
         break;
       case "fragment":
@@ -19325,7 +20411,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -20610,7 +21696,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts19.createSourceFile("__attr.tsx", `(${expr})`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TSX);
+    sf = ts20.createSourceFile("__attr.tsx", `(${expr})`, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -20618,11 +21704,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts19.isPropertyAccessExpression(n) && ts19.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts20.isPropertyAccessExpression(n) && ts20.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts19.forEachChild(n, visit3);
+    ts20.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -20692,7 +21778,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -20962,15 +22048,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts20.createSourceFile(filePath, source, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TSX);
+  const sf = ts21.createSourceFile(filePath, source, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts20.isCallExpression(node) && ts20.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts21.isCallExpression(node) && ts21.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -21278,13 +22364,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts20.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts20.ScriptTarget.Latest, true);
+    sf = ts21.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts21.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts20.isCallExpression(node) && ts20.isIdentifier(node.expression)) {
+    if (ts21.isCallExpression(node) && ts21.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -21293,7 +22379,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -21658,608 +22744,273 @@ function computeMetrics(graph, eventSummary, hydrated) {
     maxSignalFanOut: maxFanOut,
     hotSignal,
     maxMemoChainDepth,
-    totalSubscriptions,
-    batchCandidateCount
-  };
-}
-function computeMaxMemoChainDepth(graph) {
-  if (graph.memos.length === 0)
-    return 0;
-  const memoSet = new Set(graph.memos.map((m) => m.name));
-  const memoDeps = new Map;
-  for (const memo of graph.memos) {
-    memoDeps.set(memo.name, memo.deps.filter((d) => memoSet.has(d)));
-  }
-  const cache = new Map;
-  function depth(name, visited) {
-    if (cache.has(name))
-      return cache.get(name);
-    if (visited.has(name))
-      return 0;
-    const children = memoDeps.get(name) ?? [];
-    if (children.length === 0) {
-      cache.set(name, 1);
-      return 1;
-    }
-    visited.add(name);
-    const d = 1 + Math.max(...children.map((c) => depth(c, new Set(visited))));
-    cache.set(name, d);
-    return d;
-  }
-  let max = 0;
-  for (const memo of graph.memos) {
-    const d = depth(memo.name, new Set);
-    if (d > max)
-      max = d;
-  }
-  return max;
-}
-function computeFindings(metrics, graph, eventSummary) {
-  const findings = [];
-  for (const signal of graph.signals) {
-    if (signal.consumers.length > THRESHOLDS.highFanOut) {
-      findings.push({
-        kind: "high-fan-out",
-        severity: "warning",
-        signal: signal.name,
-        message: `${signal.name} has ${signal.consumers.length} consumers (fan-out > ${THRESHOLDS.highFanOut})`,
-        suggestion: `Split ${signal.name} into finer-grained signals, or add a createMemo to shield downstream consumers from unrelated updates`,
-        loc: { file: signal.loc.file, line: signal.loc.line }
-      });
-    }
-  }
-  if (metrics.maxMemoChainDepth > THRESHOLDS.deepMemoChain) {
-    findings.push({
-      kind: "deep-memo-chain",
-      severity: "warning",
-      depth: metrics.maxMemoChainDepth,
-      message: `Memo chain depth ${metrics.maxMemoChainDepth} (threshold: ${THRESHOLDS.deepMemoChain}) — a single signal update cascades through ${metrics.maxMemoChainDepth} memo levels`,
-      suggestion: "Flatten intermediate memos that do not cache expensive computations; deep chains increase propagation latency"
-    });
-  }
-  const batchSeen = new Set;
-  for (const event of eventSummary.events) {
-    const distinct = new Set;
-    const setterNames = [];
-    for (const sc of event.setterCalls) {
-      if (sc.signal) {
-        distinct.add(sc.signal);
-        setterNames.push(sc.setter);
-      }
-    }
-    if (distinct.size >= THRESHOLDS.batchMinSignals) {
-      const dedupeKey = `${event.eventName}|${event.loc.file ?? ""}|${event.loc.start.line}|${[...distinct].sort().join(",")}`;
-      if (batchSeen.has(dedupeKey))
-        continue;
-      batchSeen.add(dedupeKey);
-      findings.push({
-        kind: "batch-candidate",
-        severity: "info",
-        signals: [...distinct],
-        message: `${event.eventName} on <${event.elementContext}> sets ${distinct.size} signals (${[...distinct].join(", ")}) — triggers ${distinct.size} separate update cycles (static; verify setters are not in separate if/else branches)`,
-        suggestion: `If all listed setters fire unconditionally in the same handler path, wrap in batch(() => { ${setterNames.join("; ")}; }) to collapse ${distinct.size} cycles into 1`,
-        loc: event.loc.file ? { file: event.loc.file, line: event.loc.start.line } : undefined
-      });
-    }
-  }
-  if (metrics.dynamicBindings > 0 && metrics.fallbacks >= THRESHOLDS.fallbackHeavyMin && metrics.fallbacks / metrics.dynamicBindings > THRESHOLDS.fallbackHeavyRatio) {
-    findings.push({
-      kind: "fallback-heavy",
-      severity: "info",
-      message: `${metrics.fallbacks}/${metrics.dynamicBindings} bindings (${Math.round(metrics.fallbacks / metrics.dynamicBindings * 100)}%) are fallback-wrapped — reactivity not statically provable`,
-      suggestion: "Run `bf debug fallbacks` to see each expression and fix them so the compiler can prove reactivity without the fallback wrapper"
-    });
-  }
-  return findings;
-}
-function diffProfiles(before, after) {
-  const worseWhenHigher = new Set([
-    "fallbacks",
-    "maxSignalFanOut",
-    "maxMemoChainDepth",
-    "totalSubscriptions",
-    "batchCandidateCount"
-  ]);
-  const numericKeys = [
-    "signals",
-    "memos",
-    "effects",
-    "loops",
-    "eventHandlers",
-    "dynamicBindings",
-    "fallbacks",
-    "conditionals",
-    "maxSignalFanOut",
-    "maxMemoChainDepth",
-    "totalSubscriptions",
-    "batchCandidateCount"
-  ];
-  const regressions = [];
-  const improvements = [];
-  const neutral = [];
-  for (const key of numericKeys) {
-    const b = before[key];
-    const a = after[key];
-    if (a === b)
-      continue;
-    const entry = { metric: key, before: b, after: a, delta: a - b };
-    if (worseWhenHigher.has(key)) {
-      if (a > b)
-        regressions.push(entry);
-      else
-        improvements.push(entry);
-    } else {
-      neutral.push(entry);
-    }
-  }
-  return { componentName: after.componentName, before, after, regressions, improvements, neutral };
-}
-function formatSingleProfile(profile) {
-  const m = profile.metrics;
-  const lines = [];
-  lines.push(`${m.componentName} — reactive profile (static)`);
-  if (m.sourceFile)
-    lines.push(`  source: ${m.sourceFile}`);
-  lines.push(`  hydrated: ${m.hydrated ? "yes" : "no"}`);
-  lines.push("");
-  lines.push("  Counts:");
-  lines.push(`    signals:          ${m.signals}`);
-  lines.push(`    memos:            ${m.memos}`);
-  if (m.effects > 0)
-    lines.push(`    effects:          ${m.effects}`);
-  lines.push(`    dynamic bindings: ${m.dynamicBindings}`);
-  if (m.fallbacks > 0)
-    lines.push(`    fallbacks:        ${m.fallbacks}`);
-  if (m.loops > 0)
-    lines.push(`    loops:            ${m.loops}`);
-  if (m.conditionals > 0)
-    lines.push(`    conditionals:     ${m.conditionals}`);
-  if (m.eventHandlers > 0)
-    lines.push(`    event handlers:   ${m.eventHandlers}`);
-  lines.push("");
-  lines.push("  Reactive budget (SR5):");
-  const fanOutSuffix = m.hotSignal ? ` (${m.hotSignal})` : "";
-  lines.push(`    max signal fan-out:   ${m.maxSignalFanOut}${fanOutSuffix}`);
-  lines.push(`    max memo chain depth: ${m.maxMemoChainDepth}`);
-  lines.push(`    total subscriptions:  ${m.totalSubscriptions}`);
-  if (m.batchCandidateCount > 0) {
-    lines.push(`    batch candidates:     ${m.batchCandidateCount} handler(s) set ≥2 signals`);
-  }
-  if (profile.findings.length > 0) {
-    lines.push("");
-    lines.push("  Findings:");
-    for (const f of profile.findings) {
-      const icon = f.severity === "warning" ? "⚠" : "→";
-      lines.push(`    ${icon} [${f.kind}] ${f.message}`);
-      lines.push(`      fix: ${f.suggestion}`);
-      if (f.loc) {
-        const file = f.loc.file.split("/").pop() ?? f.loc.file;
-        lines.push(`      at ${file}:${f.loc.line}`);
-      }
-    }
-  } else {
-    lines.push("");
-    lines.push("  No findings — component is within all thresholds.");
-  }
-  return lines.join(`
-`);
-}
-function formatProfileTable(profiles) {
-  if (profiles.length === 0)
-    return "No components found.";
-  const sorted = [...profiles].sort((a, b) => b.metrics.totalSubscriptions - a.metrics.totalSubscriptions);
-  const lines = [];
-  lines.push("Component               sig  memo  bind  fall  fanOut  chain  subs  batch  findings");
-  lines.push("─".repeat(90));
-  for (const p of sorted) {
-    const m = p.metrics;
-    const name = m.componentName.padEnd(23).slice(0, 23);
-    const findingStr = p.findings.length > 0 ? p.findings.map((f) => f.kind.replace(/-/g, "_")).join(",") : "—";
-    const row = [
-      name,
-      String(m.signals).padStart(3),
-      String(m.memos).padStart(5),
-      String(m.dynamicBindings).padStart(5),
-      String(m.fallbacks).padStart(5),
-      String(m.maxSignalFanOut).padStart(7),
-      String(m.maxMemoChainDepth).padStart(6),
-      String(m.totalSubscriptions).padStart(5),
-      String(m.batchCandidateCount).padStart(6),
-      `  ${findingStr}`
-    ].join("  ");
-    lines.push(row);
-  }
-  const allFindings = sorted.flatMap((p) => p.findings.map((f) => ({ component: p.metrics.componentName, finding: f })));
-  if (allFindings.length > 0) {
-    lines.push("");
-    lines.push("Findings:");
-    for (const { component, finding } of allFindings) {
-      const icon = finding.severity === "warning" ? "⚠" : "→";
-      lines.push(`  ${icon} ${component}: ${finding.message}`);
-      lines.push(`    fix: ${finding.suggestion}`);
-      if (finding.loc) {
-        const file = finding.loc.file.split("/").pop() ?? finding.loc.file;
-        lines.push(`    at ${file}:${finding.loc.line}`);
-      }
-    }
-  } else {
-    lines.push("");
-    lines.push("No findings across all components.");
-  }
-  return lines.join(`
-`);
-}
-function formatProfileDiff(diff) {
-  const lines = [];
-  lines.push(`${diff.componentName} — reactive profile diff (before → after)`);
-  lines.push("");
-  if (diff.regressions.length === 0 && diff.improvements.length === 0 && diff.neutral.length === 0) {
-    lines.push("  No changes in reactive metrics.");
-    return lines.join(`
-`);
-  }
-  if (diff.regressions.length > 0) {
-    lines.push("  Regressions (reactive cost increased):");
-    for (const e of diff.regressions) {
-      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (+${e.delta})`);
-    }
+    totalSubscriptions,
+    batchCandidateCount
+  };
+}
+function computeMaxMemoChainDepth(graph) {
+  if (graph.memos.length === 0)
+    return 0;
+  const memoSet = new Set(graph.memos.map((m) => m.name));
+  const memoDeps = new Map;
+  for (const memo of graph.memos) {
+    memoDeps.set(memo.name, memo.deps.filter((d) => memoSet.has(d)));
   }
-  if (diff.improvements.length > 0) {
-    lines.push("  Improvements (reactive cost decreased):");
-    for (const e of diff.improvements) {
-      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${e.delta})`);
+  const cache = new Map;
+  function depth(name, visited) {
+    if (cache.has(name))
+      return cache.get(name);
+    if (visited.has(name))
+      return 0;
+    const children = memoDeps.get(name) ?? [];
+    if (children.length === 0) {
+      cache.set(name, 1);
+      return 1;
     }
+    visited.add(name);
+    const d = 1 + Math.max(...children.map((c) => depth(c, new Set(visited))));
+    cache.set(name, d);
+    return d;
   }
-  if (diff.neutral.length > 0) {
-    lines.push("  Structural changes (count changes, no clear direction):");
-    for (const e of diff.neutral) {
-      const sign = (e.delta ?? 0) > 0 ? "+" : "";
-      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${sign}${e.delta})`);
-    }
+  let max = 0;
+  for (const memo of graph.memos) {
+    const d = depth(memo.name, new Set);
+    if (d > max)
+      max = d;
   }
-  return lines.join(`
-`);
-}
-function profileToJSON(profile) {
-  return {
-    metrics: profile.metrics,
-    findings: profile.findings
-  };
+  return max;
 }
-// src/augment-inherited-props.ts
-import ts21 from "typescript";
-function collectContextConsumers(metadata) {
-  const constants = metadata.localConstants ?? [];
-  const contextDefaults = new Map;
-  for (const c of constants) {
-    if (c.systemConstructKind !== "createContext" || c.value === undefined)
-      continue;
-    contextDefaults.set(c.name, parseCreateContextDefault(c.value));
+function computeFindings(metrics, graph, eventSummary) {
+  const findings = [];
+  for (const signal of graph.signals) {
+    if (signal.consumers.length > THRESHOLDS.highFanOut) {
+      findings.push({
+        kind: "high-fan-out",
+        severity: "warning",
+        signal: signal.name,
+        message: `${signal.name} has ${signal.consumers.length} consumers (fan-out > ${THRESHOLDS.highFanOut})`,
+        suggestion: `Split ${signal.name} into finer-grained signals, or add a createMemo to shield downstream consumers from unrelated updates`,
+        loc: { file: signal.loc.file, line: signal.loc.line }
+      });
+    }
   }
-  if (contextDefaults.size === 0)
-    return [];
-  const consumers = [];
-  for (const c of constants) {
-    if (c.value === undefined)
-      continue;
-    const ctxName = parseUseContextArg(c.value);
-    if (ctxName === null || !contextDefaults.has(ctxName))
-      continue;
-    consumers.push({
-      localName: c.name,
-      contextName: ctxName,
-      defaultValue: contextDefaults.get(ctxName) ?? null
+  if (metrics.maxMemoChainDepth > THRESHOLDS.deepMemoChain) {
+    findings.push({
+      kind: "deep-memo-chain",
+      severity: "warning",
+      depth: metrics.maxMemoChainDepth,
+      message: `Memo chain depth ${metrics.maxMemoChainDepth} (threshold: ${THRESHOLDS.deepMemoChain}) — a single signal update cascades through ${metrics.maxMemoChainDepth} memo levels`,
+      suggestion: "Flatten intermediate memos that do not cache expensive computations; deep chains increase propagation latency"
     });
   }
-  return consumers;
-}
-function parseUseContextArg(source) {
-  const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
-    return null;
-  if (!ts21.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
-    return null;
-  if (expr.arguments.length !== 1)
-    return null;
-  const arg = expr.arguments[0];
-  return ts21.isIdentifier(arg) ? arg.text : null;
-}
-function parseCreateContextDefault(source) {
-  const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
-    return null;
-  if (expr.arguments.length === 0)
-    return null;
-  const arg = expr.arguments[0];
-  if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
-    return arg.text;
-  if (ts21.isNumericLiteral(arg))
-    return Number(arg.text);
-  if (arg.kind === ts21.SyntaxKind.TrueKeyword)
-    return true;
-  if (arg.kind === ts21.SyntaxKind.FalseKeyword)
-    return false;
-  return null;
-}
-function parseSingleExpression(source) {
-  const sf = ts21.createSourceFile("__ctx.ts", `(${source})`, ts21.ScriptTarget.Latest, false);
-  const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt))
-    return null;
-  let e = stmt.expression;
-  while (ts21.isParenthesizedExpression(e))
-    e = e.expression;
-  return e;
-}
-function augmentInheritedPropAccesses(ir) {
-  const propsObj = ir.metadata.propsObjectName;
-  if (!propsObj)
-    return;
-  const existing = new Set(ir.metadata.propsParams.map((p) => p.name));
-  const bareRefProps = new Set;
-  const booleanAttrProps = new Set;
-  const accessed = new Set;
-  const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, "g");
-  const scan = (s) => {
-    if (!s)
-      return;
-    for (const m of s.matchAll(accessRe))
-      accessed.add(m[1]);
-  };
-  for (const memo of ir.metadata.memos)
-    scan(memo.computation);
-  for (const signal of ir.metadata.signals)
-    scan(signal.initialValue);
-  for (const stmt of ir.metadata.initStatements ?? [])
-    scan(stmt.body);
-  for (const eff of ir.metadata.effects ?? [])
-    scan(eff.body);
-  for (const c of ir.metadata.localConstants ?? []) {
-    if (c.isModule)
-      continue;
-    scan(c.value);
-  }
-  const walk = (node) => {
-    if (!node)
-      return;
-    const el = node;
-    for (const attr of el.attrs ?? []) {
-      const v = attr.value;
-      if (v?.parts) {
-        for (const part of v.parts) {
-          if (part.type === "string")
-            scan(part.value);
-          else if (part.type === "ternary") {
-            scan(part.condition);
-            scan(part.whenTrue);
-            scan(part.whenFalse);
-          } else if (part.type === "lookup")
-            scan(part.key);
-        }
-      }
-      if (v?.kind === "expression" && typeof v.expr === "string") {
-        scan(v.expr);
-        const expr = v.expr.trim();
-        const prefix = `${propsObj}.`;
-        if (isBooleanAttr(attr.name) || v.presenceOrUndefined) {
-          const m = expr.match(new RegExp(`^${propsObj}\\.([A-Za-z_$][\\w$]*)`));
-          if (m)
-            booleanAttrProps.add(m[1]);
-        } else if (expr.startsWith(prefix)) {
-          const rest = expr.slice(prefix.length);
-          if (/^[A-Za-z_$][\w$]*$/.test(rest))
-            bareRefProps.add(rest);
-        }
+  const batchSeen = new Set;
+  for (const event of eventSummary.events) {
+    const distinct = new Set;
+    const setterNames = [];
+    for (const sc of event.setterCalls) {
+      if (sc.signal) {
+        distinct.add(sc.signal);
+        setterNames.push(sc.setter);
       }
     }
-    for (const child of el.children ?? []) {
-      const c = child;
-      walk(c.element ?? child);
+    if (distinct.size >= THRESHOLDS.batchMinSignals) {
+      const dedupeKey = `${event.eventName}|${event.loc.file ?? ""}|${event.loc.start.line}|${[...distinct].sort().join(",")}`;
+      if (batchSeen.has(dedupeKey))
+        continue;
+      batchSeen.add(dedupeKey);
+      findings.push({
+        kind: "batch-candidate",
+        severity: "info",
+        signals: [...distinct],
+        message: `${event.eventName} on <${event.elementContext}> sets ${distinct.size} signals (${[...distinct].join(", ")}) — triggers ${distinct.size} separate update cycles (static; verify setters are not in separate if/else branches)`,
+        suggestion: `If all listed setters fire unconditionally in the same handler path, wrap in batch(() => { ${setterNames.join("; ")}; }) to collapse ${distinct.size} cycles into 1`,
+        loc: event.loc.file ? { file: event.loc.file, line: event.loc.start.line } : undefined
+      });
     }
-    const branchy = node;
-    walk(branchy.whenTrue);
-    walk(branchy.whenFalse);
-    walk(branchy.consequent);
-    walk(branchy.alternate);
-  };
-  walk(ir.root);
-  for (const name of accessed) {
-    if (existing.has(name))
-      continue;
-    let raw;
-    if (booleanAttrProps.has(name))
-      raw = "boolean";
-    else if (bareRefProps.has(name))
-      raw = "unknown";
-    else
-      raw = "string";
-    const type = raw === "boolean" ? { kind: "primitive", raw: "boolean", primitive: "boolean" } : raw === "string" ? { kind: "primitive", raw: "string", primitive: "string" } : { kind: "unknown", raw: "unknown" };
-    ir.metadata.propsParams.push({ name, type, optional: true });
-    existing.add(name);
   }
+  if (metrics.dynamicBindings > 0 && metrics.fallbacks >= THRESHOLDS.fallbackHeavyMin && metrics.fallbacks / metrics.dynamicBindings > THRESHOLDS.fallbackHeavyRatio) {
+    findings.push({
+      kind: "fallback-heavy",
+      severity: "info",
+      message: `${metrics.fallbacks}/${metrics.dynamicBindings} bindings (${Math.round(metrics.fallbacks / metrics.dynamicBindings * 100)}%) are fallback-wrapped — reactivity not statically provable`,
+      suggestion: "Run `bf debug fallbacks` to see each expression and fix them so the compiler can prove reactivity without the fallback wrapper"
+    });
+  }
+  return findings;
 }
-function parseStaticStringConst(source) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
-  const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
-    return null;
-  let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
-    init = init.expression;
-  if (!init)
-    return null;
-  if (ts21.isStringLiteral(init) || ts21.isNoSubstitutionTemplateLiteral(init)) {
-    return init.text;
+function diffProfiles(before, after) {
+  const worseWhenHigher = new Set([
+    "fallbacks",
+    "maxSignalFanOut",
+    "maxMemoChainDepth",
+    "totalSubscriptions",
+    "batchCandidateCount"
+  ]);
+  const numericKeys = [
+    "signals",
+    "memos",
+    "effects",
+    "loops",
+    "eventHandlers",
+    "dynamicBindings",
+    "fallbacks",
+    "conditionals",
+    "maxSignalFanOut",
+    "maxMemoChainDepth",
+    "totalSubscriptions",
+    "batchCandidateCount"
+  ];
+  const regressions = [];
+  const improvements = [];
+  const neutral = [];
+  for (const key of numericKeys) {
+    const b = before[key];
+    const a = after[key];
+    if (a === b)
+      continue;
+    const entry = { metric: key, before: b, after: a, delta: a - b };
+    if (worseWhenHigher.has(key)) {
+      if (a > b)
+        regressions.push(entry);
+      else
+        improvements.push(entry);
+    } else {
+      neutral.push(entry);
+    }
   }
-  return evalStringArrayJoin(source);
+  return { componentName: after.componentName, before, after, regressions, improvements, neutral };
 }
-function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
-  const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
-    return null;
-  let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
-    init = init.expression;
-  if (!init || !ts21.isTemplateExpression(init))
-    return null;
-  let out = init.head.text;
-  for (const span of init.templateSpans) {
-    if (!ts21.isIdentifier(span.expression))
-      return null;
-    const value = resolved.get(span.expression.text);
-    if (value === undefined)
-      return null;
-    out += value + span.literal.text;
+function formatSingleProfile(profile) {
+  const m = profile.metrics;
+  const lines = [];
+  lines.push(`${m.componentName} — reactive profile (static)`);
+  if (m.sourceFile)
+    lines.push(`  source: ${m.sourceFile}`);
+  lines.push(`  hydrated: ${m.hydrated ? "yes" : "no"}`);
+  lines.push("");
+  lines.push("  Counts:");
+  lines.push(`    signals:          ${m.signals}`);
+  lines.push(`    memos:            ${m.memos}`);
+  if (m.effects > 0)
+    lines.push(`    effects:          ${m.effects}`);
+  lines.push(`    dynamic bindings: ${m.dynamicBindings}`);
+  if (m.fallbacks > 0)
+    lines.push(`    fallbacks:        ${m.fallbacks}`);
+  if (m.loops > 0)
+    lines.push(`    loops:            ${m.loops}`);
+  if (m.conditionals > 0)
+    lines.push(`    conditionals:     ${m.conditionals}`);
+  if (m.eventHandlers > 0)
+    lines.push(`    event handlers:   ${m.eventHandlers}`);
+  lines.push("");
+  lines.push("  Reactive budget (SR5):");
+  const fanOutSuffix = m.hotSignal ? ` (${m.hotSignal})` : "";
+  lines.push(`    max signal fan-out:   ${m.maxSignalFanOut}${fanOutSuffix}`);
+  lines.push(`    max memo chain depth: ${m.maxMemoChainDepth}`);
+  lines.push(`    total subscriptions:  ${m.totalSubscriptions}`);
+  if (m.batchCandidateCount > 0) {
+    lines.push(`    batch candidates:     ${m.batchCandidateCount} handler(s) set ≥2 signals`);
   }
-  return out;
-}
-function collectModuleStringConsts(constants) {
-  const map = new Map;
-  const candidates = (constants ?? []).filter((c) => c.isModule && c.value !== undefined);
-  let progressed = true;
-  while (progressed) {
-    progressed = false;
-    for (const c of candidates) {
-      if (map.has(c.name))
-        continue;
-      const literal = parseStaticStringConst(c.value) ?? evalTemplateOfStringConsts(c.value, map);
-      if (literal !== null) {
-        map.set(c.name, literal);
-        progressed = true;
+  if (profile.findings.length > 0) {
+    lines.push("");
+    lines.push("  Findings:");
+    for (const f of profile.findings) {
+      const icon = f.severity === "warning" ? "⚠" : "→";
+      lines.push(`    ${icon} [${f.kind}] ${f.message}`);
+      lines.push(`      fix: ${f.suggestion}`);
+      if (f.loc) {
+        const file = f.loc.file.split("/").pop() ?? f.loc.file;
+        lines.push(`      at ${file}:${f.loc.line}`);
       }
     }
+  } else {
+    lines.push("");
+    lines.push("  No findings — component is within all thresholds.");
   }
-  return map;
+  return lines.join(`
+`);
 }
-function lookupStaticRecordLiteral(objectName, key, constants) {
-  const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
-  if (constInfo?.value === undefined)
-    return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
-  if (sf.statements.length !== 1)
-    return null;
-  const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
-    return null;
-  let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
-    parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
-    return null;
-  for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
-      continue;
-    const name = prop.name;
-    const propKey = ts21.isIdentifier(name) || ts21.isStringLiteral(name) || ts21.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
-    if (propKey !== key)
-      continue;
-    let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
-      v = v.expression;
-    if (ts21.isNumericLiteral(v))
-      return { kind: "number", text: v.text };
-    if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
-      return { kind: "string", text: v.text };
-    }
-    return null;
+function formatProfileTable(profiles) {
+  if (profiles.length === 0)
+    return "No components found.";
+  const sorted = [...profiles].sort((a, b) => b.metrics.totalSubscriptions - a.metrics.totalSubscriptions);
+  const lines = [];
+  lines.push("Component               sig  memo  bind  fall  fanOut  chain  subs  batch  findings");
+  lines.push("─".repeat(90));
+  for (const p of sorted) {
+    const m = p.metrics;
+    const name = m.componentName.padEnd(23).slice(0, 23);
+    const findingStr = p.findings.length > 0 ? p.findings.map((f) => f.kind.replace(/-/g, "_")).join(",") : "—";
+    const row = [
+      name,
+      String(m.signals).padStart(3),
+      String(m.memos).padStart(5),
+      String(m.dynamicBindings).padStart(5),
+      String(m.fallbacks).padStart(5),
+      String(m.maxSignalFanOut).padStart(7),
+      String(m.maxMemoChainDepth).padStart(6),
+      String(m.totalSubscriptions).padStart(5),
+      String(m.batchCandidateCount).padStart(6),
+      `  ${findingStr}`
+    ].join("  ");
+    lines.push(row);
   }
-  return null;
-}
-function evalStringArrayJoin(source) {
-  const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
-  const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
-    return null;
-  let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts21.isParenthesizedExpression(node))
-    node = node.expression;
-  if (!node || !ts21.isCallExpression(node))
-    return null;
-  const callee = node.expression;
-  if (!ts21.isPropertyAccessExpression(callee))
-    return null;
-  if (callee.name.text !== "join")
-    return null;
-  let recv = callee.expression;
-  while (ts21.isParenthesizedExpression(recv))
-    recv = recv.expression;
-  if (!ts21.isArrayLiteralExpression(recv))
-    return null;
-  const parts = [];
-  for (const el of recv.elements) {
-    if (ts21.isStringLiteral(el) || ts21.isNoSubstitutionTemplateLiteral(el)) {
-      parts.push(el.text);
-    } else {
-      return null;
+  const allFindings = sorted.flatMap((p) => p.findings.map((f) => ({ component: p.metrics.componentName, finding: f })));
+  if (allFindings.length > 0) {
+    lines.push("");
+    lines.push("Findings:");
+    for (const { component, finding } of allFindings) {
+      const icon = finding.severity === "warning" ? "⚠" : "→";
+      lines.push(`  ${icon} ${component}: ${finding.message}`);
+      lines.push(`    fix: ${finding.suggestion}`);
+      if (finding.loc) {
+        const file = finding.loc.file.split("/").pop() ?? finding.loc.file;
+        lines.push(`    at ${file}:${finding.loc.line}`);
+      }
     }
+  } else {
+    lines.push("");
+    lines.push("No findings across all components.");
   }
-  let sep2 = ",";
-  if (node.arguments.length >= 1) {
-    const arg = node.arguments[0];
-    if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
-      sep2 = arg.text;
-    else
-      return null;
-  }
-  return parts.join(sep2);
+  return lines.join(`
+`);
 }
-function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts21.isElementAccessExpression(val))
-    return null;
-  const obj = val.expression;
-  const arg = val.argumentExpression;
-  if (!ts21.isIdentifier(obj) || !ts21.isIdentifier(arg))
-    return null;
-  let indexPropName;
-  let defaultKey;
-  const resolved = resolveKey?.(arg.text);
-  if (resolved) {
-    indexPropName = resolved.propName;
-    defaultKey = resolved.defaultLiteral;
-  } else if (propsParams.some((p) => p.name === arg.text)) {
-    indexPropName = arg.text;
-  } else {
-    return null;
+function formatProfileDiff(diff) {
+  const lines = [];
+  lines.push(`${diff.componentName} — reactive profile diff (before → after)`);
+  lines.push("");
+  if (diff.regressions.length === 0 && diff.improvements.length === 0 && diff.neutral.length === 0) {
+    lines.push("  No changes in reactive metrics.");
+    return lines.join(`
+`);
   }
-  const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
-  if (constInfo?.value === undefined)
-    return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
-  if (sf.statements.length !== 1)
-    return null;
-  const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
-    return null;
-  let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
-    parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
-    return null;
-  const entries = [];
-  for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
-      return null;
-    let key;
-    if (ts21.isIdentifier(prop.name)) {
-      key = prop.name.text;
-    } else if (ts21.isStringLiteral(prop.name) || ts21.isNoSubstitutionTemplateLiteral(prop.name)) {
-      key = prop.name.text;
-    } else {
-      return null;
+  if (diff.regressions.length > 0) {
+    lines.push("  Regressions (reactive cost increased):");
+    for (const e of diff.regressions) {
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (+${e.delta})`);
     }
-    let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
-      v = v.expression;
-    if (ts21.isNumericLiteral(v)) {
-      entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
-      entries.push({ key, value: { kind: "string", text: v.text } });
-    } else {
-      return null;
+  }
+  if (diff.improvements.length > 0) {
+    lines.push("  Improvements (reactive cost decreased):");
+    for (const e of diff.improvements) {
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${e.delta})`);
     }
   }
-  return { indexPropName, entries, defaultKey };
+  if (diff.neutral.length > 0) {
+    lines.push("  Structural changes (count changes, no clear direction):");
+    for (const e of diff.neutral) {
+      const sign = (e.delta ?? 0) > 0 ? "+" : "";
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${sign}${e.delta})`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function profileToJSON(profile) {
+  return {
+    metrics: profile.metrics,
+    findings: profile.findings
+  };
 }
 
 // src/index.ts
@@ -22292,6 +23043,7 @@ export {
   parseBlockBodyTolerant,
   parseBlockBody,
   needsTypeBasedDetection,
+  materializeGetterCalls,
   matchSearchParamsMethodCall,
   matchQueryHrefCall,
   matchLoweringCall,
@@ -22301,8 +23053,10 @@ export {
   listComponentFunctions,
   jsxToIR,
   joinProfilerEvents,
+  isValidHelperId,
   isSupported,
   isLowerableObjectRestDestructure,
+  isLowerableLoopDestructure,
   isBooleanAttr,
   importsSearchParams,
   identifierPath,
@@ -22315,6 +23069,7 @@ export {
   generateClientJsWithSourceMap,
   generateClientJs,
   freeVarsInBody,
+  freeIdentifiers,
   formatWhyUpdate,
   formatWastedReReruns,
   formatUpdatePath,
@@ -22343,6 +23098,8 @@ export {
   exprToString,
   evaluateProfileGates,
   evalStringArrayJoin,
+  envSignalReaderFor,
+  envSignalLocalNames,
   enableCompilerInstrumentation,
   emitParsedExpr,
   emitIRNode,
@@ -22355,6 +23112,7 @@ export {
   createProgramForCorpus,
   createError,
   containsHigherOrder,
+  computeSsrSeedPlan,
   compileJSX,
   combineParentChildClientJs,
   collectModuleStringConsts,
@@ -22390,6 +23148,7 @@ export {
   PROFILE_SCHEMA_VERSION,
   JsxAdapter,
   ErrorCodes,
+  ENV_SIGNAL_READERS,
   CALLBACK_METHODS,
   BaseAdapter,
   BUILTIN_LOWERING_PLUGINS,