@barefootjs/jsx 0.13.0 → 0.15.0

package/dist/index.js

@@ -2784,6 +2784,7 @@ var ErrorCodes = {
   JSX_BRANCH_LOCAL_IN_CALLBACK: "BF047",
   SHARED_PROGRAM_REQUIRED: "BF050",
   WRONG_PACKAGE_IMPORT: "BF051",
+  BUILTIN_REQUIRES_IMPORT: "BF054",
   UNDECLARED_INIT_STATEMENT_REFERENCE: "BF052",
   STRIPPED_CLIENT_IMPORT_REFERENCED: "BF053",
   STAGE_REACTIVE_IN_TEMPLATE: "BF060",
@@ -2807,6 +2808,7 @@ var errorMessages = {
   [ErrorCodes.JSX_BRANCH_LOCAL_IN_CALLBACK]: "JSX-typed local declared inside an `if`-block cannot be referenced from a callback body (ref / event handler). " + "Render it as a child instead: `<div ref={...}>{local}</div>`.",
   [ErrorCodes.SHARED_PROGRAM_REQUIRED]: "Shared ts.Program required for type-based reactivity classification. This source imports a Reactive<T>-branded library (e.g. @barefootjs/form) whose getters cannot be classified by regex alone. Pass `options.program` (built via `createProgramForCorpus`) so the analyzer can resolve the brand through the TypeChecker.",
   [ErrorCodes.WRONG_PACKAGE_IMPORT]: "Import from wrong package.",
+  [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " + "The compiler recognises these tags by their import (not by tag name), " + "so an unimported tag with this name is treated as an undeclared component.",
   [ErrorCodes.UNDECLARED_INIT_STATEMENT_REFERENCE]: "Init statement references an undeclared identifier. Declare it at module scope, inside the component, or import it — otherwise ESM strict mode throws ReferenceError at runtime.",
   [ErrorCodes.STRIPPED_CLIENT_IMPORT_REFERENCED]: "Import was stripped from the client bundle but its binding is still referenced. Client components ('use client' .tsx) are not callable as plain functions from imperative .ts modules — render them as JSX from a 'use client' parent instead. If the flagged name is a local shadow rather than the stripped import, please file an issue.",
   [ErrorCodes.STAGE_REACTIVE_IN_TEMPLATE]: "Reactive binding (signal getter or memo) referenced from template scope. The template lambda runs at module scope without the reactive context, so the value cannot be evaluated at SSR. Wrap the JSX expression in /* @client */ to defer it to hydrate, or restructure so the template uses a prop or static value.",
@@ -3822,7 +3824,10 @@ var CLIENT_EXPORTS = new Set([
   "createPortal",
   "isSSRPortal",
   "findSiblingSlot",
-  "cleanupPortalPlaceholder"
+  "cleanupPortalPlaceholder",
+  "searchParams",
+  "Async",
+  "Region"
 ]);
 function collectAmbientGlobals(node, ctx) {
   if (ts7.isVariableStatement(node)) {
@@ -3898,7 +3903,8 @@ function collectImport(node, ctx) {
             name: element.propertyName?.text ?? element.name.text,
             alias: element.propertyName ? element.name.text : null,
             isDefault: false,
-            isNamespace: false
+            isNamespace: false,
+            isTypeOnly: element.isTypeOnly
           });
         }
       }
@@ -5382,6 +5388,60 @@ function extractArrowBodyExpression(source) {
     return null;
   return expr.body.getText(sf).trim();
 }
+function parseProviderObjectLiteral(source) {
+  const sf = ts8.createSourceFile("__provider__.ts", `const __x = (${source});`, ts8.ScriptTarget.Latest, true);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts8.isVariableStatement(stmt))
+    return null;
+  let init = stmt.declarationList.declarations[0]?.initializer;
+  while (init && ts8.isParenthesizedExpression(init))
+    init = init.expression;
+  if (!init || !ts8.isObjectLiteralExpression(init))
+    return null;
+  const isFunctionShaped = (e) => {
+    let v = e;
+    while (ts8.isParenthesizedExpression(v))
+      v = v.expression;
+    if (ts8.isArrowFunction(v) || ts8.isFunctionExpression(v))
+      return true;
+    if (ts8.isBinaryExpression(v) && (v.operatorToken.kind === ts8.SyntaxKind.QuestionQuestionToken || v.operatorToken.kind === ts8.SyntaxKind.BarBarToken)) {
+      return isFunctionShaped(v.left) || isFunctionShaped(v.right);
+    }
+    return false;
+  };
+  const members = [];
+  for (const prop of init.properties) {
+    if (ts8.isShorthandPropertyAssignment(prop)) {
+      members.push({ name: prop.name.text, kind: "expression", expr: prop.name.text });
+      continue;
+    }
+    if (ts8.isMethodDeclaration(prop)) {
+      const name2 = ts8.isIdentifier(prop.name) || ts8.isStringLiteral(prop.name) ? prop.name.text : null;
+      if (name2 === null)
+        return null;
+      members.push({ name: name2, kind: "function" });
+      continue;
+    }
+    if (!ts8.isPropertyAssignment(prop))
+      return null;
+    const name = ts8.isIdentifier(prop.name) || ts8.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (name === null)
+      return null;
+    let v = prop.initializer;
+    while (ts8.isParenthesizedExpression(v))
+      v = v.expression;
+    if (ts8.isArrowFunction(v) && v.parameters.length === 0 && !ts8.isBlock(v.body)) {
+      members.push({ name, kind: "getter", body: v.body.getText(sf).trim() });
+      continue;
+    }
+    if (isFunctionShaped(v)) {
+      members.push({ name, kind: "function" });
+      continue;
+    }
+    members.push({ name, kind: "expression", expr: v.getText(sf).trim() });
+  }
+  return members;
+}
 function cssKebabCase(name) {
   return name.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^ms-/, "-ms-");
 }
@@ -5532,6 +5592,9 @@ function convertNode(node, raw) {
       if (callee.property === "trim") {
         return { kind: "array-method", method: "trim", object: callee.object, args };
       }
+      if (callee.property === "toFixed") {
+        return { kind: "array-method", method: "toFixed", object: callee.object, args };
+      }
       if (callee.property === "split") {
         return { kind: "array-method", method: "split", object: callee.object, args };
       }
@@ -5665,13 +5728,19 @@ function convertNode(node, raw) {
   if (ts8.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const argNode = node.argumentExpression;
+    if (!argNode) {
+      return { kind: "unsupported", raw, reason: "Element access with no index expression" };
+    }
     if (ts8.isNumericLiteral(argNode)) {
       return { kind: "member", object, property: argNode.text, computed: true };
     }
     if (ts8.isStringLiteral(argNode)) {
       return { kind: "member", object, property: argNode.text, computed: true };
     }
-    return { kind: "unsupported", raw, reason: "Complex computed property access" };
+    const index = convertNode(argNode, raw);
+    if (index.kind === "unsupported")
+      return index;
+    return { kind: "index-access", object, index };
   }
   if (ts8.isBinaryExpression(node)) {
     const left = convertNode(node.left, raw);
@@ -6147,6 +6216,8 @@ function findImpureDefaultNode(expr) {
       return null;
     case "member":
       return findImpureDefaultNode(expr.object);
+    case "index-access":
+      return findImpureDefaultNode(expr.object) ?? findImpureDefaultNode(expr.index);
     case "unary":
       return findImpureDefaultNode(expr.argument);
     case "binary":
@@ -6300,6 +6371,10 @@ function collectIdentifiers(expr, out) {
     case "member":
       collectIdentifiers(expr.object, out);
       return;
+    case "index-access":
+      collectIdentifiers(expr.object, out);
+      collectIdentifiers(expr.index, out);
+      return;
     case "binary":
     case "logical":
       collectIdentifiers(expr.left, out);
@@ -6366,6 +6441,8 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
           };
         }
         return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed };
+      case "index-access":
+        return { kind: "index-access", object: walk(e.object), index: walk(e.index) };
       case "binary":
         return { kind: "binary", op: e.op, left: walk(e.left), right: walk(e.right) };
       case "logical":
@@ -6544,6 +6621,15 @@ function checkSupport(expr) {
       }
       return { supported: true, level: "L2" };
     }
+    case "index-access": {
+      const objSupport = checkSupport(expr.object);
+      if (!objSupport.supported)
+        return objSupport;
+      const indexSupport = checkSupport(expr.index);
+      if (!indexSupport.supported)
+        return indexSupport;
+      return { supported: true, level: "L2" };
+    }
     case "binary": {
       const leftSupport = checkSupport(expr.left);
       if (!leftSupport.supported)
@@ -6614,6 +6700,8 @@ function containsHigherOrder(expr) {
       return expr.args.some(containsHigherOrder) || containsHigherOrder(expr.callee);
     case "member":
       return containsHigherOrder(expr.object);
+    case "index-access":
+      return containsHigherOrder(expr.object) || containsHigherOrder(expr.index);
     case "binary":
       return containsHigherOrder(expr.left) || containsHigherOrder(expr.right);
     case "unary":
@@ -6722,6 +6810,8 @@ function exprToString(expr) {
       return `${exprToString(expr.callee)}(${expr.args.map(exprToString).join(", ")})`;
     case "member":
       return `${exprToString(expr.object)}.${expr.property}`;
+    case "index-access":
+      return `${exprToString(expr.object)}[${exprToString(expr.index)}]`;
     case "binary":
       return `${exprToString(expr.left)} ${expr.op} ${exprToString(expr.right)}`;
     case "unary":
@@ -6781,6 +6871,8 @@ function stringifyParsedExpr(expr) {
       const key = /^-?\d+$/.test(expr.property) ? expr.property : JSON.stringify(expr.property);
       return `${obj}[${key}]`;
     }
+    case "index-access":
+      return `${stringifyParsedExpr(expr.object)}[${stringifyParsedExpr(expr.index)}]`;
     case "binary":
       return `${stringifyParsedExpr(expr.left)} ${expr.op} ${stringifyParsedExpr(expr.right)}`;
     case "unary":
@@ -6831,6 +6923,26 @@ function identifierPath(callee) {
   return null;
 }
 
+// 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";
@@ -7269,6 +7381,7 @@ function createTransformContext(analyzer) {
     filePath: analyzer.filePath,
     slotIdCounter: 0,
     asyncIdCounter: 0,
+    regionIdCounter: 0,
     loopMarkerCounter: 0,
     spreadIdCounter: 0,
     isRoot: true,
@@ -7456,14 +7569,72 @@ function transformNode(node, ctx) {
   }
   return null;
 }
+function clientBuiltinTags(ctx) {
+  if (ctx._clientBuiltinTags)
+    return ctx._clientBuiltinTags;
+  const map = new Map;
+  for (const imp of ctx.analyzer.imports) {
+    if (imp.source !== CLIENT_BUILTIN_SOURCE || imp.isTypeOnly)
+      continue;
+    for (const spec of imp.specifiers) {
+      if (spec.isDefault || spec.isNamespace || spec.isTypeOnly)
+        continue;
+      if (isClientBuiltinName(spec.name)) {
+        map.set(spec.alias ?? spec.name, spec.name);
+      }
+    }
+  }
+  ctx._clientBuiltinTags = map;
+  return map;
+}
+function isNameBound(ctx, name) {
+  const a = ctx.analyzer;
+  if (a.ambientGlobals.has(name))
+    return true;
+  if (a.localFunctions.some((f) => f.name === name))
+    return true;
+  if (a.localConstants.some((c) => c.name === name))
+    return true;
+  for (const imp of a.imports) {
+    if (imp.isTypeOnly)
+      continue;
+    for (const spec of imp.specifiers) {
+      if (spec.isTypeOnly)
+        continue;
+      if ((spec.alias ?? spec.name) === name)
+        return true;
+    }
+  }
+  return false;
+}
+function reportBuiltinNotImported(ctx, node, tagName) {
+  ctx.analyzer.errors.push(createError(ErrorCodes.BUILTIN_REQUIRES_IMPORT, getSourceLocation(node, ctx.sourceFile, ctx.filePath), {
+    severity: "error",
+    message: `<${tagName}> must be imported from '${CLIENT_BUILTIN_SOURCE}' to be recognised as a compiler built-in.`,
+    suggestion: {
+      message: `Add: import { ${tagName} } from '${CLIENT_BUILTIN_SOURCE}'`
+    }
+  }));
+}
+function dispatchClientBuiltin(tagName, ctx, diagNode, transformAsync, transformRegion) {
+  const builtin = clientBuiltinTags(ctx).get(tagName);
+  if (builtin === "Async")
+    return transformAsync();
+  if (builtin === "Region")
+    return transformRegion();
+  if (isClientBuiltinName(tagName) && !isNameBound(ctx, tagName)) {
+    reportBuiltinNotImported(ctx, diagNode, tagName);
+  }
+  return null;
+}
 function transformJsxElement(node, ctx) {
   const tagName = node.openingElement.tagName.getText(ctx.sourceFile);
   if (tagName.endsWith(".Provider") && /^[A-Z]/.test(tagName)) {
     return transformProviderElement(node, ctx, tagName);
   }
-  if (tagName === "Async") {
-    return transformAsyncElement(node, ctx);
-  }
+  const builtin = dispatchClientBuiltin(tagName, ctx, node.openingElement, () => transformAsyncElement(node, ctx), () => transformRegionElement(node, ctx));
+  if (builtin)
+    return builtin;
   const isComponent = /^[A-Z]/.test(tagName);
   if (isComponent) {
     const resolved = resolveMemberExpressionTag(node.openingElement.tagName, ctx);
@@ -7498,9 +7669,9 @@ function transformSelfClosingElement(node, ctx) {
   if (tagName.endsWith(".Provider") && /^[A-Z]/.test(tagName)) {
     return transformSelfClosingProviderElement(node, ctx, tagName);
   }
-  if (tagName === "Async") {
-    return transformSelfClosingAsyncElement(node, ctx);
-  }
+  const builtin = dispatchClientBuiltin(tagName, ctx, node, () => transformSelfClosingAsyncElement(node, ctx), () => transformSelfClosingRegionElement(node, ctx));
+  if (builtin)
+    return builtin;
   const isComponent = /^[A-Z]/.test(tagName);
   if (isComponent) {
     const resolved = resolveMemberExpressionTag(node.tagName, ctx);
@@ -7624,6 +7795,44 @@ function transformSelfClosingAsyncElement(node, ctx) {
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
   };
 }
+function regionId(ctx) {
+  return `${computeFileScope(ctx.filePath)}:${ctx.regionIdCounter++}`;
+}
+function transformRegionElement(node, ctx) {
+  const id = regionId(ctx);
+  const needsScope = ctx.isRoot;
+  ctx.isRoot = false;
+  const children = transformChildren(node.children, ctx);
+  return {
+    type: "element",
+    tag: "div",
+    attrs: [],
+    events: [],
+    ref: null,
+    children,
+    slotId: null,
+    needsScope,
+    regionId: id,
+    loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
+  };
+}
+function transformSelfClosingRegionElement(node, ctx) {
+  const id = regionId(ctx);
+  const needsScope = ctx.isRoot;
+  ctx.isRoot = false;
+  return {
+    type: "element",
+    tag: "div",
+    attrs: [],
+    events: [],
+    ref: null,
+    children: [],
+    slotId: null,
+    needsScope,
+    regionId: id,
+    loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
+  };
+}
 function transformComponentElement(node, ctx, name) {
   const props = processComponentProps(node.openingElement.attributes, ctx);
   ctx.isRoot = false;
@@ -11406,6 +11615,8 @@ function collectUserDomImports(ir) {
     if (runtimeSources.has(imp.source) && !imp.isTypeOnly) {
       for (const spec of imp.specifiers) {
         if (!spec.isDefault && !spec.isNamespace) {
+          if (isClientBuiltinName(spec.name))
+            continue;
           userImports.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
         }
       }
@@ -16842,6 +17053,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 // src/ssr-defaults.ts
 import ts16 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
+var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
   const out = {};
   const propsLike = new Set;
@@ -16938,6 +17150,34 @@ function tryStaticEval(expr, ctx) {
     return UNRESOLVED;
   return evalNode(node, ctx);
 }
+function evalStatementsForReturn(statements, ctx) {
+  for (const stmt of statements) {
+    if (ts16.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (!ts16.isIdentifier(d.name) || !d.initializer)
+          continue;
+        const v = evalNode(d.initializer, ctx);
+        if (v !== UNRESOLVED)
+          ctx.bindings[d.name.text] = v;
+      }
+    } else if (ts16.isReturnStatement(stmt)) {
+      return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
+    } else if (ts16.isIfStatement(stmt)) {
+      const cond = evalNode(stmt.expression, ctx);
+      if (cond === UNRESOLVED)
+        return UNRESOLVED;
+      const branch = cond ? stmt.thenStatement : stmt.elseStatement;
+      if (branch) {
+        const taken = evalStatementsForReturn(ts16.isBlock(branch) ? branch.statements : [branch], ctx);
+        if (taken !== NO_RETURN)
+          return taken;
+      }
+    } else {
+      return UNRESOLVED;
+    }
+  }
+  return NO_RETURN;
+}
 function parseExpression2(expr) {
   const sf = ts16.createSourceFile("__ssr_default__.ts", `(${expr})`, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.TS);
   const stmt = sf.statements[0];
@@ -16964,22 +17204,8 @@ function evalNode(node, ctx) {
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
-    for (const stmt of node.body.statements) {
-      if (ts16.isVariableStatement(stmt)) {
-        for (const d of stmt.declarationList.declarations) {
-          if (!ts16.isIdentifier(d.name) || !d.initializer)
-            continue;
-          const v = evalNode(d.initializer, localCtx);
-          if (v !== UNRESOLVED)
-            localBindings[d.name.text] = v;
-        }
-      } else if (ts16.isReturnStatement(stmt)) {
-        return stmt.expression ? evalNode(stmt.expression, localCtx) : UNRESOLVED;
-      } else {
-        return UNRESOLVED;
-      }
-    }
-    return UNRESOLVED;
+    const result = evalStatementsForReturn(node.body.statements, localCtx);
+    return result === NO_RETURN ? UNRESOLVED : result;
   }
   if (ts16.isNumericLiteral(node))
     return Number(node.text);
@@ -17488,7 +17714,7 @@ function buildMetadata(ctx) {
     onMounts: ctx.onMounts,
     initStatements: ctx.initStatements,
     imports: ctx.imports,
-    templateImports: ctx.imports,
+    templateImports: stripClientBuiltinImports(ctx.imports),
     namedExports: ctx.namedExports,
     localFunctions: ctx.localFunctions,
     localConstants: ctx.localConstants
@@ -18144,6 +18370,8 @@ function emitParsedExpr(expr, emitter) {
       return emitter.call(expr.callee, expr.args, emit);
     case "member":
       return emitter.member(expr.object, expr.property, expr.computed, emit);
+    case "index-access":
+      return emitter.indexAccess(expr.object, expr.index, emit);
     case "binary":
       return emitter.binary(expr.op, expr.left, expr.right, emit);
     case "unary":
@@ -18182,6 +18410,33 @@ function emitParsedExpr(expr, emitter) {
     }
   }
 }
+// src/adapters/env-signal.ts
+function searchParamsLocalNames(metadata) {
+  const names = new Set;
+  for (const imp of metadata.imports) {
+    if (imp.source !== "@barefootjs/client" || imp.isTypeOnly)
+      continue;
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault)
+        continue;
+      if (s.name === "searchParams")
+        names.add(s.alias ?? s.name);
+    }
+  }
+  return names;
+}
+function importsSearchParams(metadata) {
+  return searchParamsLocalNames(metadata).size > 0;
+}
+function matchSearchParamsMethodCall(callee, args, localNames) {
+  if (callee.kind !== "member" || callee.computed)
+    return null;
+  const recv = callee.object;
+  if (recv.kind !== "call" || recv.args.length !== 0 || recv.callee.kind !== "identifier" || !localNames.has(recv.callee.name)) {
+    return null;
+  }
+  return { method: callee.property, args };
+}
 // src/adapters/ir-node-emitter.ts
 function emitIRNode(node, emitter, ctx) {
   const emit = (child, childCtx) => emitIRNode(child, emitter, childCtx);
@@ -19836,6 +20091,7 @@ function findSourceFile2(meta) {
 }
 // src/profiler.ts
 import ts20 from "typescript";
+var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
   const threshold = options.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
@@ -19847,11 +20103,18 @@ function buildStaticBudget(source, filePath, componentName, options = {}) {
     const { direct, total } = subscriberCounts(graph, s.name);
     return { signal: s.name, subscribers: total, direct, hot: direct >= threshold, loc: s.loc };
   }).sort((a, b) => b.subscribers - a.subscribers);
+  const handlers = graph.domBindings.filter((b) => b.type === "event").flatMap((b) => {
+    if (!b.loc)
+      return [];
+    const eventName = b.label.match(/^(\w+)\s+handler/)?.[1] ?? "event";
+    return [{ name: `${eventName}@${b.slotId}`, loc: { file: b.loc.file, line: b.loc.start.line } }];
+  });
   const { depth, chain } = longestMemoChain(graph);
   const hasReactiveState = graph.signals.length > 0 || graph.memos.length > 0;
   const observedInComponent = graph.signals.some((s) => transitiveSubscriberCount(graph, s.name) > 0) || graph.memos.some((m) => transitiveSubscriberCount(graph, m.name) > 0);
   const crossComponentOnly = hasReactiveState && !observedInComponent;
   return {
+    schemaVersion: PROFILE_SCHEMA_VERSION,
     componentName: summary.componentName,
     sourceFile: summary.sourceFile,
     kind: "static-budget",
@@ -19863,6 +20126,7 @@ function buildStaticBudget(source, filePath, componentName, options = {}) {
     memoChainDepth: depth,
     memoChainLongest: chain,
     fanOut,
+    handlers,
     crossComponentOnly
   };
 }
@@ -19939,6 +20203,13 @@ function formatStaticBudget(b) {
       lines.push(`    ${f.signal.padEnd(12)} → ${f.subscribers} subscribers${detail}${f.hot ? "   ⚠ high" : ""}`);
     }
   }
+  if (b.handlers.length > 0) {
+    lines.push(`  handlers (${b.handlers.length}):`);
+    for (const h of b.handlers) {
+      const file = h.loc.file.split("/").pop() ?? h.loc.file;
+      lines.push(`    ${h.name.padEnd(16)} ${file}:${h.loc.line}`);
+    }
+  }
   if (b.crossComponentOnly) {
     lines.push(`  ⓘ compound: ${b.signals} signal(s) / ${b.memos} memo(s) but 0 in-component subscriptions —`);
     lines.push("    consumers are likely in composed child components (or it is read only from handlers);");
@@ -19962,6 +20233,7 @@ function diffStaticBudget(base, head) {
   fanOut.sort((a, b) => b.after - b.before - (a.after - a.before));
   const d = {
     kind: "diff",
+    schemaVersion: PROFILE_SCHEMA_VERSION,
     componentName: head.componentName,
     signals: head.signals - base.signals,
     memos: head.memos - base.memos,
@@ -20531,6 +20803,7 @@ function buildProfileReport(input) {
   }
   return {
     kind: "profile",
+    schemaVersion: PROFILE_SCHEMA_VERSION,
     componentName: primary.componentName,
     sourceFile: primary.sourceFile,
     scenario,
@@ -21002,6 +21275,18 @@ function augmentInheritedPropAccesses(ir) {
     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();
@@ -21021,6 +21306,11 @@ function augmentInheritedPropAccesses(ir) {
       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) {
@@ -21038,6 +21328,94 @@ function augmentInheritedPropAccesses(ir) {
     existing.add(name);
   }
 }
+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;
+  }
+  return evalStringArrayJoin(source);
+}
+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;
+  }
+  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 = 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;
+  }
+  return null;
+}
 function evalStringArrayJoin(source) {
   const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
@@ -21137,6 +21515,7 @@ export {
   traceUpdatePath,
   testAdapter,
   stringifyParsedExpr,
+  searchParamsLocalNames,
   rewriteImportsForTemplate,
   resolveSetters,
   resetCompilerCounters,
@@ -21144,11 +21523,14 @@ export {
   profileToJSON,
   parseStyleObjectEntries,
   parseRecordIndexAccess,
+  parseProviderObjectLiteral,
   parseProfilerId,
   parseExpression,
   parseBlockBody,
   needsTypeBasedDetection,
+  matchSearchParamsMethodCall,
   makeIdCallRegex,
+  lookupStaticRecordLiteral,
   listComponentFunctions as listExportedComponents,
   listComponentFunctions,
   jsxToIR,
@@ -21156,6 +21538,7 @@ export {
   isSupported,
   isLowerableObjectRestDestructure,
   isBooleanAttr,
+  importsSearchParams,
   identifierPath,
   graphToJSON,
   getCompilerCounters,
@@ -21204,6 +21587,7 @@ export {
   containsHigherOrder,
   compileJSX,
   combineParentChildClientJs,
+  collectModuleStringConsts,
   collectContextConsumers,
   buildWhyUpdate,
   buildStaticBudget,
@@ -21231,6 +21615,7 @@ export {
   TestAdapter,
   SourceMapGenerator,
   REACTIVE_PRIMITIVES,
+  PROFILE_SCHEMA_VERSION,
   JsxAdapter,
   ErrorCodes,
   BaseAdapter,