@barefootjs/jsx 0.33.1 → 0.33.3

package/dist/index.js

@@ -177,7 +177,7 @@ function findTopLevelTemplateLiterals(code) {
 }
 
 // src/compiler.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 
 // src/analyzer.ts
 import ts9 from "typescript";
@@ -228,6 +228,9 @@ var ARRAY_METHOD_NAMES = [
   "padEnd",
   "flat"
 ];
+var SORT_KEY_TYPES = ["numeric", "string", "auto"];
+var SORT_KEY_TARGETS = ["self", "field"];
+var SORT_KEY_DIRECTIONS = ["asc", "desc"];
 var UNSUPPORTED_METHODS = new Set([
   "filter",
   "map",
@@ -2381,11 +2384,16 @@ import {
   loopStartMarker,
   loopEndMarker,
   loopItemMarker,
-  toHTMLAttrName as toHtmlAttrName
+  toHTMLAttrName as toHtmlAttrName,
+  keyAttrName as sharedKeyAttrName
 } from "@barefootjs/shared";
 var PROPS_PARAM = "_p";
-function keyAttrName(loopDepth) {
-  return loopDepth > 0 ? `${DATA_KEY_PREFIX}${loopDepth}` : DATA_KEY;
+var keyAttrName = sharedKeyAttrName;
+function mapArrayKeyArgs(bfIdArg, keyed, loopDepth) {
+  if (!keyed || loopDepth <= 0)
+    return bfIdArg;
+  const bfIdSlot = bfIdArg || ", undefined";
+  return `${bfIdSlot}, ${JSON.stringify(keyAttrName(loopDepth))}`;
 }
 function varSlotId(slotId) {
   return slotId.startsWith("^") ? slotId.slice(1) : slotId;
@@ -3375,6 +3383,14 @@ function escapeAttrValueExpr(valExpr) {
 function escapeTextSlotExpr(innerExpr, isMarkup = false) {
   return `${isMarkup ? "escapeTextOrMarkup" : "escapeText"}(${innerExpr})`;
 }
+function isChildrenPassthroughExpr(expr) {
+  return /^([A-Za-z_$][\w$]*\.)?children$/.test(expr.trim());
+}
+function bareSpliceExpr(node, valueExpr) {
+  const resolved = valueExpr.trim().replace(/^\(+|\)+$/g, "");
+  const isChildren = isChildrenPassthroughExpr(node.expr) || isChildrenPassthroughExpr(resolved);
+  return !node.joinArrayChild && isChildren ? `markupOrEmpty(${valueExpr})` : valueExpr;
+}
 function dangerouslyHtmlChildren(attrs, toExpr) {
   const attr = attrs.find((a) => a.name === "dangerouslySetInnerHTML");
   if (!attr || attr.value.kind !== "expression")
@@ -3582,7 +3598,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;
@@ -3593,6 +3609,8 @@ 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 : "";
         }
@@ -3618,17 +3636,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);
@@ -3927,6 +3946,8 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
   switch (node.type) {
     case "element": {
       const attrParts = node.attrs.map((a) => {
+        if (a.clientOnly)
+          return "";
         const attrName = a.name === "..." ? "..." : a.name === "key" ? keyAttrName(loopDepth) : toHtmlAttrName(a.name);
         return renderTemplateAttrPart(a, attrName, wrapExpr, restSpreadNames);
       }).filter(Boolean);
@@ -3950,7 +3971,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);
@@ -4192,7 +4214,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) {
@@ -4523,7 +4545,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) {
@@ -4831,6 +4853,19 @@ function buildPropAliasMap(params) {
   }
   return map;
 }
+function resolveRestSpreadOriginCore(bindings, constantValues, name) {
+  const visited = new Set;
+  let current = name.trim();
+  while (current !== undefined && !visited.has(current)) {
+    if (bindings.restPropsName && current === bindings.restPropsName)
+      return "rest";
+    if (bindings.propsObjectName && current === bindings.propsObjectName)
+      return "props";
+    visited.add(current);
+    current = constantValues.get(current)?.trim();
+  }
+  return null;
+}
 
 // src/instrumentation.ts
 var _enabled = false;
@@ -8320,6 +8355,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);
@@ -10261,7 +10306,7 @@ var toLocaleDatePlugin = {
 };
 
 // src/jsx-to-ir.ts
-import { toHTMLAttrName, decodeEntities } from "@barefootjs/shared";
+import { toHTMLAttrName, decodeEntities, BF_KEY, keyAttrName as keyAttrName2 } from "@barefootjs/shared";
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -10714,10 +10759,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) {
@@ -10906,6 +10985,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
       type: "expression",
       expr,
       templateExpr: `escapeText(${templateExpr ?? expr})`,
+      escapeInClientTemplate: true,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -10943,7 +11023,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);
@@ -10976,7 +11056,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;
@@ -11202,6 +11282,33 @@ function unwrapHoistedFragment(node) {
     return node;
   return { ...only, needsScope: true };
 }
+function markDataKeyCarrier(children) {
+  for (let i = 0;i < children.length; i++) {
+    const marked = markCarrierIn(children[i]);
+    if (!marked)
+      continue;
+    const out = children.slice();
+    out[i] = marked;
+    return out;
+  }
+  return children;
+}
+function markCarrierIn(node) {
+  if (node.type === "element") {
+    if (node.keyAttr)
+      return null;
+    return { ...node, keyAttr: { name: BF_KEY } };
+  }
+  if (node.type === "conditional") {
+    const cond = node;
+    const whenTrue = markCarrierIn(cond.whenTrue);
+    const whenFalse = markCarrierIn(cond.whenFalse);
+    if (!whenTrue && !whenFalse)
+      return null;
+    return { ...cond, whenTrue: whenTrue ?? cond.whenTrue, whenFalse: whenFalse ?? cond.whenFalse };
+  }
+  return null;
+}
 function transformFragment(node, ctx) {
   const isFragmentRoot = ctx.isRoot;
   const isTransparent = isFragmentRoot && isTransparentFragment(node, ctx);
@@ -11212,7 +11319,7 @@ function transformFragment(node, ctx) {
   const needsScopeComment = isFragmentRoot && !isTransparent || undefined;
   return {
     type: "fragment",
-    children,
+    children: needsScopeComment ? markDataKeyCarrier(children) : children,
     transparent: isTransparent || undefined,
     needsScopeComment,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
@@ -11265,7 +11372,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) {
@@ -12382,6 +12489,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)
@@ -12764,6 +12881,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 = keyAttrName2(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);
@@ -13454,7 +13579,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) {
@@ -13962,34 +14087,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));
@@ -14088,6 +14321,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")
@@ -14309,6 +14567,39 @@ function buildIfStatementChain(analyzer, ctx, opts) {
 }
 
 // src/ir-to-client-js/prop-handling.ts
+function resolveRestSpreadOrigin(ctx, name) {
+  return resolveRestSpreadOriginCore(ctx, localConstantValues(ctx), name);
+}
+var _localConstantValuesCache = new WeakMap;
+function localConstantValues(ctx) {
+  const cached = _localConstantValuesCache.get(ctx);
+  if (cached)
+    return cached;
+  const byName = new Map;
+  for (const constant of ctx.localConstants) {
+    if (!byName.has(constant.name))
+      byName.set(constant.name, constant.value);
+  }
+  _localConstantValuesCache.set(ctx, byName);
+  return byName;
+}
+var _restSpreadNamesCache = new WeakMap;
+function resolveRestSpreadNames(ctx) {
+  const cached = _restSpreadNamesCache.get(ctx);
+  if (cached)
+    return cached;
+  const names = new Set;
+  if (ctx.restPropsName)
+    names.add(ctx.restPropsName);
+  if (ctx.propsObjectName)
+    names.add(ctx.propsObjectName);
+  for (const constant of ctx.localConstants) {
+    if (resolveRestSpreadOrigin(ctx, constant.name) !== null)
+      names.add(constant.name);
+  }
+  _restSpreadNamesCache.set(ctx, names);
+  return names;
+}
 function expandDynamicPropValue(value, ctx, scope) {
   const trimmedValue = value.trim();
   if (scope?.isBound(trimmedValue))
@@ -14397,6 +14688,9 @@ function decideWrapForChildProp(expandedValue, ctx, prop) {
   return decideWrapForAttr(expandedValue, ctx, prop);
 }
 function needsEffectWrapper(expr, ctx, freeIdentifiers2) {
+  return needsEffectWrapperCore(expr, ctx, freeIdentifiers2, new Set);
+}
+function needsEffectWrapperCore(expr, ctx, freeIdentifiers2, visitedConstants) {
   for (const signal of ctx.signals) {
     if (identifierCallPattern(signal.getter).test(expr)) {
       return true;
@@ -14419,6 +14713,19 @@ function needsEffectWrapper(expr, ctx, freeIdentifiers2) {
     if (propsAccess.test(expr))
       return true;
   }
+  for (const constant of ctx.localConstants) {
+    if (visitedConstants.has(constant.name))
+      continue;
+    if (constant.value === undefined || constant.containsArrow)
+      continue;
+    const referenced = freeIdentifiers2 ? freeIdentifiers2.has(constant.name) : tokenContainsIdent(expr, constant.name);
+    if (!referenced)
+      continue;
+    visitedConstants.add(constant.name);
+    if (needsEffectWrapperCore(constant.value, ctx, constant.freeIdentifiers, visitedConstants)) {
+      return true;
+    }
+  }
   return false;
 }
 function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentifiers2) {
@@ -14871,6 +15178,7 @@ function emitMultiRootTemplateCloneLines(template, indent, varEl, varExtras) {
 }
 
 // src/ir-to-client-js/collect-elements.ts
+import { classifyDOMProp } from "@barefootjs/shared";
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
 function domElementCount(node) {
   switch (node.type) {
@@ -15092,24 +15400,14 @@ function jsxChildrenContainComponent(nodes) {
 function isSingleElementJsxChildren2(nodes) {
   return nodes.length === 1 && nodes[0].type === "element";
 }
-function buildRestSpreadNames(ctx) {
-  const names = new Set;
-  if (ctx.restPropsName)
-    names.add(ctx.restPropsName);
-  if (ctx.propsObjectName)
-    names.add(ctx.propsObjectName);
-  return names;
-}
 function buildComponentPropsExpr(props, ctx) {
-  const restName = ctx.restPropsName;
-  const propsObjName = ctx.propsObjectName;
   const knownSpreadProp = props.find((p) => {
     if (p.name !== "..." && !p.name.startsWith("..."))
       return false;
     if (p.value.kind !== "spread" && p.value.kind !== "expression")
       return false;
     const expr = p.value.kind === "spread" ? p.value.expr : p.value.expr;
-    return expr === restName || expr === propsObjName;
+    return resolveRestSpreadOrigin(ctx, expr) !== null;
   });
   const spreadSource = knownSpreadProp ? PROPS_PARAM : null;
   const propsForInit = [];
@@ -15167,8 +15465,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;
@@ -15257,13 +15555,13 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
-          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, undefined, undefined);
+          staticItemTemplate = irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, undefined, undefined);
         }
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
-        template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, loopParamSpec);
+        template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec);
         if (l.isStaticArray) {
-          staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0);
+          staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0);
         } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
           const skeletonSafeSlots = {
             reactiveAttrKeys: new Set(bindings.reactiveAttrs.map((a) => `${a.childSlotId}::${a.attrName}`)),
@@ -15315,11 +15613,11 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         preambleRegions: l.preambleRegions,
         flatMapClient: projectionInner ? {
           params: l.index ? `(${l.param}, ${l.index})` : `(${l.param})`,
-          body: renderFlatMapProjectionClientBody(projectionInner, buildRestSpreadNames(ctx)),
+          body: renderFlatMapProjectionClientBody(projectionInner, resolveRestSpreadNames(ctx)),
           keyed: projectionInner.key !== null
         } : l.flatMapCallback ? {
           params: l.flatMapCallback.params,
-          body: renderFlatMapClientBody(l.flatMapCallback, buildRestSpreadNames(ctx)),
+          body: renderFlatMapClientBody(l.flatMapCallback, resolveRestSpreadNames(ctx)),
           keyed: flatMapCallbackHasKeyedLeaf(l.flatMapCallback)
         } : undefined
       });
@@ -15386,10 +15684,9 @@ function collectFromElement(element, ctx, insideConditional = false) {
     for (const attr of element.attrs) {
       if (attr.name === "..." && attr.value) {
         const spreadVal = attrValueToString(attr.value) ?? "";
-        const elemRestName = ctx.restPropsName;
-        const elemPropsObjName = ctx.propsObjectName;
-        if (spreadVal && (spreadVal === elemRestName || spreadVal === elemPropsObjName)) {
-          const consumedKeys = spreadVal === elemRestName ? ctx.propsParams.map((p) => p.sourceName ?? p.name) : [];
+        const spreadOrigin = spreadVal ? resolveRestSpreadOrigin(ctx, spreadVal) : null;
+        if (spreadOrigin !== null) {
+          const consumedKeys = spreadOrigin === "rest" ? ctx.propsParams.map((p) => p.sourceName ?? p.name) : [];
           const staticAttrKeys = element.attrs.filter((a) => a.name !== "...").map((a) => a.name);
           const excludeKeys = [...new Set([...consumedKeys, ...staticAttrKeys])];
           ctx.restAttrElements.push({
@@ -15468,7 +15765,7 @@ function collectBranchTextEffects(node) {
 }
 function collectBranchLoops(node, ctx, siblingOffsets) {
   const loops = [];
-  const restNames = ctx ? buildRestSpreadNames(ctx) : undefined;
+  const restNames = ctx ? resolveRestSpreadNames(ctx) : undefined;
   walkIR(node, null, {
     ...stopAt("conditional", "ifStatement"),
     element: ({ node: el, scope: parentSlotId, descend }) => {
@@ -15536,7 +15833,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
   return loops;
 }
 function buildConditionalMetadata(node, ctx, siblingOffsets) {
-  const restNames = buildRestSpreadNames(ctx);
+  const restNames = resolveRestSpreadNames(ctx);
   return {
     slotId: node.slotId,
     condition: node.condition,
@@ -16086,6 +16383,9 @@ function propHasPropertyAccess(u) {
   return u.accessKinds.has("property") || u.accessKinds.has("index");
 }
 
+// src/ir-to-client-js/imports.ts
+import ts16 from "typescript";
+
 // src/value-references.ts
 import ts15 from "typescript";
 function isValueReferenceIdentifier(id) {
@@ -16192,6 +16492,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeTextOrNode",
   "bfMarkup",
   "escapeTextOrMarkup",
+  "markupOrEmpty",
   "qsa",
   "qsaItem",
   "qsaChildScope",
@@ -16258,6 +16559,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 = [];
@@ -16273,23 +16647,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;
@@ -16319,7 +16701,7 @@ function collectComponentNames(node) {
 }
 
 // src/relocate.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // src/lowering-registry.ts
 var plugins = [];
@@ -16365,19 +16747,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;
@@ -16481,11 +16863,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;
@@ -16494,11 +16876,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;
@@ -16546,12 +16928,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;
   }
@@ -16568,8 +16950,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) {
@@ -16582,7 +16964,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16592,13 +16974,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;
@@ -16608,25 +16990,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;
@@ -17198,12 +17580,9 @@ function emitRegistrationAndHydration(lines, ctx, _ir, graph, inlinability) {
   lines.push("");
   const propNamesForStaticCheck = new Set(ctx.propsParams.map((p) => p.name));
   const { inlinableConstants, unsafeLocalNames } = inlinability ?? buildInlinableConstants(ctx, graph, _ir.root);
-  const restSpreadNames = new Set;
-  if (ctx.restPropsName)
-    restSpreadNames.add(ctx.restPropsName);
-  if (ctx.propsObjectName)
-    restSpreadNames.add(ctx.propsObjectName);
-  const isCommentScope = _ir.root.type === "fragment" && _ir.root.needsScopeComment || _ir.root.type === "component";
+  const restSpreadNames = resolveRestSpreadNames(ctx);
+  const isFragmentRoot = _ir.root.type === "fragment" && !!_ir.root.needsScopeComment;
+  const isCommentScope = isFragmentRoot || _ir.root.type === "component";
   const defParts = [`init: init${name}`];
   if (canGenerateStaticTemplate(_ir.root, propNamesForStaticCheck, inlinableConstants, unsafeLocalNames)) {
     const markupSlotIds = new Set(ctx.dynamicElements.map((e) => e.slotId));
@@ -17221,6 +17600,9 @@ function emitRegistrationAndHydration(lines, ctx, _ir, graph, inlinability) {
   if (isCommentScope) {
     defParts.push("comment: true");
   }
+  if (isFragmentRoot) {
+    defParts.push("fragmentRoot: true");
+  }
   const registryKey = nameForRegistryRef(name);
   if (registryKey !== name) {
     defParts.push(`name: '${name}'`);
@@ -17937,23 +18319,23 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 }
 
 // src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function propExtractionName(stmt) {
-  if (!ts17.isVariableStatement(stmt))
+  if (!ts18.isVariableStatement(stmt))
     return null;
   const decls = stmt.declarationList.declarations;
   if (decls.length !== 1)
     return null;
   const decl = decls[0];
-  if (!ts17.isIdentifier(decl.name) || !decl.initializer)
+  if (!ts18.isIdentifier(decl.name) || !decl.initializer)
     return null;
   let core = decl.initializer;
-  if (ts17.isBinaryExpression(core) && core.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken) {
+  if (ts18.isBinaryExpression(core) && core.operatorToken.kind === ts18.SyntaxKind.QuestionQuestionToken) {
     core = core.left;
   }
-  if (!ts17.isPropertyAccessExpression(core))
+  if (!ts18.isPropertyAccessExpression(core))
     return null;
-  if (!ts17.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
+  if (!ts18.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
     return null;
   if (core.name.text !== decl.name.text)
     return null;
@@ -17966,10 +18348,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);
@@ -19430,7 +19812,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -19450,12 +19832,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) {
@@ -19484,12 +19866,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);
   }
@@ -19499,56 +19881,56 @@ function findImpureNode(root, primableNames) {
   const visit3 = (node) => {
     if (found)
       return;
-    if (ts18.isCallExpression(node)) {
+    if (ts19.isCallExpression(node)) {
       const callee = node.expression;
-      const isSignalRead = ts18.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
+      const isSignalRead = ts19.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
       if (!isSignalRead) {
         found = `call to ${callee.getText(callee.getSourceFile())}`;
         return;
       }
     }
-    if (ts18.isNewExpression(node)) {
+    if (ts19.isNewExpression(node)) {
       found = "new expression";
       return;
     }
-    if (ts18.isTaggedTemplateExpression(node)) {
+    if (ts19.isTaggedTemplateExpression(node)) {
       found = "tagged template";
       return;
     }
-    if (ts18.isAwaitExpression(node)) {
+    if (ts19.isAwaitExpression(node)) {
       found = "await";
       return;
     }
-    if (ts18.isYieldExpression(node)) {
+    if (ts19.isYieldExpression(node)) {
       found = "yield";
       return;
     }
-    if (ts18.isPrefixUnaryExpression(node) || ts18.isPostfixUnaryExpression(node)) {
+    if (ts19.isPrefixUnaryExpression(node) || ts19.isPostfixUnaryExpression(node)) {
       const op = node.operator;
-      if (op === ts18.SyntaxKind.PlusPlusToken || op === ts18.SyntaxKind.MinusMinusToken) {
+      if (op === ts19.SyntaxKind.PlusPlusToken || op === ts19.SyntaxKind.MinusMinusToken) {
         found = "increment/decrement";
         return;
       }
     }
-    if (ts18.isDeleteExpression(node)) {
+    if (ts19.isDeleteExpression(node)) {
       found = "delete";
       return;
     }
-    if (ts18.isFunctionExpression(node) || ts18.isArrowFunction(node) || ts18.isClassExpression(node)) {
+    if (ts19.isFunctionExpression(node) || ts19.isArrowFunction(node) || ts19.isClassExpression(node)) {
       found = "function or class expression";
       return;
     }
-    if (ts18.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
+    if (ts19.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
       found = "assignment";
       return;
     }
-    ts18.forEachChild(node, visit3);
+    ts19.forEachChild(node, visit3);
   };
   visit3(root);
   return found;
 }
 function isAssignmentOperator2(kind) {
-  return kind >= ts18.SyntaxKind.FirstAssignment && kind <= ts18.SyntaxKind.LastAssignment;
+  return kind >= ts19.SyntaxKind.FirstAssignment && kind <= ts19.SyntaxKind.LastAssignment;
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -20078,7 +20460,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -20190,20 +20572,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)
@@ -20239,20 +20621,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)
@@ -20514,7 +20896,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) {
@@ -21363,7 +21745,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;
@@ -22273,20 +22655,28 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts20 from "typescript";
-function rewritePropsObjectRef(code, propsObjectName) {
-  const srcPropsName = propsObjectName ?? "props";
-  if (srcPropsName === PROPS_PARAM)
-    return code;
+import ts21 from "typescript";
+function rewritePropsObjectRef(code, propsObjectName, restPropsName = null) {
+  let result = code;
+  const seen = new Set;
+  for (const srcPropsName of [propsObjectName ?? "props", restPropsName]) {
+    if (srcPropsName === null || srcPropsName === PROPS_PARAM || seen.has(srcPropsName))
+      continue;
+    seen.add(srcPropsName);
+    result = rewriteOneName(result, srcPropsName);
+  }
+  return result;
+}
+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)
@@ -22302,17 +22692,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;
 }
@@ -22346,7 +22736,7 @@ function generateInitFunction(ir, ctx, siblingComponents, localImportPrefixes) {
   runPhases(lines, phaseCtx, PHASES);
   const hydrateLine = emitRegistrationAndHydration(lines, ctx, ir, graph, inlinability);
   let generatedCode = rewritePropsObjectRef(lines.join(`
-`), ctx.propsObjectName);
+`), ctx.propsObjectName, ctx.restPropsName);
   generatedCode += `
 ` + hydrateLine;
   const moduleConstantsCode = emitModuleLevelDeclarations(classification.moduleLevelConstants, classification.moduleLevelFunctions, classification.moduleLevelSignals, classification.moduleLevelMemos);
@@ -22624,7 +23014,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);
 }
@@ -22646,11 +23036,7 @@ function generateTemplateOnlyMount(ir, ctx) {
   const propNamesForStaticCheck = new Set(ctx.propsParams.map((p) => p.name));
   const graph = buildReferencesGraph(ctx, ir.root);
   const { inlinableConstants, unsafeLocalNames } = buildInlinableConstants(ctx, graph, ir.root);
-  const restSpreadNames = new Set;
-  if (ctx.restPropsName)
-    restSpreadNames.add(ctx.restPropsName);
-  if (ctx.propsObjectName)
-    restSpreadNames.add(ctx.propsObjectName);
+  const restSpreadNames = resolveRestSpreadNames(ctx);
   let templateHtml;
   if (canGenerateStaticTemplate(ir.root, propNamesForStaticCheck, inlinableConstants, unsafeLocalNames)) {
     const markupSlotIds = new Set(ctx.dynamicElements.map((e) => e.slotId));
@@ -22966,7 +23352,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -22988,8 +23374,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 };
   }
@@ -23011,22 +23397,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;
@@ -23063,7 +23449,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 };
   }
@@ -23086,11 +23472,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);
 }
@@ -23099,24 +23485,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;
@@ -23126,13 +23512,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);
     });
   }
@@ -23159,48 +23545,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;
       }
@@ -23209,43 +23595,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;
@@ -23268,29 +23654,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;
@@ -23298,7 +23684,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);
@@ -23308,7 +23694,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function deriveStashFromDefaults(defaults, props) {
   const extra = {};
   for (const [name, d] of Object.entries(defaults)) {
@@ -23431,11 +23817,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);
 }
@@ -23473,23 +23859,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;
       }
@@ -23500,45 +23886,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)
@@ -23547,29 +23933,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;
@@ -23581,10 +23967,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)
@@ -23593,7 +23979,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;
@@ -23607,7 +23993,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;
@@ -23620,13 +24006,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;
@@ -23643,7 +24029,7 @@ function evalNode(node, ctx) {
       }
       return UNRESOLVED;
     }
-    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts23.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -23659,27 +24045,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;
@@ -23692,30 +24078,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;
@@ -23727,13 +24113,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts22.isNoSubstitutionTemplateLiteral(node))
+  if (ts23.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -23765,47 +24151,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return null;
-  if (!ts23.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts24.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts23.isIdentifier(arg) ? arg.text : null;
+  return ts24.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
+  if (ts24.isStringLiteral(arg) || ts24.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts23.isNumericLiteral(arg))
+  if (ts24.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts23.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts24.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts23.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts24.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts23.isCallExpression(expr))
+  if (!expr || !ts24.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts23.isObjectLiteralExpression(expr.arguments[0]);
+  return ts24.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts23.createSourceFile("__ctx.ts", `(${source})`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__ctx.ts", `(${source})`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isExpressionStatement(stmt))
+  if (!stmt || !ts24.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts23.isParenthesizedExpression(e))
+  while (ts24.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -23830,25 +24216,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts23.createSourceFile("__aug.ts", `(${s})`, ts23.ScriptTarget.Latest, false);
+    const sf = ts24.createSourceFile("__aug.ts", `(${s})`, ts24.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts23.isBinaryExpression(n) && (n.operatorToken.kind === ts23.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts23.SyntaxKind.BarBarToken)) {
+      if (ts24.isBinaryExpression(n) && (n.operatorToken.kind === ts24.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts24.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts23.isParenthesizedExpression(left))
+        while (ts24.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts23.isPropertyAccessExpression(left) && ts23.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts24.isPropertyAccessExpression(left) && ts24.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts23.isParenthesizedExpression(right))
+          while (ts24.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts23.isPrefixUnaryExpression(right))
+          if (ts24.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts23.isNumericLiteral(right) ? "number" : right.kind === ts23.SyntaxKind.TrueKeyword || right.kind === ts23.SyntaxKind.FalseKeyword ? "boolean" : ts23.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts24.isNumericLiteral(right) ? "number" : right.kind === ts24.SyntaxKind.TrueKeyword || right.kind === ts24.SyntaxKind.FalseKeyword ? "boolean" : ts24.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts23.forEachChild(n, visit3);
+      ts24.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -23959,33 +24345,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__const.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts23.isParenthesizedExpression(init))
+  while (init && ts24.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts23.isStringLiteral(init) || ts23.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts24.isStringLiteral(init) || ts24.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__const.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts23.isParenthesizedExpression(init))
+  while (init && ts24.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts23.isTemplateExpression(init))
+  if (!init || !ts24.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts23.isIdentifier(span.expression))
+    if (!ts24.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -24018,30 +24404,30 @@ function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
+  const sf = ts24.createSourceFile("__rec.ts", `(${constInfo.value})`, ts24.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts23.isExpressionStatement(stmt))
+  if (!ts24.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts23.isParenthesizedExpression(parsed))
+  while (ts24.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts23.isObjectLiteralExpression(parsed))
+  if (!ts24.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts23.isPropertyAssignment(prop))
+    if (!ts24.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts23.isIdentifier(name) || ts23.isStringLiteral(name) || ts23.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts24.isIdentifier(name) || ts24.isStringLiteral(name) || ts24.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts23.isParenthesizedExpression(v))
+    while (ts24.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts23.isNumericLiteral(v))
+    if (ts24.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts24.isStringLiteral(v) || ts24.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -24049,28 +24435,28 @@ function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts23.createSourceFile("__join.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
+  const sf = ts24.createSourceFile("__join.ts", `const __x = (${source});`, ts24.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts23.isVariableStatement(stmt))
+  if (!stmt || !ts24.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts23.isParenthesizedExpression(node))
+  while (node && ts24.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts23.isCallExpression(node))
+  if (!node || !ts24.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts23.isPropertyAccessExpression(callee))
+  if (!ts24.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts23.isParenthesizedExpression(recv))
+  while (ts24.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts23.isArrayLiteralExpression(recv))
+  if (!ts24.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts23.isStringLiteral(el) || ts23.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts24.isStringLiteral(el) || ts24.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -24079,7 +24465,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
+    if (ts24.isStringLiteral(arg) || ts24.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -24087,11 +24473,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts23.isElementAccessExpression(val))
+  if (!ts24.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts23.isIdentifier(obj) || !ts23.isIdentifier(arg))
+  if (!ts24.isIdentifier(obj) || !ts24.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -24107,35 +24493,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
+  const sf = ts24.createSourceFile("__rec.ts", `(${constInfo.value})`, ts24.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts23.isExpressionStatement(stmt))
+  if (!ts24.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts23.isParenthesizedExpression(parsed))
+  while (ts24.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts23.isObjectLiteralExpression(parsed))
+  if (!ts24.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts23.isPropertyAssignment(prop))
+    if (!ts24.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts23.isIdentifier(prop.name)) {
+    if (ts24.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts23.isStringLiteral(prop.name) || ts23.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts24.isStringLiteral(prop.name) || ts24.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts23.isParenthesizedExpression(v))
+    while (ts24.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts23.isNumericLiteral(v)) {
+    if (ts24.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts24.isStringLiteral(v) || ts24.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -24496,31 +24882,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);
@@ -24562,13 +24971,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);
           }
         }
@@ -24627,7 +25036,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))
@@ -24716,32 +25125,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"
       });
     }
@@ -24812,53 +25198,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"
     });
   }
@@ -24931,10 +25273,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(`
 `);
@@ -25070,7 +25426,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -25091,10 +25447,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,
@@ -25104,7 +25460,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts25.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts26.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -25388,7 +25744,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // src/adapters/template-imports.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -25438,18 +25794,18 @@ function specKey(s) {
 function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
   if (!sourceText.includes("import"))
     return sourceText;
-  const sf = ts26.createSourceFile("bf-template-fragment.tsx", sourceText, ts26.ScriptTarget.Latest, false, ts26.ScriptKind.TSX);
+  const sf = ts27.createSourceFile("bf-template-fragment.tsx", sourceText, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.TSX);
   const edits = [];
   const visit3 = (node) => {
-    if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts26.isStringLiteralLike(node.arguments[0])) {
+    if (ts27.isCallExpression(node) && node.expression.kind === ts27.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts27.isStringLiteralLike(node.arguments[0])) {
       collect(node.arguments[0]);
     }
-    if (ts26.isImportTypeNode(node) && ts26.isLiteralTypeNode(node.argument)) {
+    if (ts27.isImportTypeNode(node) && ts27.isLiteralTypeNode(node.argument)) {
       const literal = node.argument.literal;
-      if (ts26.isStringLiteralLike(literal))
+      if (ts27.isStringLiteralLike(literal))
         collect(literal);
     }
-    ts26.forEachChild(node, visit3);
+    ts27.forEachChild(node, visit3);
   };
   const collect = (literal) => {
     const specifier = literal.text;
@@ -25464,7 +25820,7 @@ function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
       text: `'${next}'`
     });
   };
-  ts26.forEachChild(sf, visit3);
+  ts27.forEachChild(sf, visit3);
   if (edits.length === 0)
     return sourceText;
   let out = sourceText;
@@ -26229,7 +26585,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts27 from "typescript";
+import ts28 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -26286,10 +26642,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts27.createSourceFile("combine.js", content, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.JS);
+  const sourceFile = ts28.createSourceFile("combine.js", content, ts28.ScriptTarget.Latest, false, ts28.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts27.isImportDeclaration(stmt))
+    if (!ts28.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -26299,8 +26655,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts27.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts27.isNamedImports(bindings)) {
+    const specifier = ts28.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts28.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -26467,7 +26823,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts28 from "typescript";
+import ts29 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -27755,7 +28111,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts28.createSourceFile("__attr.tsx", `(${expr})`, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
+    sf = ts29.createSourceFile("__attr.tsx", `(${expr})`, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -27763,11 +28119,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts28.isPropertyAccessExpression(n) && ts28.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts29.isPropertyAccessExpression(n) && ts29.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts28.forEachChild(n, visit3);
+    ts29.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -27837,7 +28193,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts29 from "typescript";
+import ts30 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -28107,15 +28463,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts29.createSourceFile(filePath, source, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
+  const sf = ts30.createSourceFile(filePath, source, ts30.ScriptTarget.Latest, true, ts30.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts30.isCallExpression(node) && ts30.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts29.forEachChild(node, visit3);
+    ts30.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -28423,13 +28779,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts29.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts29.ScriptTarget.Latest, true);
+    sf = ts30.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts30.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression)) {
+    if (ts30.isCallExpression(node) && ts30.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -28438,7 +28794,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts29.forEachChild(node, visit3);
+    ts30.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -29082,6 +29438,7 @@ export {
   sortComparatorFromArrow,
   serializeParsedExpr,
   searchParamsLocalNames,
+  scanComponentFile,
   rewriteImportsForTemplate,
   rewriteDynamicImportsInSource,
   resolveStaticLoopSource,
@@ -29226,6 +29583,9 @@ export {
   __resetLoweringPluginsForTest,
   TestAdapter,
   SourceMapGenerator,
+  SORT_KEY_TYPES,
+  SORT_KEY_TARGETS,
+  SORT_KEY_DIRECTIONS,
   REACTIVE_PRIMITIVES,
   PROFILE_SCHEMA_VERSION,
   PARSED_EXPR_KINDS,