npm - @barefootjs/vite - Versions diffs - 0.33.2 → 0.33.3 - Mend

@barefootjs/vite 0.33.2 → 0.33.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/discover.d.ts +78 -6
package/dist/discover.d.ts.map +1 -1
package/dist/index.js +742 -384
package/package.json +6 -6
package/src/__tests__/discover.test.ts +140 -12
package/src/__tests__/e2e-vite-build.test.ts +45 -1
package/src/__tests__/e2e-vite-dev.test.ts +20 -0
package/src/__tests__/plugin.test.ts +29 -4
package/src/discover.ts +159 -27
package/src/plugin.ts +2 -2

package/dist/index.js CHANGED Viewed

@@ -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")
@@ -3337,7 +3393,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,10 +3404,12 @@ 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);
+        const attrName = a.name === "..." ? "..." : a.name === "key" ? keyAttrName2(loopDepth) : toHTMLAttrName(a.name);
         return renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames);
       }).filter(Boolean);
       const hoistedScopeAttr = maybeHoistedScopeAttr(inHoistedChildren, node);
@@ -3373,17 +3431,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 +3535,7 @@ function buildLoopSkeletonTemplate(node, safe) {
         if (a.name === "dangerouslySetInnerHTML")
           return null;
         if (a.name === "key") {
-          attrParts.push(`${keyAttrName(0)}=""`);
+          attrParts.push(`${keyAttrName2(0)}=""`);
           continue;
         }
         const v = a.value;
@@ -3682,7 +3741,9 @@ 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 "";
+        const attrName = a.name === "..." ? "..." : a.name === "key" ? keyAttrName2(loopDepth) : toHTMLAttrName(a.name);
         return renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames);
       }).filter(Boolean);
       if (node.slotId) {
@@ -3705,7 +3766,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 +3949,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 +4009,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 +4292,7 @@ function generateCsrTemplateWithOpts(node, opts) {
             return "";
           return `\${spreadAttrs(${transformExpr(v.expr, v.templateExpr)})}`;
         }
-        const attrName = a.name === "key" ? keyAttrName(loopDepth) : toHTMLAttrName(a.name);
+        const attrName = a.name === "key" ? keyAttrName2(loopDepth) : toHTMLAttrName(a.name);
         switch (v.kind) {
           case "boolean-attr":
             return attrName;
@@ -4278,7 +4340,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 +4648,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 +7819,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 +10195,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 +10421,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
       type: "expression",
       expr,
       templateExpr: `escapeText(${templateExpr ?? expr})`,
+      escapeInClientTemplate: true,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -10339,7 +10459,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 +10492,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 +10731,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 +10808,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) {
@@ -11803,6 +11925,16 @@ 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);
+  }
+}
 function loopBodyItemConditional(children) {
   const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
   if (real.length !== 1)
@@ -12185,6 +12317,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 resolvedKeyAttrName = keyAttrName(depth);
+    if (bodyIsItemConditional) {
+      applyLoopKeyAttr(itemConditional, resolvedKeyAttrName, key);
+    } else if (children.length > 0) {
+      applyLoopKeyAttr(children[0], resolvedKeyAttrName, key);
+    }
+  }
   const declaredNameSet = preamble && preamble.declaredNames.length > 0 ? new Set(preamble.declaredNames) : undefined;
   if (key && declaredNameSet) {
     const keyRefs = extractFreeIdentifiersFromText(key);
@@ -12875,7 +13015,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 +13523,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 +13757,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 +14004,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 +14900,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;
@@ -15556,6 +15818,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 +15927,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeTextOrNode",
   "bfMarkup",
   "escapeTextOrMarkup",
+  "markupOrEmpty",
   "qsa",
   "qsaItem",
   "qsaChildScope",
@@ -15728,6 +15994,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 +16082,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 +16136,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 +16164,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 +16280,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 +16293,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 +16345,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 +16367,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 +16381,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16044,13 +16391,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 +16407,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 +17712,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 +17741,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 +19203,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 +19223,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 +19257,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 +19272,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 +19851,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 +19963,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 +20012,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 +20264,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 +20287,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) {
@@ -20749,7 +21096,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 +21136,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 +21152,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 +21340,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}')`);
   }
@@ -21699,7 +22046,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 +22061,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 +22083,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 +22404,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 +22742,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 +22764,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 +22787,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 +22839,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 +22862,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 +22875,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 +22902,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 +22935,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 +22985,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 +23044,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 +23074,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 +23084,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 +23188,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 +23230,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 +23257,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 +23304,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 +23338,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 +23350,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 +23364,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 +23377,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 +23400,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 +23416,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 +23449,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 +23484,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 +23546,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 +23576,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 +23936,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 +24025,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 +24090,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 +24179,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 +24252,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 +24327,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 +24480,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 +24502,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 +24515,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 +24798,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 +25191,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 +25334,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 +25361,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 +25733,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 +25819,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;
       }