@barefootjs/jsx 0.33.2 → 0.33.4

package/dist/index.js

@@ -177,7 +177,7 @@ function findTopLevelTemplateLiterals(code) {
 }
 
 // src/compiler.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 
 // src/analyzer.ts
 import ts9 from "typescript";
@@ -2384,11 +2384,16 @@ import {
   loopStartMarker,
   loopEndMarker,
   loopItemMarker,
-  toHTMLAttrName as toHtmlAttrName
+  toHTMLAttrName as toHtmlAttrName,
+  keyAttrName as sharedKeyAttrName
 } from "@barefootjs/shared";
 var PROPS_PARAM = "_p";
-function keyAttrName(loopDepth) {
-  return loopDepth > 0 ? `${DATA_KEY_PREFIX}${loopDepth}` : DATA_KEY;
+var keyAttrName = sharedKeyAttrName;
+function mapArrayKeyArgs(bfIdArg, keyed, loopDepth) {
+  if (!keyed || loopDepth <= 0)
+    return bfIdArg;
+  const bfIdSlot = bfIdArg || ", undefined";
+  return `${bfIdSlot}, ${JSON.stringify(keyAttrName(loopDepth))}`;
 }
 function varSlotId(slotId) {
   return slotId.startsWith("^") ? slotId.slice(1) : slotId;
@@ -3378,6 +3383,14 @@ function escapeAttrValueExpr(valExpr) {
 function escapeTextSlotExpr(innerExpr, isMarkup = false) {
   return `${isMarkup ? "escapeTextOrMarkup" : "escapeText"}(${innerExpr})`;
 }
+function isChildrenPassthroughExpr(expr) {
+  return /^([A-Za-z_$][\w$]*\.)?children$/.test(expr.trim());
+}
+function bareSpliceExpr(node, valueExpr) {
+  const resolved = valueExpr.trim().replace(/^\(+|\)+$/g, "");
+  const isChildren = isChildrenPassthroughExpr(node.expr) || isChildrenPassthroughExpr(resolved);
+  return !node.joinArrayChild && isChildren ? `markupOrEmpty(${valueExpr})` : valueExpr;
+}
 function dangerouslyHtmlChildren(attrs, toExpr) {
   const attr = attrs.find((a) => a.name === "dangerouslySetInnerHTML");
   if (!attr || attr.value.kind !== "expression")
@@ -3425,6 +3438,9 @@ function renderTemplateAttrPart(attr, attrName, wrap, restSpreadNames) {
       return "";
   }
 }
+function resolvedKeyAttrName(node, loopDepth) {
+  return node.keyAttr ? keyAttrName(loopDepth) : null;
+}
 function isMergeableAttr(a, ctx) {
   if (ctx.honorClientOnly && a.clientOnly)
     return false;
@@ -3585,7 +3601,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
     case "element": {
       const mergeCtx = {
         isFilteredSpread: (v) => !!restSpreadNames?.has(v.expr),
-        honorClientOnly: false
+        honorClientOnly: true
       };
       const useMerge = shouldUseSpreadAttrsMerge(node.attrs, mergeCtx);
       const firstMergeableIdx = useMerge ? node.attrs.findIndex((a) => isMergeableAttr(a, mergeCtx)) : -1;
@@ -3596,11 +3612,16 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
         templateExprFor: (v) => wrapExpr(attrValueToString(v) ?? "")
       }) : null;
       const attrParts = node.attrs.map((a, idx) => {
+        if (a.clientOnly)
+          return "";
         if (useMerge && isMergeableAttr(a, mergeCtx)) {
           return idx === firstMergeableIdx ? mergeCall : "";
         }
-        const attrName = a.name === "..." ? "..." : a.name === "key" ? keyAttrName(loopDepth) : toHtmlAttrName(a.name);
-        return renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames);
+        if (a.name === "key") {
+          const attrName = resolvedKeyAttrName(node, loopDepth);
+          return attrName ? renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames) : "";
+        }
+        return renderTemplateAttrPart(a, toHtmlAttrName(a.name), wrapExpr, restSpreadNames);
       }).filter(Boolean);
       const hoistedScopeAttr = maybeHoistedScopeAttr(inHoistedChildren, node);
       if (hoistedScopeAttr)
@@ -3621,17 +3642,18 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
     case "expression": {
       if (node.expr === "null" || node.expr === "undefined")
         return "";
+      const escapeForClient = (e) => node.escapeInClientTemplate ? `escapeText(${e})` : e;
       if (node.markerless) {
-        const bare = wrapInterpolation(wrapExpr(node.expr));
+        const bare = escapeForClient(wrapInterpolation(wrapExpr(node.expr)));
         return `\${${bare}}`;
       }
-      const inner = wrapInterpolation(wrapExpr(node.expr));
+      const inner = escapeForClient(wrapInterpolation(wrapExpr(node.expr)));
       const valueExpr = node.joinArrayChild ? `Array.isArray(${inner}) ? ${inner}.join('') : (${inner} ?? '')` : inner;
       if (node.slotId) {
         const slotted = branchSlotsVar || node.joinArrayChild ? valueExpr : escapeTextSlotExpr(valueExpr);
         return `<!--bf:${node.slotId}-->\${${slotted}}<!--/-->`;
       }
-      return `\${${valueExpr}}`;
+      return `\${${bareSpliceExpr(node, valueExpr)}}`;
     }
     case "conditional": {
       const trueBranch = recurse(node.whenTrue);
@@ -3724,7 +3746,9 @@ function buildLoopSkeletonTemplate(node, safe) {
         if (a.name === "dangerouslySetInnerHTML")
           return null;
         if (a.name === "key") {
-          attrParts.push(`${keyAttrName(0)}=""`);
+          if (resolvedKeyAttrName(node, 0)) {
+            attrParts.push(`${keyAttrName(0)}=""`);
+          }
           continue;
         }
         const v = a.value;
@@ -3930,7 +3954,13 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
   switch (node.type) {
     case "element": {
       const attrParts = node.attrs.map((a) => {
-        const attrName = a.name === "..." ? "..." : a.name === "key" ? keyAttrName(loopDepth) : toHtmlAttrName(a.name);
+        if (a.clientOnly)
+          return "";
+        if (a.name === "key") {
+          const attrName2 = resolvedKeyAttrName(node, loopDepth);
+          return attrName2 ? renderTemplateAttrPart(a, attrName2, wrapExpr, restSpreadNames) : "";
+        }
+        const attrName = a.name === "..." ? "..." : toHtmlAttrName(a.name);
         return renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames);
       }).filter(Boolean);
       if (node.slotId) {
@@ -3953,7 +3983,8 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
       if (node.slotId) {
         return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(wrapped)}}<!--/-->`;
       }
-      return `\${${value}}`;
+      const spliced = bareSpliceExpr(node, value);
+      return `\${${node.escapeInClientTemplate ? `escapeText(${spliced})` : spliced}}`;
     }
     case "conditional": {
       const trueBranch = recurse(node.whenTrue);
@@ -4195,7 +4226,7 @@ function irToComponentTemplateWithOpts(node, opts) {
         const isMarkup = opts.markupSlotIds?.has(node.slotId) ?? false;
         return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(wrapped, isMarkup)}}<!--/-->`;
       }
-      return `\${${value}}`;
+      return `\${${bareSpliceExpr(node, value)}}`;
     }
     case "conditional": {
       if (node.clientOnly && node.slotId) {
@@ -4478,7 +4509,27 @@ function generateCsrTemplateWithOpts(node, opts) {
             return "";
           return `\${spreadAttrs(${transformExpr(v.expr, v.templateExpr)})}`;
         }
-        const attrName = a.name === "key" ? keyAttrName(loopDepth) : toHtmlAttrName(a.name);
+        if (a.name === "key") {
+          const keyName = resolvedKeyAttrName(node, loopDepth);
+          if (!keyName)
+            return "";
+          switch (v.kind) {
+            case "boolean-attr":
+              return keyName;
+            case "literal":
+              return `${keyName}="${escapeHtml(v.value)}"`;
+            case "expression":
+              return templateAttrExpr(keyName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
+            case "template": {
+              const valueStr = attrValueToString(v, { useTemplate: true });
+              return valueStr ? templateAttrExpr(keyName, transformExpr(valueStr)) : "";
+            }
+            case "boolean-shorthand":
+            case "jsx-children":
+              return "";
+          }
+        }
+        const attrName = toHtmlAttrName(a.name);
         switch (v.kind) {
           case "boolean-attr":
             return attrName;
@@ -4526,7 +4577,7 @@ function generateCsrTemplateWithOpts(node, opts) {
           const isMarkup = opts.markupSlotIds?.has(node.slotId) ?? false;
           return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(expr, isMarkup)}}<!--/-->`;
         }
-        return `\${${value}}`;
+        return `\${${bareSpliceExpr(node, value)}}`;
       }
     case "conditional": {
       if (node.clientOnly && node.slotId) {
@@ -4834,6 +4885,19 @@ function buildPropAliasMap(params) {
   }
   return map;
 }
+function resolveRestSpreadOriginCore(bindings, constantValues, name) {
+  const visited = new Set;
+  let current = name.trim();
+  while (current !== undefined && !visited.has(current)) {
+    if (bindings.restPropsName && current === bindings.restPropsName)
+      return "rest";
+    if (bindings.propsObjectName && current === bindings.propsObjectName)
+      return "props";
+    visited.add(current);
+    current = constantValues.get(current)?.trim();
+  }
+  return null;
+}
 
 // src/instrumentation.ts
 var _enabled = false;
@@ -8323,6 +8387,16 @@ function importsBrowserOnlyClientApi(ctx) {
 }
 function listComponentFunctions(source, filePath) {
   const sourceFile = ts9.createSourceFile(filePath, source, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TSX);
+  return listComponentFunctionsFromSourceFile(sourceFile);
+}
+function scanComponentFile(source, filePath) {
+  const sourceFile = ts9.createSourceFile(filePath, source, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TSX);
+  return {
+    exports: listComponentFunctionsFromSourceFile(sourceFile),
+    referencedComponents: [...collectJsxComponentTags(sourceFile)]
+  };
+}
+function listComponentFunctionsFromSourceFile(sourceFile) {
   const componentNames = [];
   const hasUseClient = sourceFile.statements.some((stmt) => ts9.isExpressionStatement(stmt) && ts9.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   const namedExports = collectNamedExports(sourceFile);
@@ -10264,7 +10338,7 @@ var toLocaleDatePlugin = {
 };
 
 // src/jsx-to-ir.ts
-import { toHTMLAttrName, decodeEntities } from "@barefootjs/shared";
+import { toHTMLAttrName, decodeEntities, BF_KEY, keyAttrName as keyAttrName2 } from "@barefootjs/shared";
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -10717,10 +10791,44 @@ function attachParsedExpressions(node, analyzer, bound = EMPTY_BOUND) {
       break;
   }
 }
+function resolveRootKeyAttr(node) {
+  if (!node)
+    return;
+  switch (node.type) {
+    case "element":
+      if (node.needsScope && !node.keyAttr)
+        node.keyAttr = { name: BF_KEY };
+      for (const c of node.children)
+        resolveRootKeyAttr(c);
+      return;
+    case "fragment":
+    case "component":
+    case "provider":
+    case "loop":
+      for (const c of node.children)
+        resolveRootKeyAttr(c);
+      return;
+    case "async":
+      resolveRootKeyAttr(node.fallback);
+      for (const c of node.children)
+        resolveRootKeyAttr(c);
+      return;
+    case "conditional":
+      resolveRootKeyAttr(node.whenTrue);
+      resolveRootKeyAttr(node.whenFalse);
+      return;
+    case "if-statement":
+      resolveRootKeyAttr(node.consequent);
+      resolveRootKeyAttr(node.alternate);
+      return;
+  }
+}
 function jsxToIR(analyzer) {
   const root = buildIRRoot(analyzer);
-  if (root)
+  if (root) {
     attachParsedExpressions(root, analyzer);
+    resolveRootKeyAttr(root);
+  }
   return root;
 }
 function buildIRRoot(analyzer) {
@@ -10909,6 +11017,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
       type: "expression",
       expr,
       templateExpr: `escapeText(${templateExpr ?? expr})`,
+      escapeInClientTemplate: true,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -10946,7 +11055,7 @@ function transformHtmlElement(node, ctx, tagName) {
   ctx.isRoot = false;
   const children = transformChildren(node.children, ctx);
   lowerFormControlValueSsr(tagName, attrs, children);
-  const needsSlot = events.length > 0 || hasDynamicContent(children) || hasReactiveAttributes(attrs, ctx) || ref !== null;
+  const needsSlot = events.length > 0 || hasDynamicContent(children) || hasReactiveAttributes(attrs, ctx) || ref !== null || forwardsCallerRestProps(attrs, ctx);
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   if (slotId) {
     propagateSlotIdToLoops(children, slotId);
@@ -10979,7 +11088,7 @@ function transformSelfClosingElement(node, ctx) {
   const { attrs, events, ref } = processAttributes(node.attributes, ctx);
   const selfClosingChildren = [];
   lowerFormControlValueSsr(tagName, attrs, selfClosingChildren);
-  const needsSlot = events.length > 0 || hasReactiveAttributes(attrs, ctx) || ref !== null;
+  const needsSlot = events.length > 0 || hasReactiveAttributes(attrs, ctx) || ref !== null || forwardsCallerRestProps(attrs, ctx);
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   const needsScope = ctx.isRoot;
   ctx.isRoot = false;
@@ -11218,7 +11327,9 @@ function markDataKeyCarrier(children) {
 }
 function markCarrierIn(node) {
   if (node.type === "element") {
-    return { ...node, carriesDataKey: true };
+    if (node.keyAttr)
+      return null;
+    return { ...node, keyAttr: { name: BF_KEY } };
   }
   if (node.type === "conditional") {
     const cond = node;
@@ -11293,7 +11404,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   if (isRenderNothingLiteral(expr, ctx)) {
     return null;
   }
-  checkBareSignalOrMemoIdentifier(expr, ctx);
+  checkBareSignalOrMemoIdentifier(expr, ctx, { descendNested: true });
   if (ts13.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
@@ -12172,6 +12283,10 @@ function extractLoopKey(node) {
       return null;
     return normalizeKeyExpr(a) === normalizeKeyExpr(b) ? a : null;
   }
+  if (node.type === "fragment") {
+    const first = node.children.find((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
+    return first ? extractLoopKey(first) : null;
+  }
   return null;
 }
 function keyAttrValueToExpr(v) {
@@ -12362,7 +12477,7 @@ function leafIsWirelessElement(el) {
         }
         if (ts13.isJsxAttribute(attr)) {
           const name = attr.name.getText();
-          if (/^on[A-Z]/.test(name)) {
+          if (isEventHandlerAttrName(name)) {
             ok = false;
             return;
           }
@@ -12410,6 +12525,22 @@ function tagLoopItemRootComponents(nodes) {
     }
   }
 }
+function applyLoopKeyAttr(node, name, value) {
+  if (node.type === "element") {
+    node.keyAttr = { name, value };
+    return;
+  }
+  if (node.type === "conditional") {
+    applyLoopKeyAttr(node.whenTrue, name, value);
+    applyLoopKeyAttr(node.whenFalse, name, value);
+    return;
+  }
+  if (node.type === "fragment") {
+    const first = node.children.find((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
+    if (first)
+      applyLoopKeyAttr(first, name, value);
+  }
+}
 function loopBodyItemConditional(children) {
   const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
   if (real.length !== 1)
@@ -12640,7 +12771,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         children = [foldMultiReturnBranches(multiReturn, ctx, loc, ctx.getJS)];
         const pre = multiReturn.preamble ?? [];
         if (pre.length > 0) {
-          preamble = preambleFromValueStatements(pre, ctx);
+          preamble = preambleFromValueStatements(pre, ctx, body.statements);
           if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
             ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
               message: "A .map() callback body with a preamble before its branches cannot be " + "lowered to a template: the preamble is not a sequence of value " + "declarations, so this backend has no per-row local to carry into the " + "branches.",
@@ -12727,7 +12858,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
             valueStmts.push(stmt);
           }
           if (valueStmts.length > 0) {
-            preamble = preambleFromValueStatements(valueStmts, ctx);
+            preamble = preambleFromValueStatements(valueStmts, ctx, body.statements);
             if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
               ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(body, ctx.sourceFile, ctx.filePath), {
                 message: "A .map() callback preamble that is not a sequence of value " + "declarations cannot be lowered to a template: this backend can " + "declare a per-row local, but cannot run arbitrary statements per row.",
@@ -12792,6 +12923,14 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const itemConditional = children.length > 0 ? loopBodyItemConditional(children) : null;
   const bodyIsItemConditional = itemConditional !== null;
   const key = bodyIsItemConditional ? extractItemConditionalKey(itemConditional) : children.length > 0 ? extractLoopKey(children[0]) : null;
+  if (key !== null) {
+    const resolvedKeyAttrName2 = keyAttrName2(depth);
+    if (bodyIsItemConditional) {
+      applyLoopKeyAttr(itemConditional, resolvedKeyAttrName2, key);
+    } else if (children.length > 0) {
+      applyLoopKeyAttr(children[0], resolvedKeyAttrName2, key);
+    }
+  }
   const declaredNameSet = preamble && preamble.declaredNames.length > 0 ? new Set(preamble.declaredNames) : undefined;
   if (key && declaredNameSet) {
     const keyRefs = extractFreeIdentifiersFromText(key);
@@ -13182,7 +13321,7 @@ function computePreambleReactiveNames(statements, ctx) {
   }
   return reactiveNames;
 }
-function preambleFromValueStatements(statements, ctx) {
+function preambleFromValueStatements(statements, ctx, bodyStatements) {
   const segments = [];
   const typedParts = [];
   const declared = new Set;
@@ -13202,11 +13341,11 @@ function preambleFromValueStatements(statements, ctx) {
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     builderNames: [],
-    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined,
+    declarations: neutralPreambleDeclarations(statements, ctx, bodyStatements) ?? undefined,
     reactiveNames: reactiveNames.size > 0 ? [...reactiveNames] : undefined
   };
 }
-function neutralPreambleDeclarations(statements, ctx) {
+function neutralPreambleDeclarations(statements, ctx, bodyStatements) {
   const out = [];
   for (const stmt of statements) {
     if (!ts13.isVariableStatement(stmt))
@@ -13216,6 +13355,11 @@ function neutralPreambleDeclarations(statements, ctx) {
         return null;
       if (!decl.initializer)
         return null;
+      if (isFunctionLiteral(decl.initializer)) {
+        if (everyReadIsEventHandlerPropValue(decl.name.text, bodyStatements))
+          continue;
+        return null;
+      }
       const valueParsed = tsNodeToParsedExpr(decl.initializer);
       if (!isSupported(valueParsed).supported)
         return null;
@@ -13226,7 +13370,30 @@ function neutralPreambleDeclarations(statements, ctx) {
       });
     }
   }
-  return out.length > 0 ? out : null;
+  return out;
+}
+function isFunctionLiteral(node) {
+  return ts13.isArrowFunction(node) || ts13.isFunctionExpression(node);
+}
+function everyReadIsEventHandlerPropValue(name, bodyStatements) {
+  const findDisallowedRead = (node) => {
+    if (ts13.isIdentifier(node) && node.text === name) {
+      const isBindingName = ts13.isVariableDeclaration(node.parent) && node.parent.name === node;
+      const isPropertyName = ts13.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+      if (!isBindingName && !isPropertyName) {
+        const jsxExpr = node.parent;
+        const attr = jsxExpr.parent;
+        const isEventHandlerAttrValue = ts13.isJsxExpression(jsxExpr) && ts13.isJsxAttribute(attr) && attr.initializer === jsxExpr && ts13.isIdentifier(attr.name) && isEventHandlerAttrName(attr.name.text);
+        if (!isEventHandlerAttrValue)
+          return true;
+      }
+    }
+    return ts13.forEachChild(node, findDisallowedRead);
+  };
+  return !bodyStatements.some(findDisallowedRead);
+}
+function isEventHandlerAttrName(name) {
+  return /^on[A-Z]/.test(name);
 }
 function trimPreambleSegments(segments) {
   const last = segments[segments.length - 1];
@@ -13423,7 +13590,7 @@ function processAttributes(attributes, ctx) {
       }
       continue;
     }
-    if (/^on[A-Z]/.test(rawName)) {
+    if (isEventHandlerAttrName(rawName)) {
       if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         const eventName = rawName.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
@@ -13482,7 +13649,7 @@ function getAttributeValue(attr, ctx) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
     }
-    checkBareSignalOrMemoIdentifier(expr, ctx);
+    checkBareSignalOrMemoIdentifier(expr, ctx, { descendNested: isRenderedElementAttribute(attr, ctx) });
     if (attr.name.getText(ctx.sourceFile) === "style" && ts13.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
       if (cssString !== null) {
@@ -13990,34 +14157,142 @@ function processComponentProps(attributes, ctx) {
   }
   return props;
 }
-function checkBareSignalOrMemoIdentifier(expr, ctx) {
-  if (!ts13.isIdentifier(expr))
+function isRenderedElementAttribute(attr, ctx) {
+  const tagName = attr.parent.parent.tagName.getText(ctx.sourceFile);
+  return !/^[A-Z]/.test(tagName);
+}
+function checkBareSignalOrMemoIdentifier(expr, ctx, options) {
+  const reactiveNames = new Map;
+  for (const signal of ctx.analyzer.signals)
+    reactiveNames.set(signal.getter, "signal");
+  for (const memo of ctx.analyzer.memos)
+    reactiveNames.set(memo.name, "memo");
+  if (reactiveNames.size === 0)
     return;
-  const name = expr.text;
-  for (const signal of ctx.analyzer.signals) {
-    if (signal.getter === name) {
-      ctx.analyzer.errors.push(createError(ErrorCodes.SIGNAL_GETTER_NOT_CALLED, getSourceLocation(expr, ctx.sourceFile, ctx.filePath), {
-        message: `Signal getter '${name}' passed without calling it`,
-        suggestion: {
-          message: `Signal getters must be called to read the value. Use \`${name}()\` instead of \`${name}\`.`,
-          replacement: `${name}()`
-        }
-      }));
+  const report = (id, name, kind) => {
+    const label = kind === "signal" ? "Signal" : "Memo";
+    ctx.analyzer.errors.push(createError(ErrorCodes.SIGNAL_GETTER_NOT_CALLED, getSourceLocation(id, ctx.sourceFile, ctx.filePath), {
+      message: `${label} getter '${name}' passed without calling it`,
+      suggestion: {
+        message: `${label} getters must be called to read the value. Use \`${name}()\` instead of \`${name}\`.`,
+        replacement: `${name}()`
+      }
+    }));
+  };
+  if (ts13.isIdentifier(expr)) {
+    const kind = reactiveNames.get(expr.text);
+    if (kind && !ctx.scope.isBound(expr.text))
+      report(expr, expr.text, kind);
+    return;
+  }
+  if (!options?.descendNested)
+    return;
+  const boundStack = [];
+  const isBound = (name) => {
+    for (let i = boundStack.length - 1;i >= 0; i--) {
+      if (boundStack[i].has(name))
+        return true;
+    }
+    return ctx.scope.isBound(name);
+  };
+  const visitBindingDefaults = (name, bound) => {
+    if (ts13.isIdentifier(name)) {
+      bound.add(name.text);
       return;
     }
-  }
-  for (const memo of ctx.analyzer.memos) {
-    if (memo.name === name) {
-      ctx.analyzer.errors.push(createError(ErrorCodes.SIGNAL_GETTER_NOT_CALLED, getSourceLocation(expr, ctx.sourceFile, ctx.filePath), {
-        message: `Memo getter '${name}' passed without calling it`,
-        suggestion: {
-          message: `Memo getters must be called to read the value. Use \`${name}()\` instead of \`${name}\`.`,
-          replacement: `${name}()`
-        }
-      }));
+    for (const el of name.elements) {
+      if (ts13.isOmittedExpression(el))
+        continue;
+      if (el.initializer)
+        visit2(el.initializer);
+      visitBindingDefaults(el.name, bound);
+    }
+  };
+  const collectBindingNames3 = (name, out) => {
+    if (ts13.isIdentifier(name))
+      out.add(name.text);
+    else if (ts13.isObjectBindingPattern(name)) {
+      for (const el of name.elements)
+        collectBindingNames3(el.name, out);
+    } else if (ts13.isArrayBindingPattern(name)) {
+      for (const el of name.elements) {
+        if (!ts13.isOmittedExpression(el))
+          collectBindingNames3(el.name, out);
+      }
+    }
+  };
+  const collectBlockDeclarations = (block, out) => {
+    for (const stmt of block.statements) {
+      if (ts13.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations)
+          collectBindingNames3(decl.name, out);
+      } else if (ts13.isFunctionDeclaration(stmt) && stmt.name) {
+        out.add(stmt.name.text);
+      }
+    }
+  };
+  function visit2(node) {
+    if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node)) {
+      return;
+    }
+    if (ts13.isTypeNode(node))
+      return;
+    if (ts13.isCallExpression(node) && node.arguments.length === 0 && ts13.isIdentifier(node.expression)) {
+      return;
+    }
+    if (ts13.isPropertyAccessExpression(node)) {
+      visit2(node.expression);
+      return;
+    }
+    if (ts13.isPropertyAssignment(node)) {
+      if (ts13.isComputedPropertyName(node.name))
+        visit2(node.name.expression);
+      visit2(node.initializer);
+      return;
+    }
+    if (ts13.isShorthandPropertyAssignment(node)) {
+      if (ts13.isIdentifier(node.name) && !isBound(node.name.text)) {
+        const kind = reactiveNames.get(node.name.text);
+        if (kind)
+          report(node.name, node.name.text, kind);
+      }
+      return;
+    }
+    if (ts13.isArrowFunction(node) || ts13.isFunctionExpression(node)) {
+      const bound = new Set;
+      boundStack.push(bound);
+      for (const p of node.parameters) {
+        if (p.initializer)
+          visit2(p.initializer);
+        visitBindingDefaults(p.name, bound);
+      }
+      if (node.body && ts13.isBlock(node.body))
+        collectBlockDeclarations(node.body, bound);
+      if (node.body)
+        visit2(node.body);
+      boundStack.pop();
+      return;
+    }
+    if (ts13.isVariableDeclaration(node)) {
+      if (node.initializer)
+        visit2(node.initializer);
+      const declared = new Set;
+      boundStack.push(declared);
+      visitBindingDefaults(node.name, declared);
+      boundStack.pop();
+      return;
+    }
+    if (ts13.isIdentifier(node)) {
+      if (isBound(node.text))
+        return;
+      const kind = reactiveNames.get(node.text);
+      if (kind)
+        report(node, node.text, kind);
       return;
     }
+    ts13.forEachChild(node, visit2);
   }
+  visit2(expr);
 }
 function isArrayExprDirectPropRef(arrayExpr, ctx) {
   const propNames = new Set(ctx.patterns.props.map((p) => p.name));
@@ -14116,6 +14391,31 @@ function isPropsReference(expr, ctx, visited) {
   }
   return false;
 }
+function forwardsCallerRestProps(attrs, ctx) {
+  for (const attr of attrs) {
+    if (attr.value.kind !== "spread")
+      continue;
+    const constants = restSpreadConstantValues(ctx);
+    for (const name of new Set([attr.value.expr, attr.value.templateExpr])) {
+      if (!name)
+        continue;
+      if (resolveRestSpreadOriginCore(ctx.analyzer, constants, name) !== null)
+        return true;
+    }
+  }
+  return false;
+}
+function restSpreadConstantValues(ctx) {
+  if (ctx._restSpreadConstantValues)
+    return ctx._restSpreadConstantValues;
+  const byName = new Map;
+  for (const constant of ctx.analyzer.localConstants) {
+    if (!byName.has(constant.name))
+      byName.set(constant.name, constant.value);
+  }
+  ctx._restSpreadConstantValues = byName;
+  return byName;
+}
 function hasReactiveAttributes(attrs, ctx) {
   for (const attr of attrs) {
     if (attr.name === "key")
@@ -14338,18 +14638,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
 
 // src/ir-to-client-js/prop-handling.ts
 function resolveRestSpreadOrigin(ctx, name) {
-  const byName = localConstantValues(ctx);
-  const visited = new Set;
-  let current = name.trim();
-  while (current !== undefined && !visited.has(current)) {
-    if (ctx.restPropsName && current === ctx.restPropsName)
-      return "rest";
-    if (ctx.propsObjectName && current === ctx.propsObjectName)
-      return "props";
-    visited.add(current);
-    current = byName.get(current)?.trim();
-  }
-  return null;
+  return resolveRestSpreadOriginCore(ctx, localConstantValues(ctx), name);
 }
 var _localConstantValuesCache = new WeakMap;
 function localConstantValues(ctx) {
@@ -14959,6 +15248,7 @@ function emitMultiRootTemplateCloneLines(template, indent, varEl, varExtras) {
 }
 
 // src/ir-to-client-js/collect-elements.ts
+import { classifyDOMProp } from "@barefootjs/shared";
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
 function domElementCount(node) {
   switch (node.type) {
@@ -15245,8 +15535,8 @@ function collectReactiveChildProps(node, ctx) {
       continue;
     if (prop.value.kind === "jsx-children")
       continue;
-    const isEventHandler = prop.name.startsWith("on") && prop.name.length > 2 && prop.name[2] === prop.name[2].toUpperCase();
-    if (isEventHandler)
+    const domKind = classifyDOMProp(prop.name).kind;
+    if (domKind === "ref" || domKind === "event" || domKind === "skip")
       continue;
     if (prop.value.kind !== "expression" && prop.value.kind !== "template")
       continue;
@@ -15956,6 +16246,8 @@ function buildReferencesGraph(ctx, irRoot) {
       }
       for (const ev of el.events)
         addExprEdges(ROOT_SOURCE, ev.handler, "init-body");
+      if (el.ref)
+        addExprEdges(ROOT_SOURCE, el.ref, "init-body");
       descend();
     },
     component: ({ node: c, descend, descendJsxChildren }) => {
@@ -16163,6 +16455,9 @@ function propHasPropertyAccess(u) {
   return u.accessKinds.has("property") || u.accessKinds.has("index");
 }
 
+// src/ir-to-client-js/imports.ts
+import ts16 from "typescript";
+
 // src/value-references.ts
 import ts15 from "typescript";
 function isValueReferenceIdentifier(id) {
@@ -16269,6 +16564,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeTextOrNode",
   "bfMarkup",
   "escapeTextOrMarkup",
+  "markupOrEmpty",
   "qsa",
   "qsaItem",
   "qsaChildScope",
@@ -16335,6 +16631,79 @@ function makeValueUsageTest(generatedCode) {
     return generatedCode.includes(localName);
   };
 }
+function renderUsedImportLines(source, usedDefault, usedNamespace, usedNamed) {
+  const lines = [];
+  const defaultAndNamed = [
+    usedDefault,
+    usedNamed.length > 0 ? `{ ${usedNamed.join(", ")} }` : null
+  ].filter((part) => part !== null).join(", ");
+  if (defaultAndNamed)
+    lines.push(`import ${defaultAndNamed} from '${source}'`);
+  if (usedNamespace)
+    lines.push(`import * as ${usedNamespace} from '${source}'`);
+  return lines;
+}
+function mergeCompiledClientJsImports(codeBlobs) {
+  const sourceOrder = [];
+  const namedBySource = new Map;
+  const defaultBySource = new Map;
+  const otherImports = [];
+  const seenOther = new Set;
+  const codeSections = [];
+  const ensureSource = (source) => {
+    if (!namedBySource.has(source)) {
+      namedBySource.set(source, new Set);
+      sourceOrder.push(source);
+    }
+    return namedBySource.get(source);
+  };
+  for (const content of codeBlobs) {
+    const sourceFile = ts16.createSourceFile("combine.js", content, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.JS);
+    const importSpans = [];
+    for (const stmt of sourceFile.statements) {
+      if (!ts16.isImportDeclaration(stmt))
+        continue;
+      const start = stmt.getStart(sourceFile);
+      const end = stmt.getEnd();
+      importSpans.push([start, end]);
+      const clause = stmt.importClause;
+      const bindings = clause?.namedBindings;
+      const specifier = ts16.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+      const isNamespace = !!bindings && ts16.isNamespaceImport(bindings);
+      const isNamed = !!bindings && ts16.isNamedImports(bindings);
+      if (!isNamespace && (clause?.name || isNamed)) {
+        const set = ensureSource(specifier);
+        if (clause?.name && !defaultBySource.has(specifier)) {
+          defaultBySource.set(specifier, clause.name.text);
+        }
+        if (isNamed) {
+          for (const el of bindings.elements) {
+            set.add(el.propertyName ? `${el.propertyName.text} as ${el.name.text}` : el.name.text);
+          }
+        }
+      } else {
+        const stmtText = content.slice(start, end);
+        if (!seenOther.has(stmtText)) {
+          seenOther.add(stmtText);
+          otherImports.push(stmtText);
+        }
+      }
+    }
+    let code = "";
+    let cursor = 0;
+    for (const [start, end] of importSpans) {
+      code += content.slice(cursor, start);
+      cursor = end;
+    }
+    code += content.slice(cursor);
+    code = code.trim();
+    if (code)
+      codeSections.push(code);
+  }
+  const mergedImports = sourceOrder.flatMap((source) => renderUsedImportLines(source, defaultBySource.get(source) ?? null, null, [...namedBySource.get(source)]));
+  return [...mergedImports, ...otherImports, "", ...codeSections].join(`
+`);
+}
 function collectExternalImports(ir, generatedCode, localImportPrefixes) {
   const componentNames = collectComponentNames(ir.root);
   const importLines = [];
@@ -16350,23 +16719,31 @@ function collectExternalImports(ir, generatedCode, localImportPrefixes) {
       importLines.push(`import '${imp.source}'`);
       continue;
     }
-    const usedSpecs = [];
+    const usedNamed = [];
+    let usedDefault = null;
+    let usedNamespace = null;
     for (const spec of imp.specifiers) {
       if (spec.isTypeOnly)
         continue;
       const localName = spec.alias || spec.name;
       if (componentNames.has(localName))
         continue;
-      if (isUsedAsValue(localName)) {
-        usedSpecs.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
+      if (!isUsedAsValue(localName))
+        continue;
+      if (spec.isDefault) {
+        usedDefault = localName;
+      } else if (spec.isNamespace) {
+        usedNamespace = localName;
+      } else {
+        usedNamed.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
       }
     }
-    if (usedSpecs.length > 0) {
+    if (usedDefault || usedNamespace || usedNamed.length > 0) {
       let source = imp.source;
       if (ir.metadata.clientSignalImportSources?.has(source)) {
         source = source.replace(/\.tsx?$/, "") + ".client.js";
       }
-      importLines.push(`import { ${usedSpecs.join(", ")} } from '${source}'`);
+      importLines.push(...renderUsedImportLines(source, usedDefault, usedNamespace, usedNamed));
     }
   }
   return importLines;
@@ -16396,7 +16773,7 @@ function collectComponentNames(node) {
 }
 
 // src/relocate.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // src/lowering-registry.ts
 var plugins = [];
@@ -16442,19 +16819,19 @@ function classify(name, env) {
 function collectFreeRefs(node) {
   const refs = new Map;
   function visit3(n, parent) {
-    if (ts16.isIdentifier(n)) {
-      if (parent && ts16.isPropertyAccessExpression(parent) && parent.name === n)
+    if (ts17.isIdentifier(n)) {
+      if (parent && ts17.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts16.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts17.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts16.isShorthandPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts17.isShorthandPropertyAssignment(parent) && parent.name === n)
         return;
       const list = refs.get(n.text) ?? [];
       list.push(n);
       refs.set(n.text, list);
       return;
     }
-    ts16.forEachChild(n, (child) => visit3(child, n));
+    ts17.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return refs;
@@ -16558,11 +16935,11 @@ function isInlinableInTemplate(value, env) {
   return { ok: true, rewrittenValue: r.text, decisions: r.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts16.isParenthesizedExpression(callee))
+  if (ts17.isParenthesizedExpression(callee))
     return getCalleeIdentifierPath(callee.expression);
-  if (ts16.isIdentifier(callee))
+  if (ts17.isIdentifier(callee))
     return callee.text;
-  if (ts16.isPropertyAccessExpression(callee)) {
+  if (ts17.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null)
       return null;
@@ -16571,11 +16948,11 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts16.isParenthesizedExpression(callee))
+  if (ts17.isParenthesizedExpression(callee))
     return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts16.isIdentifier(callee))
+  if (ts17.isIdentifier(callee))
     return callee.text;
-  if (ts16.isPropertyAccessExpression(callee)) {
+  if (ts17.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -16623,12 +17000,12 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts16.createSourceFile("__inline_check__.ts", `(${text});`, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.TS);
+    const sf = ts17.createSourceFile("__inline_check__.ts", `(${text});`, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.TS);
     const stmt = sf.statements[0];
-    if (!stmt || !ts16.isExpressionStatement(stmt))
+    if (!stmt || !ts17.isExpressionStatement(stmt))
       return null;
     const inner = stmt.expression;
-    return ts16.isParenthesizedExpression(inner) ? inner.expression : inner;
+    return ts17.isParenthesizedExpression(inner) ? inner.expression : inner;
   } catch {
     return null;
   }
@@ -16645,8 +17022,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts16.isCallExpression(n) || ts16.isNewExpression(n)) {
-      const accepted = ts16.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
+    if (ts17.isCallExpression(n) || ts17.isNewExpression(n)) {
+      const accepted = ts17.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
       if (!accepted) {
         const args = n.arguments;
         if (args) {
@@ -16659,7 +17036,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16669,13 +17046,13 @@ function hasZeroArgCall(node, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts16.isCallExpression(n) && n.arguments.length === 0) {
+    if (ts17.isCallExpression(n) && n.arguments.length === 0) {
       if (!isCallAcceptedByAdapter(n, env)) {
         found = true;
         return;
       }
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16685,25 +17062,25 @@ function containsAnyIdentifier(node, names) {
   function visit3(n) {
     if (found)
       return;
-    if (ts16.isPropertyAccessExpression(n)) {
+    if (ts17.isPropertyAccessExpression(n)) {
       visit3(n.expression);
       return;
     }
-    if (ts16.isPropertyAssignment(n)) {
+    if (ts17.isPropertyAssignment(n)) {
       visit3(n.initializer);
       return;
     }
-    if (ts16.isShorthandPropertyAssignment(n)) {
-      if (ts16.isIdentifier(n.name) && names.has(n.name.text)) {
+    if (ts17.isShorthandPropertyAssignment(n)) {
+      if (ts17.isIdentifier(n.name) && names.has(n.name.text)) {
         found = true;
       }
       return;
     }
-    if (ts16.isIdentifier(n) && names.has(n.text)) {
+    if (ts17.isIdentifier(n) && names.has(n.text)) {
       found = true;
       return;
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -18014,23 +18391,23 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 }
 
 // src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function propExtractionName(stmt) {
-  if (!ts17.isVariableStatement(stmt))
+  if (!ts18.isVariableStatement(stmt))
     return null;
   const decls = stmt.declarationList.declarations;
   if (decls.length !== 1)
     return null;
   const decl = decls[0];
-  if (!ts17.isIdentifier(decl.name) || !decl.initializer)
+  if (!ts18.isIdentifier(decl.name) || !decl.initializer)
     return null;
   let core = decl.initializer;
-  if (ts17.isBinaryExpression(core) && core.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken) {
+  if (ts18.isBinaryExpression(core) && core.operatorToken.kind === ts18.SyntaxKind.QuestionQuestionToken) {
     core = core.left;
   }
-  if (!ts17.isPropertyAccessExpression(core))
+  if (!ts18.isPropertyAccessExpression(core))
     return null;
-  if (!ts17.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
+  if (!ts18.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
     return null;
   if (core.name.text !== decl.name.text)
     return null;
@@ -18043,10 +18420,10 @@ function pruneUnusedPropExtractions(code) {
       console.warn("[barefootjs] pruneUnusedPropExtractions: generated code did not parse; skipping prune");
       return code;
     }
-    const sourceFile = ts17.createSourceFile("generated.js", code, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.JS);
+    const sourceFile = ts18.createSourceFile("generated.js", code, ts18.ScriptTarget.Latest, false, ts18.ScriptKind.JS);
     const spans = [];
     for (const stmt of sourceFile.statements) {
-      if (!ts17.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body)
+      if (!ts18.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body)
         continue;
       for (const inner of stmt.body.statements) {
         const name = propExtractionName(inner);
@@ -19507,7 +19884,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -19527,12 +19904,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   if (text.trim().length === 0)
     return NO_PREAMBLE;
   const declaredNames = new Set;
-  const sf = ts18.createSourceFile("__lazy_preamble__.ts", text, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
+  const sf = ts19.createSourceFile("__lazy_preamble__.ts", text, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
   for (const stmt of sf.statements) {
-    if (!ts18.isVariableStatement(stmt)) {
-      return NO2(`map-callback preamble has a non-declaration statement (${ts18.SyntaxKind[stmt.kind]})`);
+    if (!ts19.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts19.SyntaxKind[stmt.kind]})`);
     }
-    const isConst = (stmt.declarationList.flags & ts18.NodeFlags.Const) !== 0;
+    const isConst = (stmt.declarationList.flags & ts19.NodeFlags.Const) !== 0;
     if (!isConst)
       return NO2("map-callback preamble declares a mutable binding (let/var)");
     for (const decl of stmt.declarationList.declarations) {
@@ -19561,12 +19938,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   return { lazySafe: true, facts: { declaredNames, freeNames } };
 }
 function collectBindingNames3(name, out) {
-  if (ts18.isIdentifier(name)) {
+  if (ts19.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const element of name.elements) {
-    if (ts18.isOmittedExpression(element))
+    if (ts19.isOmittedExpression(element))
       continue;
     collectBindingNames3(element.name, out);
   }
@@ -19576,56 +19953,56 @@ function findImpureNode(root, primableNames) {
   const visit3 = (node) => {
     if (found)
       return;
-    if (ts18.isCallExpression(node)) {
+    if (ts19.isCallExpression(node)) {
       const callee = node.expression;
-      const isSignalRead = ts18.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
+      const isSignalRead = ts19.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
       if (!isSignalRead) {
         found = `call to ${callee.getText(callee.getSourceFile())}`;
         return;
       }
     }
-    if (ts18.isNewExpression(node)) {
+    if (ts19.isNewExpression(node)) {
       found = "new expression";
       return;
     }
-    if (ts18.isTaggedTemplateExpression(node)) {
+    if (ts19.isTaggedTemplateExpression(node)) {
       found = "tagged template";
       return;
     }
-    if (ts18.isAwaitExpression(node)) {
+    if (ts19.isAwaitExpression(node)) {
       found = "await";
       return;
     }
-    if (ts18.isYieldExpression(node)) {
+    if (ts19.isYieldExpression(node)) {
       found = "yield";
       return;
     }
-    if (ts18.isPrefixUnaryExpression(node) || ts18.isPostfixUnaryExpression(node)) {
+    if (ts19.isPrefixUnaryExpression(node) || ts19.isPostfixUnaryExpression(node)) {
       const op = node.operator;
-      if (op === ts18.SyntaxKind.PlusPlusToken || op === ts18.SyntaxKind.MinusMinusToken) {
+      if (op === ts19.SyntaxKind.PlusPlusToken || op === ts19.SyntaxKind.MinusMinusToken) {
         found = "increment/decrement";
         return;
       }
     }
-    if (ts18.isDeleteExpression(node)) {
+    if (ts19.isDeleteExpression(node)) {
       found = "delete";
       return;
     }
-    if (ts18.isFunctionExpression(node) || ts18.isArrowFunction(node) || ts18.isClassExpression(node)) {
+    if (ts19.isFunctionExpression(node) || ts19.isArrowFunction(node) || ts19.isClassExpression(node)) {
       found = "function or class expression";
       return;
     }
-    if (ts18.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
+    if (ts19.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
       found = "assignment";
       return;
     }
-    ts18.forEachChild(node, visit3);
+    ts19.forEachChild(node, visit3);
   };
   visit3(root);
   return found;
 }
 function isAssignmentOperator2(kind) {
-  return kind >= ts18.SyntaxKind.FirstAssignment && kind <= ts18.SyntaxKind.LastAssignment;
+  return kind >= ts19.SyntaxKind.FirstAssignment && kind <= ts19.SyntaxKind.LastAssignment;
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -20155,7 +20532,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -20267,20 +20644,20 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
+    sourceFile = ts20.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt))
+  if (!stmt || !ts20.isExpressionStatement(stmt))
     return expr;
-  const root = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts20.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts19.isCallExpression(n) && n.arguments.length === 2 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts20.isCallExpression(n) && n.arguments.length === 2 && ts20.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts19.forEachChild(n, visit3);
+    ts20.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -20316,20 +20693,20 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
+    sourceFile = ts20.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt))
+  if (!stmt || !ts20.isExpressionStatement(stmt))
     return expr;
-  const root = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts20.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts19.isCallExpression(n) && n.arguments.length === 0 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts20.isCallExpression(n) && n.arguments.length === 0 && ts20.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts19.forEachChild(n, visit3);
+    ts20.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -20591,7 +20968,7 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc);
     }
     lines.push(`${indent}  return __bel${uid}`);
-    lines.push(`${indent}}, '${inner.markerId}'${profileBindingId(pc, inner.slotId)}) }`);
+    lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!inner.wrappedKey, inner.keyDepth)}) }`);
   }
 }
 function stringifyLoopChildConditionals(lines, conditionals, indent, pc) {
@@ -20823,12 +21200,15 @@ function stringifyComponentLoop(lines, plan) {
     keyExpr,
     nestedComps,
     childConditionalEffects,
-    profileLoopId
+    profileLoopId,
+    mapPreambleWrapped
   } = plan;
   const loopBfId = profileLoopId ? `, ${JSON.stringify(profileLoopId)}` : "";
   lines.push(`  mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => {`);
   if (paramUnwrap)
     lines.push(`    ${paramUnwrap}`);
+  if (mapPreambleWrapped)
+    lines.push(`    ${mapPreambleWrapped}`);
   const scopedComp = nameForRegistryRef(componentName);
   if (nestedComps.length === 0) {
     lines.push(`    if (__existing) { initChild('${scopedComp}', __existing, ${componentPropsExpr}); return __existing }`);
@@ -21440,7 +21820,7 @@ function emitReactive(lines, inner, indent, pc) {
     bodyIsMultiRoot: emit.bodyIsMultiRoot
   });
   lines.push(`${indent}  return __innerEl${uid}`);
-  lines.push(`${indent}}, '${inner.markerId}'${profileBindingId(pc, inner.slotId)}) }`);
+  lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!emit.wrappedKey, inner.keyDepth)}) }`);
 }
 function emitStatic(lines, inner, indent, pc) {
   const uid = inner.uidSuffix;
@@ -21944,6 +22324,12 @@ function buildComponentLoopPlan(elem, profileComponentName) {
   const propsExpr = buildComponentPropsExpr2(elem.childComponent, elem.param);
   const keyExpr = wrapLoopParamAsAccessor(elem.key || "__idx", elem.param, elem.paramBindings);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
+  const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
+    transformJs: (text) => wrapLoopParamAsAccessor(text, elem.param, elem.paramBindings),
+    renderLeaf: () => {
+      internalInvariant(false, "component-root loop received a JSX-bearing preamble — Phase 1 should have refused it");
+    }
+  }) : "";
   const outerNestedComps = (elem.nestedComponents ?? []).filter((c) => !c.loopDepth);
   const nestedComps = outerNestedComps.map((comp) => {
     const isTextOnly = comp.children?.length ? comp.children.every((c) => c.type === "expression" || c.type === "text" || isTextOnlyConditional(c)) : false;
@@ -21961,6 +22347,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
   return {
     kind: "component",
     rowConstruction: "dom-ops",
+    mapPreambleWrapped,
     containerVar: `_${varSlotId(elem.slotId)}`,
     markerId: elem.markerId,
     arrayExpr: buildChainedArrayExpr(elem),
@@ -22143,6 +22530,7 @@ function emitLoopUpdates(lines, ctx, unsafeLocalNames) {
       lazyScope
     });
     internalInvariant(!(elem.preamble && elem.preamble.builderNames.length > 0 && plan.rowConstruction === "dom-ops"), `loop variant '${plan.kind}' declares dom-ops row construction but received a JSX-bearing preamble — add a Phase-1 refusal (or wire renderPreamble support) for this shape`);
+    internalInvariant(!(elem.preamble && elem.preamble.declaredNames.length > 0 && ("mapPreambleWrapped" in plan) && plan.mapPreambleWrapped === ""), `loop variant '${plan.kind}' has a preamble with declared names (${elem.preamble?.declaredNames.join(", ")}) but its plan's mapPreambleWrapped is empty — wire it up or the emitted call site references a name nothing declares`);
     stringifyLoop(lines, plan);
     emitLoopEventDelegation(lines, elem, plan.kind, ctx.profile ? ctx.componentName : undefined);
   }
@@ -22350,7 +22738,7 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName, restPropsName = null) {
   let result = code;
   const seen = new Set;
@@ -22365,13 +22753,13 @@ function rewritePropsObjectRef(code, propsObjectName, restPropsName = null) {
 function rewriteOneName(code, srcPropsName) {
   if (!identifierPattern(srcPropsName).test(code))
     return code;
-  const sourceFile = ts20.createSourceFile("init-body.ts", code, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TS);
+  const sourceFile = ts21.createSourceFile("init-body.ts", code, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts20.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts21.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -22387,17 +22775,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts20.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts21.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts20.isPropertyAssignment(parent) && parent.name === node)
+  if (ts21.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts20.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts21.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts20.isPropertySignature(parent) && parent.name === node)
+  if (ts21.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts20.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts21.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts20.isBindingElement(parent) && parent.name === node)
+  if (ts21.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -22709,7 +23097,7 @@ function createContext(ir, scope, adapterCapabilities, profile) {
   };
 }
 function needsClientJs(ctx) {
-  if (ctx.signals.length > 0 || ctx.memos.length > 0 || ctx.effects.length > 0 || ctx.onMounts.length > 0 || ctx.initStatements.length > 0 || ctx.interactiveElements.length > 0 || ctx.dynamicElements.length > 0 || ctx.conditionalElements.length > 0 || ctx.loopElements.length > 0 || ctx.refElements.length > 0 || ctx.childInits.length > 0 || ctx.reactiveAttrs.length > 0 || ctx.clientOnlyElements.length > 0 || ctx.clientOnlyConditionals.length > 0 || ctx.providerSetups.length > 0)
+  if (ctx.signals.length > 0 || ctx.memos.length > 0 || ctx.effects.length > 0 || ctx.onMounts.length > 0 || ctx.initStatements.length > 0 || ctx.interactiveElements.length > 0 || ctx.dynamicElements.length > 0 || ctx.conditionalElements.length > 0 || ctx.loopElements.length > 0 || ctx.refElements.length > 0 || ctx.restAttrElements.length > 0 || ctx.childInits.length > 0 || ctx.reactiveAttrs.length > 0 || ctx.clientOnlyElements.length > 0 || ctx.clientOnlyConditionals.length > 0 || ctx.providerSetups.length > 0)
     return true;
   return hasInitScopeOnlyConstant(ctx);
 }
@@ -23047,7 +23435,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -23069,8 +23457,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts21.createSourceFile(filePath, source, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts21.isExpressionStatement(stmt) && ts21.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const sourceFile = ts22.createSourceFile(filePath, source, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
+  const hasUseClient = sourceFile.statements.some((stmt) => ts22.isExpressionStatement(stmt) && ts22.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -23092,22 +23480,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts21.isJsxAttribute(node) && node.initializer && ts21.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts22.isJsxAttribute(node) && node.initializer && ts22.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts21.isPropertyAssignment(node) && node.initializer) {
+    if (ts22.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts21.forEachChild(node, visit3);
+    ts22.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts21.isParenthesizedExpression(expr))
+    while (ts22.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts21.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts22.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -23144,7 +23532,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts21.forEachChild(sourceFile, visit3);
+  ts22.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -23167,11 +23555,11 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ` + `${captures.sort().join(", ")}. ` + `Extract the callback into a top-level '\\'use client\\'' component (e.g. ` + `\`function MyNode(n) { return <div/> }\` then \`renderNode={MyNode}\`) ` + `or pass captured values via component props.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts21.isBlock(arrow.body)) {
+  if (ts22.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts21.isParenthesizedExpression(body))
+  while (ts22.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -23180,24 +23568,24 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts21.isReturnStatement(n) && n.expression) {
+    if (ts22.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts21.isParenthesizedExpression(e))
+      while (ts22.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts21.isArrowFunction(n) || ts21.isFunctionDeclaration(n) || ts21.isFunctionExpression(n))
+    if (ts22.isArrowFunction(n) || ts22.isFunctionDeclaration(n) || ts22.isFunctionExpression(n))
       return;
-    ts21.forEachChild(n, visit3);
+    ts22.forEachChild(n, visit3);
   }
-  ts21.forEachChild(block, visit3);
+  ts22.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts21.isJsxElement(expr) || ts21.isJsxSelfClosingElement(expr) || ts21.isJsxFragment(expr);
+  return ts22.isJsxElement(expr) || ts22.isJsxSelfClosingElement(expr) || ts22.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
@@ -23207,13 +23595,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames4(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts21.isIdentifier(name)) {
+  if (ts22.isIdentifier(name)) {
     push(name.text);
-  } else if (ts21.isObjectBindingPattern(name)) {
+  } else if (ts22.isObjectBindingPattern(name)) {
     name.elements.forEach((el) => collectBindingNames4(el.name, out));
-  } else if (ts21.isArrayBindingPattern(name)) {
+  } else if (ts22.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts21.isOmittedExpression(el))
+      if (!ts22.isOmittedExpression(el))
         collectBindingNames4(el.name, out);
     });
   }
@@ -23240,48 +23628,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts21.isIdentifier(node)) {
+    if (ts22.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts21.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts22.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts21.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts22.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts21.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts22.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts21.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts22.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts21.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isEnumMember(parent) && parent.name === node)
+      if (parent && ts22.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts21.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts22.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts21.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts22.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts21.isParameter(parent) && parent.name === node)
+      if (parent && ts22.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts21.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts22.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts21.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts22.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts21.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts22.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts21.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts22.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -23290,43 +23678,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts21.isVariableDeclaration(node)) {
+    if (ts22.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts21.isFunctionDeclaration(node)) {
+    if (ts22.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts21.isClassDeclaration(node)) {
+    if (ts22.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts21.forEachChild(node, visit3);
+      ts22.forEachChild(node, visit3);
       return;
     }
-    if (ts21.isArrowFunction(node) || ts21.isFunctionExpression(node)) {
+    if (ts22.isArrowFunction(node) || ts22.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts21.isCatchClause(node)) {
+    if (ts22.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts21.forEachChild(node, visit3);
+      ts22.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts21.isBlock(node)) {
+    if (ts22.isBlock(node)) {
       const before = bound.length;
-      ts21.forEachChild(node, visit3);
+      ts22.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts21.forEachChild(node, visit3);
+    ts22.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -23349,29 +23737,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts21.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts22.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts21.isClassDeclaration(stmt) && stmt.name)
+    else if (ts22.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts21.isVariableStatement(stmt)) {
+    else if (ts22.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
         collectBindingNames4(decl.name, names);
-    } else if (ts21.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts22.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts21.isNamespaceImport(ic.namedBindings))
+        if (ts22.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts21.isTypeAliasDeclaration(stmt))
+    } else if (ts22.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts21.isInterfaceDeclaration(stmt))
+    else if (ts22.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts21.isEnumDeclaration(stmt))
+    else if (ts22.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -23379,7 +23767,7 @@ function collectModuleScopeNames(sourceFile) {
 function buildSyntheticDeclaration(name, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts21.isBlock(arrow.body)) {
+  if (ts22.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -23389,7 +23777,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function deriveStashFromDefaults(defaults, props) {
   const extra = {};
   for (const [name, d] of Object.entries(defaults)) {
@@ -23512,11 +23900,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts22.isIdentifier(n.name)) {
+    if (ts23.isPropertyAccessExpression(n) && ts23.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts23.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts22.forEachChild(n, visit3);
+    ts23.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -23554,23 +23942,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts22.isVariableStatement(stmt)) {
+    if (ts23.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts22.isIdentifier(d.name) || !d.initializer)
+        if (!ts23.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts22.isReturnStatement(stmt)) {
+    } else if (ts23.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts22.isIfStatement(stmt)) {
+    } else if (ts23.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(ts22.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts23.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -23581,45 +23969,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts22.createSourceFile("__ssr_default__.ts", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TS);
+  const sf = ts23.createSourceFile("__ssr_default__.ts", `(${expr})`, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isExpressionStatement(stmt))
+  if (!stmt || !ts23.isExpressionStatement(stmt))
     return null;
-  const inner = ts22.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts23.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts22.isParenthesizedExpression(node))
+  if (ts23.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts22.isAsExpression(node))
+  if (ts23.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts22.isSatisfiesExpression(node))
+  if (ts23.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts22.isTypeAssertionExpression(node))
+  if (ts23.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts22.isNonNullExpression(node))
+  if (ts23.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts22.isArrowFunction(node)) {
+  if (ts23.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts22.isBlock(node.body))
+    if (!ts23.isBlock(node.body))
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
     const result = evalStatementsForReturn(node.body.statements, localCtx);
     return result === NO_RETURN ? UNRESOLVED : result;
   }
-  if (ts22.isNumericLiteral(node))
+  if (ts23.isNumericLiteral(node))
     return Number(node.text);
-  if (ts22.isStringLiteralLike(node))
+  if (ts23.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts22.SyntaxKind.TrueKeyword)
+  if (node.kind === ts23.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts22.SyntaxKind.FalseKeyword)
+  if (node.kind === ts23.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts22.SyntaxKind.NullKeyword)
+  if (node.kind === ts23.SyntaxKind.NullKeyword)
     return null;
-  if (ts22.isIdentifier(node)) {
+  if (ts23.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -23628,29 +24016,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts22.isPrefixUnaryExpression(node)) {
+  if (ts23.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts22.SyntaxKind.MinusToken:
+      case ts23.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts22.SyntaxKind.PlusToken:
+      case ts23.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts22.SyntaxKind.ExclamationToken:
+      case ts23.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts22.isObjectLiteralExpression(node)) {
+  if (ts23.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts22.isPropertyAssignment(prop))
+      if (!ts23.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts22.isIdentifier(prop.name) || ts22.isStringLiteralLike(prop.name)) {
+      if (ts23.isIdentifier(prop.name) || ts23.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts22.isNumericLiteral(prop.name)) {
+      } else if (ts23.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -23662,10 +24050,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts22.isArrayLiteralExpression(node)) {
+  if (ts23.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts22.isOmittedExpression(elem))
+      if (ts23.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -23674,7 +24062,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts22.isElementAccessExpression(node)) {
+  if (ts23.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -23688,7 +24076,7 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts22.isPropertyAccessExpression(node)) {
+  if (ts23.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
@@ -23701,13 +24089,13 @@ function evalNode(node, ctx) {
     const key = node.name.text;
     return Object.prototype.hasOwnProperty.call(baseResult, key) ? baseResult[key] : undefined;
   }
-  if (ts22.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts22.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts23.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts23.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && node.arguments.length === 1) {
+    if (ts23.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && node.arguments.length === 1) {
       const arrow = node.arguments[0];
-      if (ts22.isArrowFunction(arrow) && arrow.parameters.length === 1 && ts22.isIdentifier(arrow.parameters[0].name) && !ts22.isBlock(arrow.body)) {
+      if (ts23.isArrowFunction(arrow) && arrow.parameters.length === 1 && ts23.isIdentifier(arrow.parameters[0].name) && !ts23.isBlock(arrow.body)) {
         const recv = evalNode(node.expression.expression, ctx);
         if (Array.isArray(recv)) {
           const paramName = arrow.parameters[0].name.text;
@@ -23724,7 +24112,7 @@ function evalNode(node, ctx) {
       }
       return UNRESOLVED;
     }
-    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts23.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -23740,27 +24128,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts22.isConditionalExpression(node)) {
+  if (ts23.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts22.isBinaryExpression(node)) {
+  if (ts23.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts22.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts23.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts22.SyntaxKind.BarBarToken) {
+    if (op === ts23.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts22.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts23.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -23773,30 +24161,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts22.SyntaxKind.PlusToken:
+      case ts23.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r === "string")
           return `${l}${r}`;
         if (typeof l === "number" && typeof r === "number")
           return l + r;
         return UNRESOLVED;
-      case ts22.SyntaxKind.MinusToken:
+      case ts23.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts22.SyntaxKind.AsteriskToken:
+      case ts23.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts22.SyntaxKind.SlashToken:
+      case ts23.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts22.SyntaxKind.PercentToken:
+      case ts23.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts22.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts22.SyntaxKind.EqualsEqualsToken:
+      case ts23.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts23.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts22.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts22.SyntaxKind.ExclamationEqualsToken:
+      case ts23.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts23.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts22.isTemplateExpression(node)) {
+  if (ts23.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -23808,13 +24196,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts22.isNoSubstitutionTemplateLiteral(node))
+  if (ts23.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -23846,47 +24234,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return null;
-  if (!ts23.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts24.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts23.isIdentifier(arg) ? arg.text : null;
+  return ts24.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
+  if (ts24.isStringLiteral(arg) || ts24.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts23.isNumericLiteral(arg))
+  if (ts24.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts23.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts24.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts23.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts24.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts23.isObjectLiteralExpression(expr.arguments[0]);
+  return ts24.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts23.createSourceFile("__ctx.ts", `(${source})`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__ctx.ts", `(${source})`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isExpressionStatement(stmt))
+  if (!stmt || !ts24.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts23.isParenthesizedExpression(e))
+  while (ts24.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -23911,25 +24299,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts23.createSourceFile("__aug.ts", `(${s})`, ts23.ScriptTarget.Latest, false);
+    const sf = ts24.createSourceFile("__aug.ts", `(${s})`, ts24.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts23.isBinaryExpression(n) && (n.operatorToken.kind === ts23.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts23.SyntaxKind.BarBarToken)) {
+      if (ts24.isBinaryExpression(n) && (n.operatorToken.kind === ts24.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts24.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts23.isParenthesizedExpression(left))
+        while (ts24.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts23.isPropertyAccessExpression(left) && ts23.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts24.isPropertyAccessExpression(left) && ts24.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts23.isParenthesizedExpression(right))
+          while (ts24.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts23.isPrefixUnaryExpression(right))
+          if (ts24.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts23.isNumericLiteral(right) ? "number" : right.kind === ts23.SyntaxKind.TrueKeyword || right.kind === ts23.SyntaxKind.FalseKeyword ? "boolean" : ts23.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts24.isNumericLiteral(right) ? "number" : right.kind === ts24.SyntaxKind.TrueKeyword || right.kind === ts24.SyntaxKind.FalseKeyword ? "boolean" : ts24.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts23.forEachChild(n, visit3);
+      ts24.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -24040,33 +24428,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__const.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts23.isParenthesizedExpression(init))
+  while (init && ts24.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts23.isStringLiteral(init) || ts23.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts24.isStringLiteral(init) || ts24.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__const.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts23.isParenthesizedExpression(init))
+  while (init && ts24.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts23.isTemplateExpression(init))
+  if (!init || !ts24.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts23.isIdentifier(span.expression))
+    if (!ts24.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -24099,30 +24487,30 @@ function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
+  const sf = ts24.createSourceFile("__rec.ts", `(${constInfo.value})`, ts24.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts23.isExpressionStatement(stmt))
+  if (!ts24.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts23.isParenthesizedExpression(parsed))
+  while (ts24.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts23.isObjectLiteralExpression(parsed))
+  if (!ts24.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts23.isPropertyAssignment(prop))
+    if (!ts24.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts23.isIdentifier(name) || ts23.isStringLiteral(name) || ts23.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts24.isIdentifier(name) || ts24.isStringLiteral(name) || ts24.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts23.isParenthesizedExpression(v))
+    while (ts24.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts23.isNumericLiteral(v))
+    if (ts24.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts24.isStringLiteral(v) || ts24.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -24130,28 +24518,28 @@ function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts23.createSourceFile("__join.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__join.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts23.isParenthesizedExpression(node))
+  while (node && ts24.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts23.isCallExpression(node))
+  if (!node || !ts24.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts23.isPropertyAccessExpression(callee))
+  if (!ts24.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts23.isParenthesizedExpression(recv))
+  while (ts24.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts23.isArrayLiteralExpression(recv))
+  if (!ts24.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts23.isStringLiteral(el) || ts23.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts24.isStringLiteral(el) || ts24.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -24160,7 +24548,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
+    if (ts24.isStringLiteral(arg) || ts24.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -24168,11 +24556,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts23.isElementAccessExpression(val))
+  if (!ts24.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts23.isIdentifier(obj) || !ts23.isIdentifier(arg))
+  if (!ts24.isIdentifier(obj) || !ts24.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -24188,35 +24576,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
+  const sf = ts24.createSourceFile("__rec.ts", `(${constInfo.value})`, ts24.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts23.isExpressionStatement(stmt))
+  if (!ts24.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts23.isParenthesizedExpression(parsed))
+  while (ts24.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts23.isObjectLiteralExpression(parsed))
+  if (!ts24.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts23.isPropertyAssignment(prop))
+    if (!ts24.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts23.isIdentifier(prop.name)) {
+    if (ts24.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts23.isStringLiteral(prop.name) || ts23.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts24.isStringLiteral(prop.name) || ts24.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts23.isParenthesizedExpression(v))
+    while (ts24.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts23.isNumericLiteral(v)) {
+    if (ts24.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts24.isStringLiteral(v) || ts24.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -24577,31 +24965,54 @@ function walkNode2(node, meta, bindings, matchers, errors, seen) {
 function mergeTemplateImports(lines) {
   const result = [];
   const valueIdx = new Map;
+  const valueDefault = 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);
+  const foldType = (src, rawNames) => {
+    if (!typeIdx.has(src)) {
+      typeIdx.set(src, result.length);
+      typeNames.set(src, new Set);
       result.push("");
     }
-    const set = names.get(src);
+    const set = typeNames.get(src);
     for (const n of rawNames.split(",").map((s) => s.trim()).filter(Boolean))
       set.add(n);
-    result[idx.get(src)] = render(src, set);
+    result[typeIdx.get(src)] = `import type { ${[...set].join(", ")} } from '${src}'`;
+  };
+  const foldValue = (src, defaultName, rawNames) => {
+    if (!valueIdx.has(src)) {
+      valueIdx.set(src, result.length);
+      valueNames.set(src, new Set);
+      result.push("");
+    }
+    if (defaultName && !valueDefault.has(src))
+      valueDefault.set(src, defaultName);
+    if (rawNames) {
+      const set = valueNames.get(src);
+      for (const n of rawNames.split(",").map((s) => s.trim()).filter(Boolean))
+        set.add(n);
+    }
+    result[valueIdx.get(src)] = renderUsedImportLines(src, valueDefault.get(src) ?? null, null, [...valueNames.get(src)]).join(`
+`);
   };
   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}'`);
+    const namedMatch = line.match(/^import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
+    const defaultNamedMatch = line.match(/^import\s+([A-Za-z_$][\w$]*)\s*,\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/);
+    const defaultOnlyMatch = line.match(/^import\s+([A-Za-z_$][\w$]*)\s*from\s*['"]([^'"]+)['"]\s*;?$/);
+    if (typeMatch) {
+      foldType(typeMatch[2], typeMatch[1]);
+    } else if (namedMatch) {
+      foldValue(namedMatch[2], null, namedMatch[1]);
+    } else if (defaultNamedMatch) {
+      foldValue(defaultNamedMatch[3], defaultNamedMatch[1], defaultNamedMatch[2]);
+    } else if (defaultOnlyMatch) {
+      foldValue(defaultOnlyMatch[2], defaultOnlyMatch[1], null);
     } else if (!seenOther.has(line)) {
       seenOther.add(line);
       result.push(line);
@@ -24643,13 +25054,13 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   if (entries.some((e) => e.componentIR.metadata.isClientComponent)) {
     const topLevelNames = new Set;
     {
-      const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
+      const sf = ts25.createSourceFile(filePath, source, ts25.ScriptTarget.Latest, true, ts25.ScriptKind.TSX);
       for (const stmt of sf.statements) {
-        if (ts24.isFunctionDeclaration(stmt) && stmt.name)
+        if (ts25.isFunctionDeclaration(stmt) && stmt.name)
           topLevelNames.add(stmt.name.text);
-        else if (ts24.isVariableStatement(stmt)) {
+        else if (ts25.isVariableStatement(stmt)) {
           for (const d of stmt.declarationList.declarations) {
-            if (ts24.isIdentifier(d.name))
+            if (ts25.isIdentifier(d.name))
               topLevelNames.add(d.name.text);
           }
         }
@@ -24708,7 +25119,7 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   const moduleStatementSeen = new Set;
   const moduleStatementsOrdered = [];
   const collectModuleStatements = (block) => {
-    const sf = ts24.createSourceFile("__bf_module_decls.tsx", block, ts24.ScriptTarget.Latest, false, ts24.ScriptKind.TSX);
+    const sf = ts25.createSourceFile("__bf_module_decls.tsx", block, ts25.ScriptTarget.Latest, false, ts25.ScriptKind.TSX);
     for (const stmt of sf.statements) {
       const text = stmt.getText(sf);
       if (moduleStatementSeen.has(text))
@@ -24797,32 +25208,9 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
     }
     const clientJsOutputs2 = allOutputs.map((o) => o.clientJs).filter(Boolean);
     if (clientJsOutputs2.length > 0) {
-      const importsBySource = new Map;
-      const otherImports = [];
-      const allCode = [];
-      for (const js of clientJsOutputs2) {
-        for (const line of js.split(`
-`)) {
-          if (line.startsWith("import ")) {
-            const match = line.match(/^import \{ ([^}]+) \} from ['"]([^'"]+)['"]$/);
-            if (match) {
-              const source2 = match[2];
-              if (!importsBySource.has(source2))
-                importsBySource.set(source2, new Set);
-              for (const n of match[1].split(",").map((n2) => n2.trim()))
-                importsBySource.get(source2).add(n);
-            } else if (!otherImports.includes(line)) {
-              otherImports.push(line);
-            }
-          }
-        }
-        allCode.push(js.replace(/^import .+\n/gm, "").trim());
-      }
-      const mergedClientImports = [...importsBySource].map(([src, names]) => `import { ${[...names].sort().join(", ")} } from '${src}'`);
       files.push({
         path: filePath.replace(/\.tsx?$/, ".client.js"),
-        content: [...mergedClientImports, ...otherImports, "", ...allCode.filter(Boolean)].join(`
-`),
+        content: mergeCompiledClientJsImports(clientJsOutputs2),
         type: "clientJs"
       });
     }
@@ -24893,53 +25281,9 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   }
   const clientJsOutputs = allOutputs.map((o) => o.clientJs).filter(Boolean);
   if (clientJsOutputs.length > 0) {
-    const importsBySource = new Map;
-    const otherImports = [];
-    const allCode = [];
-    for (const js of clientJsOutputs) {
-      const lines = js.split(`
-`);
-      const codeLines = [];
-      for (const line of lines) {
-        if (line.startsWith("import ")) {
-          const match = line.match(/^import \{ ([^}]+) \} from ['"]([^'"]+)['"]$/);
-          if (match) {
-            const names = match[1].split(",").map((n) => n.trim());
-            const source2 = match[2];
-            if (!importsBySource.has(source2)) {
-              importsBySource.set(source2, new Set);
-            }
-            const set = importsBySource.get(source2);
-            for (const name of names) {
-              set.add(name);
-            }
-          } else {
-            if (!otherImports.includes(line)) {
-              otherImports.push(line);
-            }
-          }
-        } else {
-          codeLines.push(line);
-        }
-      }
-      allCode.push(codeLines.join(`
-`).trim());
-    }
-    const mergedImports2 = [];
-    for (const [source2, names] of importsBySource) {
-      const sortedNames = [...names].sort();
-      mergedImports2.push(`import { ${sortedNames.join(", ")} } from '${source2}'`);
-    }
-    const combinedClientJs = [
-      ...mergedImports2,
-      ...otherImports,
-      "",
-      ...allCode.filter(Boolean)
-    ].join(`
-`);
     files.push({
       path: filePath.replace(/\.tsx?$/, ".client.js"),
-      content: combinedClientJs,
+      content: mergeCompiledClientJsImports(clientJsOutputs),
       type: "clientJs"
     });
   }
@@ -25012,10 +25356,24 @@ function compileJSX(source, filePath, options) {
           externalImportLines.push(`import '${imp.source}'`);
           continue;
         }
-        const used = imp.specifiers.filter((s2) => !s2.isDefault && !s2.isNamespace && !s2.isTypeOnly && isUsedAsValue(s2.alias || s2.name)).map((s2) => s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
-        if (used.length > 0) {
-          externalImportLines.push(`import { ${used.join(", ")} } from '${imp.source}'`);
+        const usedNamed = [];
+        let usedDefault = null;
+        let usedNamespace = null;
+        for (const s2 of imp.specifiers) {
+          if (s2.isTypeOnly)
+            continue;
+          const localName = s2.alias || s2.name;
+          if (!isUsedAsValue(localName))
+            continue;
+          if (s2.isDefault) {
+            usedDefault = localName;
+          } else if (s2.isNamespace) {
+            usedNamespace = localName;
+          } else {
+            usedNamed.push(s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
+          }
         }
+        externalImportLines.push(...renderUsedImportLines(imp.source, usedDefault, usedNamespace, usedNamed));
       }
       const allImports = [runtimeImportLine, ...externalImportLines].filter(Boolean).join(`
 `);
@@ -25151,7 +25509,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -25172,10 +25530,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts25.ScriptTarget.Latest,
-    module: ts25.ModuleKind.ESNext,
-    moduleResolution: ts25.ModuleResolutionKind.Bundler,
-    jsx: ts25.JsxEmit.ReactJSX,
+    target: ts26.ScriptTarget.Latest,
+    module: ts26.ModuleKind.ESNext,
+    moduleResolution: ts26.ModuleResolutionKind.Bundler,
+    jsx: ts26.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -25185,7 +25543,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts25.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts26.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -25469,7 +25827,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // src/adapters/template-imports.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -25519,18 +25877,18 @@ function specKey(s) {
 function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
   if (!sourceText.includes("import"))
     return sourceText;
-  const sf = ts26.createSourceFile("bf-template-fragment.tsx", sourceText, ts26.ScriptTarget.Latest, false, ts26.ScriptKind.TSX);
+  const sf = ts27.createSourceFile("bf-template-fragment.tsx", sourceText, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.TSX);
   const edits = [];
   const visit3 = (node) => {
-    if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts26.isStringLiteralLike(node.arguments[0])) {
+    if (ts27.isCallExpression(node) && node.expression.kind === ts27.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts27.isStringLiteralLike(node.arguments[0])) {
       collect(node.arguments[0]);
     }
-    if (ts26.isImportTypeNode(node) && ts26.isLiteralTypeNode(node.argument)) {
+    if (ts27.isImportTypeNode(node) && ts27.isLiteralTypeNode(node.argument)) {
       const literal = node.argument.literal;
-      if (ts26.isStringLiteralLike(literal))
+      if (ts27.isStringLiteralLike(literal))
         collect(literal);
     }
-    ts26.forEachChild(node, visit3);
+    ts27.forEachChild(node, visit3);
   };
   const collect = (literal) => {
     const specifier = literal.text;
@@ -25545,7 +25903,7 @@ function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
       text: `'${next}'`
     });
   };
-  ts26.forEachChild(sf, visit3);
+  ts27.forEachChild(sf, visit3);
   if (edits.length === 0)
     return sourceText;
   let out = sourceText;
@@ -26310,7 +26668,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts27 from "typescript";
+import ts28 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -26367,10 +26725,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts27.createSourceFile("combine.js", content, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.JS);
+  const sourceFile = ts28.createSourceFile("combine.js", content, ts28.ScriptTarget.Latest, false, ts28.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts27.isImportDeclaration(stmt))
+    if (!ts28.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -26380,8 +26738,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts27.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts27.isNamedImports(bindings)) {
+    const specifier = ts28.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts28.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -26548,7 +26906,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts28 from "typescript";
+import ts29 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -27836,7 +28194,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts28.createSourceFile("__attr.tsx", `(${expr})`, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
+    sf = ts29.createSourceFile("__attr.tsx", `(${expr})`, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -27844,11 +28202,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts28.isPropertyAccessExpression(n) && ts28.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts29.isPropertyAccessExpression(n) && ts29.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts28.forEachChild(n, visit3);
+    ts29.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -27918,7 +28276,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts29 from "typescript";
+import ts30 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -28188,15 +28546,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts29.createSourceFile(filePath, source, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
+  const sf = ts30.createSourceFile(filePath, source, ts30.ScriptTarget.Latest, true, ts30.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts30.isCallExpression(node) && ts30.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 });
     }
-    ts29.forEachChild(node, visit3);
+    ts30.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -28504,13 +28862,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts29.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts29.ScriptTarget.Latest, true);
+    sf = ts30.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts30.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression)) {
+    if (ts30.isCallExpression(node) && ts30.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -28519,7 +28877,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts29.forEachChild(node, visit3);
+    ts30.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -29163,6 +29521,7 @@ export {
   sortComparatorFromArrow,
   serializeParsedExpr,
   searchParamsLocalNames,
+  scanComponentFile,
   rewriteImportsForTemplate,
   rewriteDynamicImportsInSource,
   resolveStaticLoopSource,