@barefootjs/jsx 0.17.0 → 0.17.1

package/dist/index.js

@@ -352,6 +352,7 @@ function tsNodeToParsedExpr(node) {
 }
 var CALLBACK_METHODS = new Set([
   "filter",
+  "map",
   "every",
   "some",
   "find",
@@ -1813,6 +1814,57 @@ 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) };
+      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);
@@ -1862,8 +1914,13 @@ function freeVarsInBody(body, params) {
         for (const p of e.properties)
           visit(p.value);
         return;
-      case "literal":
       case "array-method":
+        if (e.method === "includes") {
+          visit(e.object);
+          e.args.forEach(visit);
+        }
+        return;
+      case "literal":
       case "arrow":
       case "regex":
       case "unsupported":
@@ -1873,6 +1930,72 @@ function freeVarsInBody(body, params) {
   visit(body);
   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;
+        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([
   "+",
   "-",
@@ -1998,7 +2121,14 @@ 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;
+      }
+      return null;
+    }
     case "arrow":
     case "regex":
     case "unsupported":
@@ -3582,8 +3712,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 +3766,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);
@@ -6301,7 +6431,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 +6439,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 +6523,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 +6572,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,
@@ -9843,14 +9973,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 };
@@ -10173,14 +10303,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 +10726,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 +10740,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 +10751,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 +10762,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" };
@@ -12634,9 +12764,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 +12782,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 +13329,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;
 }
@@ -17897,123 +18039,503 @@ 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;
+  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));
   }
-  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) {
-    const ctx = analyzeComponent(source, filePath, componentName, program);
-    if (!ctx.jsxReturn) {
-      errors.push(...ctx.errors);
+  if (contextDefaults.size === 0)
+    return [];
+  const consumers = [];
+  for (const c of constants) {
+    if (c.value === undefined)
       continue;
-    }
-    const ir = jsxToIR(ctx);
-    errors.push(...ctx.errors);
-    if (!ir)
+    const ctxName = parseUseContextArg(c.value);
+    if (ctxName === null || !contextDefaults.has(ctxName))
       continue;
-    const componentIR = {
-      version: "0.1",
-      metadata: buildMetadata(ctx),
-      root: ir,
-      errors: []
-    };
-    componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
-    if (options.cssLayerPrefix) {
-      applyCssLayerPrefix(componentIR, options.cssLayerPrefix);
-    }
-    entries.push({ componentIR, ctx });
-  }
-  if (options.outputIR) {
-    for (const { componentIR } of entries) {
-      const componentName = componentIR.metadata.componentName;
-      files.push({
-        path: filePath.replace(/\.tsx?$/, `.${componentName}.ir.json`),
-        content: JSON.stringify(componentIR, null, 2),
-        type: "ir"
-      });
-    }
-  }
-  const allOutputs = [];
-  const defaultExportName = entries.find((e) => e.componentIR.metadata.hasDefaultExport)?.componentIR.metadata.componentName;
-  const fileWideInlineExported = new Set;
-  for (const { componentIR } of entries) {
-    for (const name of collectInlineExportedNames(componentIR)) {
-      fileWideInlineExported.add(name);
-    }
-  }
-  const moduleConstantsSet = new Set;
-  const moduleConstantsOrdered = [];
-  const fileScope = computeFileScope(filePath);
-  const nonExportedSiblings = new Set;
-  for (const { componentIR } of entries) {
-    if (!componentIR.metadata.isExported) {
-      nonExportedSiblings.add(componentIR.metadata.componentName);
-    }
+    consumers.push({
+      localName: c.name,
+      contextName: ctxName,
+      defaultValue: contextDefaults.get(ctxName) ?? null
+    });
   }
-  setActiveComponentScope({ fileScope, nonExportedSiblings });
-  const multiAdapterCaps = {
-    templatePrimitives: options.adapter.templatePrimitives,
-    acceptsTemplateCall: options.adapter.acceptsTemplateCall
+  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 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) => {
+    if (!s)
+      return;
+    for (const m of s.matchAll(accessRe))
+      accessed.add(m[1]);
   };
-  try {
-    for (const { componentIR } of entries) {
-      const scriptBaseName = options.scriptBaseName ?? (!componentIR.metadata.hasDefaultExport && defaultExportName ? defaultExportName : undefined);
-      const adapterOutput = adapter.generate(componentIR, {
-        scriptBaseName,
-        siblingTemplatesRegistered: options.siblingTemplatesRegistered,
-        rewriteRelativeImport: options.rewriteRelativeImport
-      });
-      const moduleExports = generateModuleExports(componentIR, fileWideInlineExported, options.rewriteRelativeImport);
-      const s = adapterOutput.sections;
-      const imports = s.imports;
-      const types = s.types;
-      const component = s.component + (s.defaultExport || "");
-      const mc = s.moduleConstants;
-      if (mc && !moduleConstantsSet.has(mc)) {
-        moduleConstantsSet.add(mc);
-        moduleConstantsOrdered.push(mc);
-      }
-      allOutputs.push({
-        componentName: componentIR.metadata.componentName,
+  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);
+        }
+      }
+    }
+    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 (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);
+  }
+}
+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) {
+    const ctx = analyzeComponent(source, filePath, componentName, program);
+    if (!ctx.jsxReturn) {
+      errors.push(...ctx.errors);
+      continue;
+    }
+    const ir = jsxToIR(ctx);
+    errors.push(...ctx.errors);
+    if (!ir)
+      continue;
+    const componentIR = {
+      version: "0.1",
+      metadata: buildMetadata(ctx),
+      root: ir,
+      errors: []
+    };
+    componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
+    if (options.cssLayerPrefix) {
+      applyCssLayerPrefix(componentIR, options.cssLayerPrefix);
+    }
+    entries.push({ componentIR, ctx });
+  }
+  if (options.outputIR) {
+    for (const { componentIR } of entries) {
+      const componentName = componentIR.metadata.componentName;
+      files.push({
+        path: filePath.replace(/\.tsx?$/, `.${componentName}.ir.json`),
+        content: JSON.stringify(componentIR, null, 2),
+        type: "ir"
+      });
+    }
+  }
+  const allOutputs = [];
+  const defaultExportName = entries.find((e) => e.componentIR.metadata.hasDefaultExport)?.componentIR.metadata.componentName;
+  const fileWideInlineExported = new Set;
+  for (const { componentIR } of entries) {
+    for (const name of collectInlineExportedNames(componentIR)) {
+      fileWideInlineExported.add(name);
+    }
+  }
+  const moduleConstantsSet = new Set;
+  const moduleConstantsOrdered = [];
+  const fileScope = computeFileScope(filePath);
+  const nonExportedSiblings = new Set;
+  for (const { componentIR } of entries) {
+    if (!componentIR.metadata.isExported) {
+      nonExportedSiblings.add(componentIR.metadata.componentName);
+    }
+  }
+  setActiveComponentScope({ fileScope, nonExportedSiblings });
+  const multiAdapterCaps = {
+    templatePrimitives: options.adapter.templatePrimitives,
+    acceptsTemplateCall: options.adapter.acceptsTemplateCall
+  };
+  try {
+    for (const { componentIR } of entries) {
+      const scriptBaseName = options.scriptBaseName ?? (!componentIR.metadata.hasDefaultExport && defaultExportName ? defaultExportName : undefined);
+      const adapterOutput = adapter.generate(componentIR, {
+        scriptBaseName,
+        siblingTemplatesRegistered: options.siblingTemplatesRegistered,
+        rewriteRelativeImport: options.rewriteRelativeImport
+      });
+      const moduleExports = generateModuleExports(componentIR, fileWideInlineExported, options.rewriteRelativeImport);
+      const s = adapterOutput.sections;
+      const imports = s.imports;
+      const types = s.types;
+      const component = s.component + (s.defaultExport || "");
+      const mc = s.moduleConstants;
+      if (mc && !moduleConstantsSet.has(mc)) {
+        moduleConstantsSet.add(mc);
+        moduleConstantsOrdered.push(mc);
+      }
+      allOutputs.push({
+        componentName: componentIR.metadata.componentName,
         rawTemplate: adapterOutput.template,
         imports,
         types,
@@ -18209,7 +18731,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 +18753,8 @@ function buildMetadata(ctx) {
     localFunctions: ctx.localFunctions,
     localConstants: ctx.localConstants
   };
+  metadata.ssrSeedPlan = computeSsrSeedPlan(metadata);
+  return metadata;
 }
 function compileJSX(source, filePath, options) {
   const files = [];
@@ -18393,7 +18917,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 +18938,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 +18951,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 {
@@ -19095,7 +19619,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 +19676,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 +19689,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);
       }
@@ -19325,7 +19849,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 +21134,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 +21142,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 +21216,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 +21486,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 +21802,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 +21817,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);
@@ -21664,602 +22188,267 @@ function computeMetrics(graph, eventSummary, hydrated) {
 }
 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})`);
-    }
+    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 +22481,7 @@ export {
   parseBlockBodyTolerant,
   parseBlockBody,
   needsTypeBasedDetection,
+  materializeGetterCalls,
   matchSearchParamsMethodCall,
   matchQueryHrefCall,
   matchLoweringCall,
@@ -22315,6 +22505,7 @@ export {
   generateClientJsWithSourceMap,
   generateClientJs,
   freeVarsInBody,
+  freeIdentifiers,
   formatWhyUpdate,
   formatWastedReReruns,
   formatUpdatePath,
@@ -22343,6 +22534,8 @@ export {
   exprToString,
   evaluateProfileGates,
   evalStringArrayJoin,
+  envSignalReaderFor,
+  envSignalLocalNames,
   enableCompilerInstrumentation,
   emitParsedExpr,
   emitIRNode,
@@ -22355,6 +22548,7 @@ export {
   createProgramForCorpus,
   createError,
   containsHigherOrder,
+  computeSsrSeedPlan,
   compileJSX,
   combineParentChildClientJs,
   collectModuleStringConsts,
@@ -22390,6 +22584,7 @@ export {
   PROFILE_SCHEMA_VERSION,
   JsxAdapter,
   ErrorCodes,
+  ENV_SIGNAL_READERS,
   CALLBACK_METHODS,
   BaseAdapter,
   BUILTIN_LOWERING_PLUGINS,