@barefootjs/vite 0.33.2 → 0.33.4

package/dist/index.js

@@ -3,7 +3,7 @@ import { mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } f
 import { relative as relative2, resolve as resolve7, sep as sep3 } from "node:path";
 
 // ../jsx/src/compiler.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 
 // ../jsx/src/analyzer.ts
 import ts9 from "typescript";
@@ -1885,6 +1885,9 @@ function loopEndMarker(markerId) {
 }
 var BF_KEY = "data-key";
 var BF_KEY_PREFIX = "data-key-";
+function keyAttrName(loopDepth) {
+  return loopDepth > 0 ? `${BF_KEY_PREFIX}${loopDepth}` : BF_KEY;
+}
 var BF_PLACEHOLDER = "data-bf-ph";
 var BF_PARENT_SCOPE_PLACEHOLDER = "__BF_PARENT_SCOPE__";
 // ../shared/src/dom-prop.ts
@@ -2058,6 +2061,29 @@ var SVG_XML_CAMEL_ATTRS = new Set([
   "yChannelSelector",
   "zoomAndPan"
 ]);
+function isEventProp(key) {
+  return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] >= "A" && key[2] <= "Z";
+}
+function classifyDOMProp(key) {
+  if (key === "children")
+    return { kind: "skip", attrName: key };
+  if (key === "ref")
+    return { kind: "ref", attrName: key };
+  if (key === "dangerouslySetInnerHTML")
+    return { kind: "innerHTML", attrName: key };
+  if (isEventProp(key))
+    return { kind: "event", attrName: key };
+  const attrName = toHTMLAttrNameRuntime(key);
+  if (attrName === "style")
+    return { kind: "style", attrName };
+  if (attrName === "value")
+    return { kind: "property", attrName };
+  if (attrName === "checked")
+    return { kind: "property", attrName };
+  if (BOOLEAN_ATTRS.has(attrName.toLowerCase()))
+    return { kind: "boolean", attrName };
+  return { kind: "attr", attrName };
+}
 function toHTMLAttrName(key) {
   if (key === "className")
     return "class";
@@ -2071,6 +2097,24 @@ function toHTMLAttrName(key) {
     return svgKebab;
   return key;
 }
+function toHTMLAttrNameRuntime(key) {
+  if (key === "className")
+    return "class";
+  if (key === "htmlFor")
+    return "for";
+  const htmlAlias = HTML_CAMEL_ALIASES[key];
+  if (htmlAlias !== undefined)
+    return htmlAlias;
+  const svgKebab = SVG_CAMEL_TO_KEBAB[key];
+  if (svgKebab !== undefined)
+    return svgKebab;
+  if (SVG_XML_CAMEL_ATTRS.has(key))
+    return key;
+  if (key.startsWith("data") || key.startsWith("aria")) {
+    return key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  }
+  return key;
+}
 function isBooleanAttr(name) {
   return BOOLEAN_ATTRS.has(name.toLowerCase());
 }
@@ -2146,8 +2190,12 @@ function escapeHtml(text) {
 }
 // ../jsx/src/ir-to-client-js/utils.ts
 var PROPS_PARAM = "_p";
-function keyAttrName(loopDepth) {
-  return loopDepth > 0 ? `${BF_KEY_PREFIX}${loopDepth}` : BF_KEY;
+var keyAttrName2 = keyAttrName;
+function mapArrayKeyArgs(bfIdArg, keyed, loopDepth) {
+  if (!keyed || loopDepth <= 0)
+    return bfIdArg;
+  const bfIdSlot = bfIdArg || ", undefined";
+  return `${bfIdSlot}, ${JSON.stringify(keyAttrName2(loopDepth))}`;
 }
 function varSlotId(slotId) {
   return slotId.startsWith("^") ? slotId.slice(1) : slotId;
@@ -3130,6 +3178,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")
@@ -3177,6 +3233,9 @@ function renderTemplateAttrPart(attr, attrName, wrap, restSpreadNames) {
       return "";
   }
 }
+function resolvedKeyAttrName(node, loopDepth) {
+  return node.keyAttr ? keyAttrName2(loopDepth) : null;
+}
 function isMergeableAttr(a, ctx) {
   if (ctx.honorClientOnly && a.clientOnly)
     return false;
@@ -3337,7 +3396,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;
@@ -3348,11 +3407,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)
@@ -3373,17 +3437,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);
@@ -3476,7 +3541,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(`${keyAttrName2(0)}=""`);
+          }
           continue;
         }
         const v = a.value;
@@ -3682,7 +3749,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) {
@@ -3705,7 +3778,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);
@@ -3887,7 +3961,7 @@ function irToComponentTemplateWithOpts(node, opts) {
         if (a.name === "key") {
           if (loopDepth === 0)
             return "";
-          const keyName = keyAttrName(loopDepth);
+          const keyName = keyAttrName2(loopDepth);
           switch (v.kind) {
             case "expression":
               return templateAttrExpr(keyName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
@@ -3947,7 +4021,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) {
@@ -4230,7 +4304,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;
@@ -4278,7 +4372,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) {
@@ -4586,6 +4680,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;
+}
 
 // ../jsx/src/instrumentation.ts
 var _enabled = false;
@@ -7744,6 +7851,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);
@@ -10110,10 +10227,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) {
@@ -10302,6 +10453,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
       type: "expression",
       expr,
       templateExpr: `escapeText(${templateExpr ?? expr})`,
+      escapeInClientTemplate: true,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -10339,7 +10491,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);
@@ -10372,7 +10524,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;
@@ -10611,7 +10763,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;
@@ -10686,7 +10840,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) {
@@ -11565,6 +11719,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) {
@@ -11755,7 +11913,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;
           }
@@ -11803,6 +11961,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)
@@ -12033,7 +12207,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.",
@@ -12120,7 +12294,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.",
@@ -12185,6 +12359,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 = keyAttrName(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);
@@ -12575,7 +12757,7 @@ function computePreambleReactiveNames(statements, ctx) {
   }
   return reactiveNames;
 }
-function preambleFromValueStatements(statements, ctx) {
+function preambleFromValueStatements(statements, ctx, bodyStatements) {
   const segments = [];
   const typedParts = [];
   const declared = new Set;
@@ -12595,11 +12777,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))
@@ -12609,6 +12791,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;
@@ -12619,7 +12806,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];
@@ -12816,7 +13026,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);
@@ -12875,7 +13085,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) {
@@ -13383,34 +13593,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));
@@ -13509,6 +13827,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")
@@ -13731,18 +14074,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
 
 // ../jsx/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) {
@@ -14638,8 +14970,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;
@@ -15349,6 +15681,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 }) => {
@@ -15556,6 +15890,9 @@ function propHasPropertyAccess(u) {
   return u.accessKinds.has("property") || u.accessKinds.has("index");
 }
 
+// ../jsx/src/ir-to-client-js/imports.ts
+import ts16 from "typescript";
+
 // ../jsx/src/value-references.ts
 import ts15 from "typescript";
 function isValueReferenceIdentifier(id) {
@@ -15662,6 +15999,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeTextOrNode",
   "bfMarkup",
   "escapeTextOrMarkup",
+  "markupOrEmpty",
   "qsa",
   "qsaItem",
   "qsaChildScope",
@@ -15728,6 +16066,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 = [];
@@ -15743,23 +16154,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;
@@ -15789,7 +16208,7 @@ function collectComponentNames(node) {
 }
 
 // ../jsx/src/relocate.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -15817,19 +16236,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;
@@ -15933,11 +16352,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;
@@ -15946,11 +16365,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;
@@ -15998,12 +16417,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;
   }
@@ -16020,8 +16439,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) {
@@ -16034,7 +16453,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16044,13 +16463,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;
@@ -16060,25 +16479,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;
@@ -17365,23 +17784,23 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 }
 
 // ../jsx/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;
@@ -17394,10 +17813,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);
@@ -18856,7 +19275,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // ../jsx/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 }
@@ -18876,12 +19295,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) {
@@ -18910,12 +19329,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);
   }
@@ -18925,56 +19344,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;
 }
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -19504,7 +19923,7 @@ function buildArmBody(branch, options) {
 }
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -19616,20 +20035,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)
@@ -19665,20 +20084,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)
@@ -19917,7 +20336,7 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       lines.push(`${indent}  let __bel${uid} = __existing ?? (() => { const __t = document.createElement('template'); __t.innerHTML = \`${innerHtml}\`; return __t.content${childPath}.cloneNode(true) })()`);
     }
     if (inner.wrappedKey) {
-      lines.push(`${indent}  __bel${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${inner.wrappedKey}))`);
+      lines.push(`${indent}  __bel${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${inner.wrappedKey}))`);
     }
     if (inner.legacyComponents.length > 0 || inner.legacyEvents.length > 0) {
       emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings);
@@ -19940,7 +20359,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) {
@@ -20172,12 +20591,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 }`);
@@ -20749,7 +21171,7 @@ function emitReactive(lines, inner, indent, pc) {
     lines.push(`${indent}  let __innerEl${uid} = __existing ?? (() => { const __t = document.createElement('template'); __t.innerHTML = \`${innerHtml}\`; return __t.content${childPath}.cloneNode(true) })()`);
   }
   if (emit.wrappedKey) {
-    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${emit.wrappedKey}))`);
+    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${emit.wrappedKey}))`);
   }
   if (emit.components.length > 0 || emit.events.length > 0) {
     emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
@@ -20789,7 +21211,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;
@@ -20805,7 +21227,7 @@ function emitStatic(lines, inner, indent, pc) {
     lines.push(`${indent}  ${stmt}`);
   }
   if (emit.rawKey) {
-    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${emit.rawKey}))`);
+    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${emit.rawKey}))`);
   }
   emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
   if (inner.childLevels.length > 0) {
@@ -20993,7 +21415,7 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
   }
   const evVar = varSlotId(ev.childSlotId);
   for (const nested of ev.nestedLoops) {
-    const dataAttr = keyAttrName(nested.depth);
+    const dataAttr = keyAttrName2(nested.depth);
     ls.push(`      const innerLi${nested.depth} = ${evVar}El.closest('[${dataAttr}]')`);
     ls.push(`      const innerKey${nested.depth} = innerLi${nested.depth}?.getAttribute('${dataAttr}')`);
   }
@@ -21293,6 +21715,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;
@@ -21310,6 +21738,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
   return {
     kind: "component",
     rowConstruction: "dom-ops",
+    mapPreambleWrapped,
     containerVar: `_${varSlotId(elem.slotId)}`,
     markerId: elem.markerId,
     arrayExpr: buildChainedArrayExpr(elem),
@@ -21492,6 +21921,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);
   }
@@ -21699,7 +22129,7 @@ var PHASES = [
 ];
 
 // ../jsx/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;
@@ -21714,13 +22144,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)
@@ -21736,17 +22166,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;
 }
@@ -22057,7 +22487,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);
 }
@@ -22395,7 +22825,7 @@ function walkIR2(node, visitor) {
 }
 
 // ../jsx/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) {
@@ -22417,8 +22847,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 };
   }
@@ -22440,22 +22870,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;
@@ -22492,7 +22922,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 };
   }
@@ -22515,11 +22945,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);
 }
@@ -22528,24 +22958,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;
@@ -22555,13 +22985,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);
     });
   }
@@ -22588,48 +23018,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;
       }
@@ -22638,43 +23068,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;
@@ -22697,29 +23127,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;
@@ -22727,7 +23157,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);
@@ -22737,7 +23167,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // ../jsx/src/ssr-defaults.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -22841,11 +23271,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);
 }
@@ -22883,23 +23313,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;
       }
@@ -22910,45 +23340,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)
@@ -22957,29 +23387,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;
@@ -22991,10 +23421,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)
@@ -23003,7 +23433,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;
@@ -23017,7 +23447,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;
@@ -23030,13 +23460,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;
@@ -23053,7 +23483,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 sep = ",";
@@ -23069,27 +23499,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;
@@ -23102,30 +23532,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;
@@ -23137,41 +23567,41 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts22.isNoSubstitutionTemplateLiteral(node))
+  if (ts23.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // ../jsx/src/augment-inherited-props.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 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)
@@ -23199,28 +23629,28 @@ function collectModuleStringConsts(constants) {
   return map;
 }
 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;
@@ -23229,7 +23659,7 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
+    if (ts24.isStringLiteral(arg) || ts24.isNoSubstitutionTemplateLiteral(arg))
       sep = arg.text;
     else
       return null;
@@ -23589,31 +24019,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);
@@ -23655,13 +24108,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);
           }
         }
@@ -23720,7 +24173,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))
@@ -23809,32 +24262,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"
       });
     }
@@ -23905,53 +24335,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"
     });
   }
@@ -24024,10 +24410,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(`
 `);
@@ -24163,7 +24563,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // ../jsx/src/shared-program.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 import path3 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0)
@@ -24185,10 +24585,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,
@@ -24198,7 +24598,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path3.resolve(f));
-  return ts25.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts26.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
@@ -24481,7 +24881,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // ../jsx/src/adapters/template-imports.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -24874,11 +25274,11 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-import ts27 from "typescript";
-// ../jsx/src/debug.ts
 import ts28 from "typescript";
-// ../jsx/src/profiler.ts
+// ../jsx/src/debug.ts
 import ts29 from "typescript";
+// ../jsx/src/profiler.ts
+import ts30 from "typescript";
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();
@@ -25017,21 +25417,24 @@ async function discoverComponents(entries, readFile) {
       seen.add(absPath);
       const content = await readFile(absPath);
       const isClient = hasUseClientDirective(content);
+      const scan = scanComponentFile(content, absPath);
       out.push({
         absPath,
         content,
         isClient,
-        exportedComponents: isClient ? listComponentFunctions(content, absPath) : [],
+        exportedComponents: scan.exports,
+        referencedComponents: scan.referencedComponents,
         cssLayerPrefix: entry.cssLayerPrefix
       });
     }
   }
-  return out;
+  const clientEntryPaths = computeClientEntryPaths(out);
+  return out.map((row) => ({ ...row, needsClientEntry: clientEntryPaths.has(row.absPath) }));
 }
-function buildChildNameIndex(discovered) {
+function nameIndexOver(rows, include) {
   const index = new Map;
-  for (const c of discovered) {
-    if (!c.isClient)
+  for (const c of rows) {
+    if (!include(c))
       continue;
     const names = c.exportedComponents.length > 0 ? c.exportedComponents : [basename(c.absPath).replace(/\.tsx?$/, "")];
     for (const name of names) {
@@ -25041,6 +25444,44 @@ function buildChildNameIndex(discovered) {
   }
   return index;
 }
+function computeClientEntryPaths(rows) {
+  const nameToPath = nameIndexOver(rows, () => true);
+  const referencers = new Map;
+  for (const row of rows) {
+    for (const name of row.referencedComponents) {
+      const target = nameToPath.get(name);
+      if (!target || target === row.absPath)
+        continue;
+      let set = referencers.get(target);
+      if (!set) {
+        set = new Set;
+        referencers.set(target, set);
+      }
+      set.add(row.absPath);
+    }
+  }
+  const visited = new Set;
+  const queue = [];
+  for (const row of rows) {
+    if (row.isClient && !visited.has(row.absPath)) {
+      visited.add(row.absPath);
+      queue.push(row.absPath);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const referencer of referencers.get(current) ?? []) {
+      if (visited.has(referencer))
+        continue;
+      visited.add(referencer);
+      queue.push(referencer);
+    }
+  }
+  return visited;
+}
+function buildChildNameIndex(discovered) {
+  return nameIndexOver(discovered, (c) => c.needsClientEntry);
+}
 
 // src/resolve-client-js.ts
 import { existsSync } from "node:fs";
@@ -25375,7 +25816,7 @@ function barefoot(options) {
       const canonical = compileCanonical(component.absPath, content);
       reportErrors(canonical, content, projectDir);
       let result = canonical;
-      if (component.isClient) {
+      if (component.needsClientEntry) {
         const { scriptAssets, preloadAssets } = resolveAssetsFor(component);
         if (scriptAssets.length > 0) {
           result = compileJSX(content, component.absPath, {
@@ -25461,7 +25902,7 @@ function barefoot(options) {
       const found = await discoverComponents(guessedEntries, (absPath) => readFile2(absPath, "utf8"));
       const input = {};
       for (const c of found) {
-        if (!c.isClient)
+        if (!c.needsClientEntry)
           continue;
         input[safeRollupEntryName(guessedRoot, c.absPath, dirs)] = c.absPath;
       }