npm - @barefootjs/vite - Versions diffs - 0.34.0 → 0.35.1 - Mend

@barefootjs/vite 0.34.0 → 0.35.1

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

Files changed (2) hide show

package/dist/index.js +1069 -903
package/package.json +6 -6

package/dist/index.js CHANGED Viewed

@@ -6,7 +6,7 @@ import { relative as relative2, resolve as resolve7, sep as sep3 } from "node:pa
 import ts25 from "typescript";
 // ../jsx/src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -2473,12 +2473,22 @@ function renderLoopBindingAccess(b, base) {
   }
   return parent;
 }
-function wrapLoopParamAsAccessor(expr, paramName, bindings) {
+function wrapLoopParamAsAccessor(expr, paramName, bindings, indexParam) {
+  let result;
   if (bindings && bindings.length > 0) {
-    return rewriteLoopBindingRefs(expr, bindings, "__bfItem()");
+    result = rewriteLoopBindingRefs(expr, bindings, "__bfItem()");
+  } else {
+    const re = new RegExp(`${ID_BOUNDARY_BEFORE}${escapeIdentifierForRegex(paramName)}(?!\\s*\\()(?!-)${ID_BOUNDARY_AFTER}`, "gu");
+    result = replaceInExprContexts(expr, re, () => `${paramName}()`);
   }
-  const re = new RegExp(`${ID_BOUNDARY_BEFORE}${escapeIdentifierForRegex(paramName)}(?!\\s*\\()(?!-)${ID_BOUNDARY_AFTER}`, "gu");
-  return replaceInExprContexts(expr, re, () => `${paramName}()`);
+  if (indexParam && indexParam !== paramName) {
+    result = wrapIndexParamAsAccessor(result, indexParam);
+  }
+  return result;
+}
+function wrapIndexParamAsAccessor(expr, indexParam) {
+  const re = new RegExp(`${ID_BOUNDARY_BEFORE}${escapeIdentifierForRegex(indexParam)}(?!\\s*\\()(?!-)${ID_BOUNDARY_AFTER}`, "gu");
+  return replaceInExprContexts(expr, re, () => `${indexParam}()`);
 }
 function rewriteLoopBindingRefs(expr, bindings, accessor) {
   const byName = new Map;
@@ -2525,7 +2535,7 @@ function wrapExprWithLoopParams(expr, loopParams) {
   let result = expr;
   for (const p of loopParams) {
     const spec = typeof p === "string" ? { param: p } : p;
-    result = wrapLoopParamAsAccessor(result, spec.param, spec.bindings);
+    result = wrapLoopParamAsAccessor(result, spec.param, spec.bindings, spec.index);
   }
   return result;
 }
@@ -2808,6 +2818,20 @@ function buildPropAliasMap(params) {
   }
   return map;
 }
+function resolveBodyDestructuredPropAliases(localConstants, propsObjectName) {
+  const aliases = new Map;
+  if (propsObjectName === null)
+    return aliases;
+  for (const c of localConstants) {
+    if (c.isModule)
+      continue;
+    const m = c.parsed;
+    if (m?.kind === "member" && !m.computed && m.object.kind === "identifier" && m.object.name === propsObjectName) {
+      aliases.set(c.name, m.property);
+    }
+  }
+  return aliases;
+}
 function boundPropLocalNames(b) {
   if (b.propsObjectName !== null)
     return EMPTY_SET;
@@ -3040,6 +3064,18 @@ function resolveGetterAliases(localConstants, isGetter) {
   }
   return aliases;
 }
+function collectAliasableGetterNames(signals, memos) {
+  const getterNames = new Set;
+  for (const sig of signals) {
+    if (sig.getter && !sig.isModule && !sig.envReader)
+      getterNames.add(sig.getter);
+  }
+  for (const memo of memos) {
+    if (!memo.isModule)
+      getterNames.add(memo.name);
+  }
+  return getterNames;
+}
 function buildSignalMemoEnv(signals, memos, propsObjectName, localConstants = []) {
   const substitutions = new Map;
   for (const s of signals) {
@@ -3216,6 +3252,65 @@ class BindingScope {
   }
 }
+// ../jsx/src/ir-to-client-js/safe-html.ts
+function safeHtml(expr) {
+  return expr;
+}
+function interp(span) {
+  return `\${${span}}`;
+}
+function escapedText(expr) {
+  return safeHtml(`escapeText(${expr})`);
+}
+function escapedTextOrMarkup(expr) {
+  return safeHtml(`escapeTextOrMarkup(${expr})`);
+}
+function branchSlotValue(expr, slotsVar) {
+  return safeHtml(`__bfSlot(${expr}, ${slotsVar})`);
+}
+function childrenMarkup(expr) {
+  return safeHtml(`markupOrEmpty(${expr})`);
+}
+function joinedMarkup(expr) {
+  return safeHtml(`Array.isArray(${expr}) ? ${expr}.join('') : (${expr} ?? '')`);
+}
+function renderChildCall(registryName, propsExpr, tailArgs) {
+  return safeHtml(`renderChild('${registryName}', ${propsExpr}${tailArgs})`);
+}
+function dangerousInnerHtml(expr) {
+  return safeHtml(`((${expr}) ?? {}).__html ?? ''`);
+}
+function conditionalMarkup(condition, whenTrue, whenFalse) {
+  return safeHtml(`${condition} ? \`${whenTrue}\` : \`${whenFalse}\``);
+}
+function mappedRowsMarkup(arrayExpr, method, params, body) {
+  return safeHtml(`${arrayExpr}.${method}(${params} => ${body}).join('')`);
+}
+var EMPTY_MARKUP = safeHtml("''");
+function isChildrenPassthroughExpr(expr) {
+  return /^([A-Za-z_$][\w$]*\.)?children$/.test(expr.trim());
+}
+function spliceChildValue(node, valueExpr, cx) {
+  if (node.joinArrayChild)
+    return joinedMarkup(valueExpr);
+  if (cx.branchSlotsVar)
+    return branchSlotValue(valueExpr, cx.branchSlotsVar);
+  if (node.slotId) {
+    return cx.markupSlotIds?.has(node.slotId) ? escapedTextOrMarkup(valueExpr) : escapedText(valueExpr);
+  }
+  const resolved = valueExpr.trim().replace(/^\(+|\)+$/g, "");
+  if (isChildrenPassthroughExpr(node.expr) || isChildrenPassthroughExpr(resolved)) {
+    return childrenMarkup(valueExpr);
+  }
+  return escapedText(valueExpr);
+}
+// ../jsx/src/ir-to-client-js/markup-slots.ts
+var DYNAMIC_ELEMENT_WRITER_KIND = "markup";
+function markupSlotIdsOf(ctx) {
+  return new Set(ctx.dynamicElements.map((e) => e.slotId));
+}
 // ../jsx/src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -3385,22 +3480,11 @@ function templateAttrExpr(attrName, valExpr, presenceOrUndefined) {
 function escapeAttrValueExpr(valExpr) {
   return `escapeAttr(${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")
     return null;
-  return `\${((${toExpr(attr.value)}) ?? {}).__html ?? ''}`;
+  return interp(dangerousInnerHtml(toExpr(attr.value)));
 }
 function transformKeyValue(value, transformExpr) {
   switch (value.kind) {
@@ -3516,7 +3600,7 @@ function buildSpreadAttrsMergeCall(args) {
   return `\${spreadAttrs({${objMembers.join(", ")}})}`;
 }
 function itemAnchorTemplate(keyExpr) {
-  return `<!--${loopItemMarker("${" + keyExpr + "}")}-->`;
+  return `<!--${loopItemMarker("${escapeCommentText(" + keyExpr + ")}")}-->`;
 }
 function renderPreamble(preamble, opts) {
   let out = "";
@@ -3525,9 +3609,9 @@ function renderPreamble(preamble, opts) {
       const text = opts.textVariant === "template" ? seg.templateText ?? seg.text : seg.text;
       out += opts.transformJs ? opts.transformJs(text) : text;
     } else if (opts.rawLeaf) {
-      out += opts.renderLeaf(escapeLeafTextExpressions(seg.ir));
+      out += opts.renderLeaf(seg.ir);
     } else {
-      out += "`" + opts.renderLeaf(escapeLeafTextExpressions(seg.ir)) + "`";
+      out += "`" + opts.renderLeaf(seg.ir) + "`";
     }
   }
   return out;
@@ -3572,36 +3656,12 @@ function renderFlatMapProjectionClientBody(inner, restSpreadNames) {
   const chained = applyLoopChain(inner);
   const params = inner.index ? `(${inner.param}, ${inner.index})` : `(${inner.param})`;
   const key = inner.key ? `(${inner.key})` : "undefined";
-  const html = inner.children.map((c) => irToHtmlTemplate(escapeLeafTextExpressions(c), restSpreadNames, 1, undefined, undefined)).join("");
+  const html = inner.children.map((c) => irToHtmlTemplate(c, restSpreadNames, 1, undefined, undefined)).join("");
   return `${chained}.map(${params} => ({ k: ${key}, h: \`${html}\` }))`;
 }
-function escapeLeafTextExpressions(ir) {
-  switch (ir.type) {
-    case "element":
-      return { ...ir, children: ir.children.map(escapeLeafTextExpressions) };
-    case "fragment":
-      return { ...ir, children: ir.children.map(escapeLeafTextExpressions) };
-    case "expression": {
-      if (ir.expr === "null" || ir.expr === "undefined")
-        return ir;
-      if (ir.slotId || ir.expr.trimStart().startsWith("escapeText("))
-        return ir;
-      return { ...ir, expr: `escapeText((${ir.expr}))`, templateExpr: ir.templateExpr ? `escapeText((${ir.templateExpr}))` : ir.templateExpr };
-    }
-    case "conditional":
-      return {
-        ...ir,
-        whenTrue: escapeLeafTextExpressions(ir.whenTrue),
-        whenFalse: ir.whenFalse ? escapeLeafTextExpressions(ir.whenFalse) : ir.whenFalse
-      };
-    default:
-      return ir;
-  }
-}
 function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, branchSlotsVar, inHoistedChildren = false) {
   const recurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, inHoistedChildren);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
-  const wrapInterpolation = (expr) => branchSlotsVar ? `__bfSlot(${expr}, ${branchSlotsVar})` : expr;
   switch (node.type) {
     case "element": {
       const mergeCtx = {
@@ -3647,25 +3707,17 @@ 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 = escapeForClient(wrapInterpolation(wrapExpr(node.expr)));
-        return `\${${bare}}`;
-      }
-      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 `\${${bareSpliceExpr(node, valueExpr)}}`;
+      const hole = interp(spliceChildValue(node, wrapExpr(node.expr), { branchSlotsVar }));
+      if (node.markerless)
+        return hole;
+      return node.slotId ? `<!--bf:${node.slotId}-->${hole}<!--/-->` : hole;
     }
     case "conditional": {
       const trueBranch = recurse(node.whenTrue);
       const falseBranch = recurse(node.whenFalse);
       const trueHtml = node.slotId ? addCondAttrToTemplate(trueBranch, node.slotId) : trueBranch;
       const falseHtml = node.slotId ? addCondAttrToTemplate(falseBranch, node.slotId) : falseBranch;
-      return `\${${wrapExpr(node.condition)} ? \`${trueHtml}\` : \`${falseHtml}\`}`;
+      return interp(conditionalMarkup(wrapExpr(node.condition), trueHtml, falseHtml));
     }
     case "fragment":
       return node.children.map(recurse).join("");
@@ -3691,7 +3743,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
           case "expression":
           case "template":
           case "spread": {
-            const expr = attrValueToString(p.value, { useTemplate: true }) ?? "undefined";
+            const expr = wrapExpr(attrValueToString(p.value, { useTemplate: true }) ?? "undefined");
             return `${quotePropName(p.name)}: ${expr}`;
           }
         }
@@ -3702,7 +3754,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${attrValueToString(keyProp.value) ?? "undefined"}` : "";
-      return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${renderChildScopeArgs(node, keyArg)})}`;
+      return interp(renderChildCall(nameForRegistryRef(node.name), propsExpr, renderChildScopeArgs(node, keyArg)));
     }
     case "loop": {
       const innerRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar);
@@ -3720,12 +3772,12 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
         const body = renderPreamble(node.flatMapCallback, {
           renderLeaf: (ir) => irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar)
         });
-        mapExpr = `\${${wrappedArray}.flatMap(${node.flatMapCallback.params} => ${body}).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, "flatMap", node.flatMapCallback.params, body));
       } else if (node.preamble) {
         const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToHtmlTemplate(ir, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar) });
-        mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => { ${preamble} return \`${childTemplate}\` }).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, iterMethod, callbackParam, `{ ${preamble} return \`${childTemplate}\` }`));
       } else {
-        mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => \`${childTemplate}\`).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, iterMethod, callbackParam, `\`${childTemplate}\``));
       }
       return `<!--${loopStartMarker(node.markerId)}-->${mapExpr}<!--${loopEndMarker(node.markerId)}-->`;
     }
@@ -3984,20 +4036,15 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
     case "expression": {
       if (node.expr === "null" || node.expr === "undefined")
         return "";
-      const wrapped = wrapExpr(node.expr);
-      const value = node.joinArrayChild ? `Array.isArray(${wrapped}) ? ${wrapped}.join('') : (${wrapped} ?? '')` : wrapped;
-      if (node.slotId) {
-        return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(wrapped)}}<!--/-->`;
-      }
-      const spliced = bareSpliceExpr(node, value);
-      return `\${${node.escapeInClientTemplate ? `escapeText(${spliced})` : spliced}}`;
+      const hole = interp(spliceChildValue(node, wrapExpr(node.expr), {}));
+      return node.slotId ? `<!--bf:${node.slotId}-->${hole}<!--/-->` : hole;
     }
     case "conditional": {
       const trueBranch = recurse(node.whenTrue);
       const falseBranch = recurse(node.whenFalse);
       const trueHtml = node.slotId ? addCondAttrToTemplate(trueBranch, node.slotId) : trueBranch;
       const falseHtml = node.slotId ? addCondAttrToTemplate(falseBranch, node.slotId) : falseBranch;
-      return `\${${wrapExpr(node.condition)} ? \`${trueHtml}\` : \`${falseHtml}\`}`;
+      return interp(conditionalMarkup(wrapExpr(node.condition), trueHtml, falseHtml));
     }
     case "fragment":
       return node.children.map(recurse).join("");
@@ -4021,12 +4068,12 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
         const body = renderPreamble(node.flatMapCallback, {
           renderLeaf: (ir) => irToPlaceholderTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams)
         });
-        mapExpr = `\${${wrappedArray}.flatMap(${node.flatMapCallback.params} => ${body}).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, "flatMap", node.flatMapCallback.params, body));
       } else if (node.preamble) {
         const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToPlaceholderTemplate(ir, restSpreadNames, loopDepth + 1, loopParams) });
-        mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => { ${preamble} return \`${childTemplate}\` }).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, iterMethod, callbackParam, `{ ${preamble} return \`${childTemplate}\` }`));
       } else {
-        mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => \`${childTemplate}\`).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(wrappedArray, iterMethod, callbackParam, `\`${childTemplate}\``));
       }
       return `<!--${loopStartMarker(node.markerId)}-->${mapExpr}<!--${loopEndMarker(node.markerId)}-->`;
     }
@@ -4228,13 +4275,8 @@ function irToComponentTemplateWithOpts(node, opts) {
           return "";
         return `<!--bf:${node.slotId}--><!--/-->`;
       }
-      const wrapped = transformExpr(node.expr, node.templateExpr);
-      const value = node.joinArrayChild ? `Array.isArray(${wrapped}) ? ${wrapped}.join('') : (${wrapped} ?? '')` : wrapped;
-      if (node.slotId) {
-        const isMarkup = opts.markupSlotIds?.has(node.slotId) ?? false;
-        return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(wrapped, isMarkup)}}<!--/-->`;
-      }
-      return `\${${bareSpliceExpr(node, value)}}`;
+      const hole = interp(spliceChildValue(node, transformExpr(node.expr, node.templateExpr), { markupSlotIds: opts.markupSlotIds }));
+      return node.slotId ? `<!--bf:${node.slotId}-->${hole}<!--/-->` : hole;
     }
     case "conditional": {
       if (node.clientOnly && node.slotId) {
@@ -4244,7 +4286,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       const falseBranch = recurse(node.whenFalse);
       const trueHtml = node.slotId ? addCondAttrToTemplate(trueBranch, node.slotId) : trueBranch;
       const falseHtml = node.slotId ? addCondAttrToTemplate(falseBranch, node.slotId) : falseBranch;
-      return `\${${transformExpr(node.condition, node.templateCondition)} ? \`${trueHtml}\` : \`${falseHtml}\`}`;
+      return interp(conditionalMarkup(transformExpr(node.condition, node.templateCondition), trueHtml, falseHtml));
     }
     case "fragment":
       return node.children.map(recurse).join("");
@@ -4282,7 +4324,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${transformKeyValue(keyProp.value, transformExpr)}` : "";
-      return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg})}`;
+      return interp(renderChildCall(nameForRegistryRef(node.name), propsExpr, keyArg));
     }
     case "loop": {
       const innerOpts = { ...opts, loopDepth: loopDepth + 1 };
@@ -4292,7 +4334,7 @@ function irToComponentTemplateWithOpts(node, opts) {
     case "if-statement": {
       const consequent = recurse(node.consequent);
       const alternate = node.alternate ? recurse(node.alternate) : "";
-      return `\${${transformExpr(node.condition, node.templateCondition)} ? \`${consequent}\` : \`${alternate}\`}`;
+      return interp(conditionalMarkup(transformExpr(node.condition, node.templateCondition), consequent, alternate));
     }
     case "provider":
     case "async":
@@ -4380,7 +4422,7 @@ function generateCsrTemplate(node, inlinableConstants, ctx, restSpreadNames, pro
     }
   }
   const effectiveUnsafeLocalNames = mergeCsrNullUnsafe(ctx, unsafeLocalNames);
-  const markupSlotIds = new Set(ctx.dynamicElements.map((e) => e.slotId));
+  const markupSlotIds = markupSlotIdsOf(ctx);
   return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1, markupSlotIds, restPropsName: ctx.restPropsName });
 }
 function mergeCsrNullUnsafe(ctx, unsafeLocalNames) {
@@ -4579,13 +4621,8 @@ function generateCsrTemplateWithOpts(node, opts) {
       }
       {
         const transformed = transformExpr(node.expr, node.templateExpr);
-        const expr = transformed === UNSAFE_TEMPLATE_EXPR ? "''" : transformed;
-        const value = node.joinArrayChild ? `Array.isArray(${expr}) ? ${expr}.join('') : (${expr} ?? '')` : expr;
-        if (node.slotId) {
-          const isMarkup = opts.markupSlotIds?.has(node.slotId) ?? false;
-          return `<!--bf:${node.slotId}-->\${${node.joinArrayChild ? value : escapeTextSlotExpr(expr, isMarkup)}}<!--/-->`;
-        }
-        return `\${${bareSpliceExpr(node, value)}}`;
+        const hole = interp(transformed === UNSAFE_TEMPLATE_EXPR ? EMPTY_MARKUP : spliceChildValue(node, transformed, { markupSlotIds: opts.markupSlotIds }));
+        return node.slotId ? `<!--bf:${node.slotId}-->${hole}<!--/-->` : hole;
       }
     case "conditional": {
       if (node.clientOnly && node.slotId) {
@@ -4595,7 +4632,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       const falseBranch = recurse(node.whenFalse);
       const trueHtml = node.slotId ? addCondAttrToTemplate(trueBranch, node.slotId) : trueBranch;
       const falseHtml = node.slotId ? addCondAttrToTemplate(falseBranch, node.slotId) : falseBranch;
-      return `\${${transformExpr(node.condition, node.templateCondition)} ? \`${trueHtml}\` : \`${falseHtml}\`}`;
+      return interp(conditionalMarkup(transformExpr(node.condition, node.templateCondition), trueHtml, falseHtml));
     }
     case "fragment":
       return node.children.map(recurse).join("");
@@ -4644,7 +4681,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${transformKeyValue(keyProp.value, transformExpr)}` : "";
-      return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${renderChildScopeArgs(node, keyArg)})}`;
+      return interp(renderChildCall(nameForRegistryRef(node.name), propsExpr, renderChildScopeArgs(node, keyArg)));
     }
     case "loop": {
       const childScope = (opts.scope ?? BindingScope.EMPTY).enterLoopRow(node);
@@ -4677,19 +4714,19 @@ function generateCsrTemplateWithOpts(node, opts) {
           transformJs: (t) => rewritePropsObjectRef(t, propsObjectName ?? null, restPropsName ?? null, { enclosingScope: childScope }),
           renderLeaf: (ir) => recurseInLoopBody(stripLeafKeyAttr(ir))
         });
-        mapExpr = `\${${iterArrayExpr}.flatMap(${node.flatMapCallback.params} => ${body}).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(iterArrayExpr, "flatMap", node.flatMapCallback.params, body));
       } else if (node.preamble) {
         const preamble = renderPreamble(node.preamble, { textVariant: "template", transformJs: (t) => rewritePropsObjectRef(t, propsObjectName ?? null, restPropsName ?? null, { enclosingScope: childScope }), renderLeaf: (ir) => recurseInLoopBody(ir) });
-        mapExpr = `\${${iterArrayExpr}.${iterMethod}(${callbackParam} => { ${preamble} return \`${childTemplate}\` }).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(iterArrayExpr, iterMethod, callbackParam, `{ ${preamble} return \`${childTemplate}\` }`));
       } else {
-        mapExpr = `\${${iterArrayExpr}.${iterMethod}(${callbackParam} => \`${childTemplate}\`).join('')}`;
+        mapExpr = interp(mappedRowsMarkup(iterArrayExpr, iterMethod, callbackParam, `\`${childTemplate}\``));
       }
       return `<!--${loopStartMarker(node.markerId)}-->${mapExpr}<!--${loopEndMarker(node.markerId)}-->`;
     }
     case "if-statement": {
       const consequent = recurse(node.consequent);
       const alternate = node.alternate ? recurse(node.alternate) : "";
-      return `\${${transformExpr(node.condition, node.templateCondition)} ? \`${consequent}\` : \`${alternate}\`}`;
+      return interp(conditionalMarkup(transformExpr(node.condition, node.templateCondition), consequent, alternate));
     }
     case "provider":
     case "async":
@@ -4790,8 +4827,6 @@ function collectAstPropRefs(node, propNames, out) {
   walkWithScope(node, (n, parent, shadowed) => {
     if (shadowed || !propNames.has(n.text))
       return;
-    if (parent && ts7.isShorthandPropertyAssignment(parent) && parent.name === n)
-      return;
     if (isNonValuePosition(n, parent))
       return;
     out.add(n.text);
@@ -4881,7 +4916,7 @@ function incrementCounter(key) {
 }
 // ../jsx/src/analyzer-context.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 // ../jsx/src/strip-types.ts
 import ts8 from "typescript";
@@ -5098,6 +5133,140 @@ function findAngleBracketAfter(lastTypeArg, fullText) {
   return -1;
 }
+// ../jsx/src/reactivity-checker.ts
+import ts9 from "typescript";
+var REACTIVE_BRAND = "__reactive";
+function queryType(checker, node) {
+  incrementCounter("typeCheckerQueries");
+  return checker.getTypeAtLocation(node);
+}
+function isReactiveType(type) {
+  return type.getProperty(REACTIVE_BRAND) !== undefined;
+}
+var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
+function safeGetText(node) {
+  try {
+    return node.getText();
+  } catch {
+    return "";
+  }
+}
+function analyze(node, checker) {
+  if (ts9.isPropertyAccessExpression(node)) {
+    try {
+      const type = queryType(checker, node);
+      if (isReactiveType(type)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {}
+    const sub = analyze(node.expression, checker);
+    if (sub.isReactive) {
+      return {
+        isReactive: true,
+        reason: {
+          kind: "child",
+          via: "property-access-object",
+          childText: safeGetText(node.expression),
+          childReason: sub.reason
+        }
+      };
+    }
+    return NOT_REACTIVE;
+  }
+  if (ts9.isIdentifier(node)) {
+    try {
+      const type = queryType(checker, node);
+      if (isReactiveType(type)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "identifier", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {}
+    return NOT_REACTIVE;
+  }
+  if (ts9.isCallExpression(node)) {
+    try {
+      const calleeType = queryType(checker, node.expression);
+      if (isReactiveType(calleeType)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "callee", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {}
+  }
+  let foundChild;
+  let foundChildText = "";
+  ts9.forEachChild(node, (child) => {
+    if (foundChild?.isReactive)
+      return;
+    const result = analyze(child, checker);
+    if (result.isReactive) {
+      foundChild = result;
+      foundChildText = safeGetText(child);
+    }
+  });
+  if (foundChild?.isReactive) {
+    return {
+      isReactive: true,
+      reason: {
+        kind: "child",
+        via: "sub-expression",
+        childText: foundChildText,
+        childReason: foundChild.reason
+      }
+    };
+  }
+  return NOT_REACTIVE;
+}
+var brandTypeReactivityAnalyzer = { analyze };
+function containsReactiveExpression(node, checker) {
+  incrementCounter("reactivityChecks");
+  return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive;
+}
+function nodeContainsJsx(node) {
+  if (ts9.isJsxElement(node) || ts9.isJsxSelfClosingElement(node) || ts9.isJsxFragment(node))
+    return true;
+  return ts9.forEachChild(node, nodeContainsJsx) ?? false;
+}
+function collectReactiveBrandLeaves(node, checker) {
+  const leaves = [];
+  const visit = (n) => {
+    if (ts9.isPropertyAccessExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) {
+          leaves.push(n);
+          return;
+        }
+      } catch {}
+      visit(n.expression);
+      return;
+    }
+    if (ts9.isIdentifier(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n)))
+          leaves.push(n);
+      } catch {}
+      return;
+    }
+    if (ts9.isCallExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n.expression))) {
+          leaves.push(nodeContainsJsx(n) ? n.expression : n);
+          return;
+        }
+      } catch {}
+    }
+    ts9.forEachChild(n, visit);
+  };
+  visit(node);
+  return leaves;
+}
 // ../jsx/src/analyzer-context.ts
 function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
   return {
@@ -5149,7 +5318,7 @@ function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
       } catch {
         ownSourceFile = undefined;
       }
-      if (process.env.BF_ASSERT_NO_JSX_IN_GETJS === "1" && this.errors.length === 0 && nodeContainsJsx(node)) {
+      if (process.env.BF_ASSERT_NO_JSX_IN_GETJS === "1" && !this.errors.some((e) => e.severity === "error") && nodeContainsJsx(node)) {
         throw new Error("getJS() called on a JSX-bearing node — raw JSX must never be spliced " + "into emitted output. Carry mixed content as structured segments " + "(MapCallbackPreamble / FlatMapCallback) instead.");
       }
       if (ownSourceFile && ownSourceFile !== sourceFile) {
@@ -5159,11 +5328,6 @@ function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
     }
   };
 }
-function nodeContainsJsx(node) {
-  if (ts9.isJsxElement(node) || ts9.isJsxSelfClosingElement(node) || ts9.isJsxFragment(node))
-    return true;
-  return ts9.forEachChild(node, nodeContainsJsx) ?? false;
-}
 function getSourceLocation(node, sourceFile, filePath) {
   const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
   const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
@@ -5180,20 +5344,20 @@ function getSourceLocation(node, sourceFile, filePath) {
   };
 }
 function membersToProperties(members, sourceFile) {
-  return members.filter(ts9.isPropertySignature).map((member) => ({
+  return members.filter(ts10.isPropertySignature).map((member) => ({
     name: propertyNameText(member.name, sourceFile),
     type: typeNodeToTypeInfo(member.type, sourceFile) ?? {
       kind: "unknown",
       raw: "unknown"
     },
     optional: !!member.questionToken,
-    readonly: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)
+    readonly: !!member.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword)
   }));
 }
 function propertyNameText(name, sourceFile) {
   if (!name)
     return "";
-  if (ts9.isStringLiteral(name) || ts9.isNumericLiteral(name))
+  if (ts10.isStringLiteral(name) || ts10.isNumericLiteral(name))
     return name.text;
   return name.getText(sourceFile);
 }
@@ -5204,56 +5368,56 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   const raw = rawOf ? rawOf(typeNode) : typeNode.getText(sourceFile);
   const recurse = (n) => typeNodeToTypeInfo(n, sourceFile, rawOf) ?? { kind: "unknown", raw: "unknown" };
   switch (typeNode.kind) {
-    case ts9.SyntaxKind.StringKeyword:
+    case ts10.SyntaxKind.StringKeyword:
       return { kind: "primitive", raw, primitive: "string" };
-    case ts9.SyntaxKind.NumberKeyword:
+    case ts10.SyntaxKind.NumberKeyword:
       return { kind: "primitive", raw, primitive: "number" };
-    case ts9.SyntaxKind.BooleanKeyword:
+    case ts10.SyntaxKind.BooleanKeyword:
       return { kind: "primitive", raw, primitive: "boolean" };
-    case ts9.SyntaxKind.NullKeyword:
+    case ts10.SyntaxKind.NullKeyword:
       return { kind: "primitive", raw, primitive: "null" };
-    case ts9.SyntaxKind.UndefinedKeyword:
+    case ts10.SyntaxKind.UndefinedKeyword:
       return { kind: "primitive", raw, primitive: "undefined" };
   }
-  if (ts9.isArrayTypeNode(typeNode)) {
+  if (ts10.isArrayTypeNode(typeNode)) {
     return { kind: "array", raw, elementType: recurse(typeNode.elementType) };
   }
-  if (ts9.isLiteralTypeNode(typeNode)) {
+  if (ts10.isLiteralTypeNode(typeNode)) {
     const lit = typeNode.literal;
-    if (ts9.isStringLiteral(lit) || ts9.isNoSubstitutionTemplateLiteral(lit)) {
+    if (ts10.isStringLiteral(lit) || ts10.isNoSubstitutionTemplateLiteral(lit)) {
       return { kind: "primitive", raw, primitive: "string", literalValue: lit.text };
     }
-    if (ts9.isNumericLiteral(lit)) {
+    if (ts10.isNumericLiteral(lit)) {
       return { kind: "primitive", raw, primitive: "number", literalValue: lit.text };
     }
-    if (ts9.isPrefixUnaryExpression(lit) && lit.operator === ts9.SyntaxKind.MinusToken && ts9.isNumericLiteral(lit.operand)) {
+    if (ts10.isPrefixUnaryExpression(lit) && lit.operator === ts10.SyntaxKind.MinusToken && ts10.isNumericLiteral(lit.operand)) {
       return { kind: "primitive", raw, primitive: "number", literalValue: `-${lit.operand.text}` };
     }
-    if (lit.kind === ts9.SyntaxKind.TrueKeyword || lit.kind === ts9.SyntaxKind.FalseKeyword) {
+    if (lit.kind === ts10.SyntaxKind.TrueKeyword || lit.kind === ts10.SyntaxKind.FalseKeyword) {
       return {
         kind: "primitive",
         raw,
         primitive: "boolean",
-        literalValue: lit.kind === ts9.SyntaxKind.TrueKeyword ? "true" : "false"
+        literalValue: lit.kind === ts10.SyntaxKind.TrueKeyword ? "true" : "false"
       };
     }
-    if (lit.kind === ts9.SyntaxKind.NullKeyword) {
+    if (lit.kind === ts10.SyntaxKind.NullKeyword) {
       return { kind: "primitive", raw, primitive: "null" };
     }
     return { kind: "unknown", raw };
   }
-  if (ts9.isUnionTypeNode(typeNode)) {
+  if (ts10.isUnionTypeNode(typeNode)) {
     return { kind: "union", raw, unionTypes: typeNode.types.map(recurse) };
   }
-  if (ts9.isTypeLiteralNode(typeNode)) {
+  if (ts10.isTypeLiteralNode(typeNode)) {
     return {
       kind: "object",
       raw,
       ...synthetic ? {} : { properties: membersToProperties(typeNode.members, sourceFile) }
     };
   }
-  if (ts9.isTypeReferenceNode(typeNode)) {
-    const refName = ts9.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : "";
+  if (ts10.isTypeReferenceNode(typeNode)) {
+    const refName = ts10.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : "";
     if ((refName === "Array" || refName === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
       return { kind: "array", raw, elementType: recurse(typeNode.typeArguments[0]) };
     }
@@ -5262,7 +5426,7 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
       raw
     };
   }
-  if (ts9.isFunctionTypeNode(typeNode)) {
+  if (ts10.isFunctionTypeNode(typeNode)) {
     if (synthetic)
       return { kind: "function", raw };
     return {
@@ -5282,15 +5446,15 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   }
   return { kind: "unknown", raw };
 }
-var _typePrinter = ts9.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts9.createSourceFile("__bf_types__.ts", "", ts9.ScriptTarget.Latest);
+var _typePrinter = ts10.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts10.createSourceFile("__bf_types__.ts", "", ts10.ScriptTarget.Latest);
 function tsTypeToTypeInfo(type, checker) {
-  const node = checker.typeToTypeNode(type, undefined, ts9.NodeBuilderFlags.NoTruncation);
+  const node = checker.typeToTypeNode(type, undefined, ts10.NodeBuilderFlags.NoTruncation);
   if (!node)
     return null;
   const rawOf = (n) => {
     try {
-      return _typePrinter.printNode(ts9.EmitHint.Unspecified, n, _blankTypeSourceFile);
+      return _typePrinter.printNode(ts10.EmitHint.Unspecified, n, _blankTypeSourceFile);
     } catch {
       return "unknown";
     }
@@ -5301,16 +5465,16 @@ function isPascalCase(name) {
   return /^[A-Z][a-zA-Z0-9]*$/.test(name);
 }
 function isComponentFunction(node) {
-  return ts9.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
+  return ts10.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
 }
 function isArrowComponentFunction(node) {
-  if (!ts9.isVariableDeclaration(node))
+  if (!ts10.isVariableDeclaration(node))
     return false;
-  if (!ts9.isIdentifier(node.name))
+  if (!ts10.isIdentifier(node.name))
     return false;
   if (!isPascalCase(node.name.text))
     return false;
-  if (!node.initializer || !ts9.isArrowFunction(node.initializer))
+  if (!node.initializer || !ts10.isArrowFunction(node.initializer))
     return false;
   return true;
 }
@@ -5637,9 +5801,9 @@ function needsTypeBasedDetection(source) {
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
   for (const stmt of sourceFile.statements) {
-    if (!ts10.isImportDeclaration(stmt))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier))
       continue;
     if (!REACTIVE_BRAND_PACKAGES.includes(stmt.moduleSpecifier.text))
       continue;
@@ -5658,21 +5822,21 @@ function createProgramForFile(source, filePath) {
   try {
     const normalizedPath = path2.resolve(filePath);
     const compilerOptions = {
-      target: ts10.ScriptTarget.Latest,
-      module: ts10.ModuleKind.ESNext,
-      moduleResolution: ts10.ModuleResolutionKind.Bundler,
-      jsx: ts10.JsxEmit.ReactJSX,
+      target: ts11.ScriptTarget.Latest,
+      module: ts11.ModuleKind.ESNext,
+      moduleResolution: ts11.ModuleResolutionKind.Bundler,
+      jsx: ts11.JsxEmit.ReactJSX,
       strict: true,
       skipLibCheck: true,
       noEmit: true,
       baseUrl: path2.dirname(normalizedPath)
     };
-    const defaultHost = ts10.createCompilerHost(compilerOptions);
+    const defaultHost = ts11.createCompilerHost(compilerOptions);
     const virtualHost = {
       ...defaultHost,
       getSourceFile(fileName, languageVersion) {
         if (path2.resolve(fileName) === normalizedPath) {
-          return ts10.createSourceFile(fileName, source, languageVersion, true, ts10.ScriptKind.TSX);
+          return ts11.createSourceFile(fileName, source, languageVersion, true, ts11.ScriptKind.TSX);
         }
         return defaultHost.getSourceFile(fileName, languageVersion);
       },
@@ -5687,7 +5851,7 @@ function createProgramForFile(source, filePath) {
         return defaultHost.readFile(fileName);
       }
     };
-    const program = ts10.createProgram([normalizedPath], compilerOptions, virtualHost);
+    const program = ts11.createProgram([normalizedPath], compilerOptions, virtualHost);
     const sourceFile = program.getSourceFile(normalizedPath);
     if (!sourceFile)
       return null;
@@ -5720,7 +5884,7 @@ function analyzeComponent(source, filePath, targetComponentName, program, accept
     }
   }
   if (!sourceFile) {
-    sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+    sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   }
   if (!checker && needsTypeBasedDetection(source)) {
     const result = createProgramForFile(source, filePath);
@@ -5766,23 +5930,23 @@ function analyzeComponent(source, filePath, targetComponentName, program, accept
 function findDefaultExportedComponent(sourceFile) {
   let defaultExportName;
   function findDefaultExport(node) {
-    if (ts10.isExportAssignment(node) && !node.isExportEquals) {
-      if (ts10.isIdentifier(node.expression)) {
+    if (ts11.isExportAssignment(node) && !node.isExportEquals) {
+      if (ts11.isIdentifier(node.expression)) {
         defaultExportName = node.expression.text;
       }
     }
-    if (ts10.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword)) {
+    if (ts11.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword)) {
       defaultExportName = node.name.text;
     }
-    ts10.forEachChild(node, findDefaultExport);
+    ts11.forEachChild(node, findDefaultExport);
   }
-  ts10.forEachChild(sourceFile, findDefaultExport);
+  ts11.forEachChild(sourceFile, findDefaultExport);
   return defaultExportName;
 }
 function collectNamedExports(sourceFile) {
   const exported = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts10.isExportDeclaration(stmt) && stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+    if (ts11.isExportDeclaration(stmt) && stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
       for (const spec of stmt.exportClause.elements) {
         const local = (spec.propertyName ?? spec.name).text;
         exported.add(local);
@@ -5792,22 +5956,22 @@ function collectNamedExports(sourceFile) {
   return exported;
 }
 function visit(node, ctx, targetComponentName, namedExports) {
-  if (ts10.isExpressionStatement(node) && ts10.isStringLiteral(node.expression)) {
+  if (ts11.isExpressionStatement(node) && ts11.isStringLiteral(node.expression)) {
     if (node.expression.text === "use client" || node.expression.text === "'use client'") {
       ctx.hasUseClientDirective = true;
     }
   }
-  if (ts10.isImportDeclaration(node)) {
+  if (ts11.isImportDeclaration(node)) {
     collectImport(node, ctx);
   }
-  if (ts10.isInterfaceDeclaration(node)) {
+  if (ts11.isInterfaceDeclaration(node)) {
     collectInterfaceDefinition(node, ctx);
   }
-  if (ts10.isTypeAliasDeclaration(node)) {
+  if (ts11.isTypeAliasDeclaration(node)) {
     collectTypeAliasDefinition(node, ctx);
   }
-  if (!ctx.hasUseClientDirective && ts10.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
-    const hasInlineExport = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+  if (!ctx.hasUseClientDirective && ts11.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
+    const hasInlineExport = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
     const hasNamedExport = namedExports?.has(node.name.text) ?? false;
     if (!hasInlineExport && !hasNamedExport) {
       collectFunction(node, ctx, true, false);
@@ -5822,9 +5986,9 @@ function visit(node, ctx, targetComponentName, namedExports) {
       if (!ctx.componentName) {
         ctx.componentName = node.name.text;
         ctx.componentNode = node;
-        ctx.isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+        ctx.isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
         analyzeComponentBody(node, ctx);
-        if (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword)) {
+        if (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword)) {
           ctx.hasDefaultExport = true;
         }
       }
@@ -5838,10 +6002,10 @@ function visit(node, ctx, targetComponentName, namedExports) {
         ctx.componentName = node.name.text;
         ctx.componentNode = node.initializer;
         const parentStatement = node.parent;
-        if (ts10.isVariableDeclarationList(parentStatement)) {
+        if (ts11.isVariableDeclarationList(parentStatement)) {
           const varStatement = parentStatement.parent;
-          if (ts10.isVariableStatement(varStatement)) {
-            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+          if (ts11.isVariableStatement(varStatement)) {
+            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
           }
         }
         analyzeComponentBody(node.initializer, ctx);
@@ -5853,10 +6017,10 @@ function visit(node, ctx, targetComponentName, namedExports) {
   if (!ctx.componentNode) {
     collectAmbientGlobals(node, ctx);
   }
-  const isDeclareStatement = ts10.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false);
-  if (ts10.isVariableStatement(node) && !ctx.componentNode && !isDeclareStatement) {
-    const isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
-    const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+  const isDeclareStatement = ts11.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false);
+  if (ts11.isVariableStatement(node) && !ctx.componentNode && !isDeclareStatement) {
+    const isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
+    const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
     const isModuleClientDirective = hasLeadingClientDirectiveOnStatement(node, ctx.sourceFile);
     for (const decl of node.declarationList.declarations) {
       if (declarationIsReactiveFactoryCall(decl, ctx)) {
@@ -5867,19 +6031,19 @@ function visit(node, ctx, targetComponentName, namedExports) {
         }
         continue;
       }
-      if (ts10.isIdentifier(decl.name) && (decl.initializer || isLet) && !isArrowComponentFunction(decl)) {
+      if (ts11.isIdentifier(decl.name) && (decl.initializer || isLet) && !isArrowComponentFunction(decl)) {
         collectConstant(decl, ctx, true, isLet ? "let" : "const", isExported);
       }
     }
   }
-  if (ts10.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
-    const isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+  if (ts11.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
+    const isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
     collectFunction(node, ctx, true, isExported);
     return;
   }
-  if (ts10.isExportDeclaration(node) && node.exportClause && ts10.isNamedExports(node.exportClause)) {
+  if (ts11.isExportDeclaration(node) && node.exportClause && ts11.isNamedExports(node.exportClause)) {
     const isFromReexport = !!node.moduleSpecifier;
-    const sourceSpec = node.moduleSpecifier && ts10.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+    const sourceSpec = node.moduleSpecifier && ts11.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
     const exportSpecifiers = node.exportClause.elements.map((spec) => ({
       name: (spec.propertyName ?? spec.name).text,
       alias: spec.propertyName ? spec.name.text : null,
@@ -5907,24 +6071,24 @@ function visit(node, ctx, targetComponentName, namedExports) {
       }
     }
   }
-  if (ts10.isExportAssignment(node) && !node.isExportEquals) {
+  if (ts11.isExportAssignment(node) && !node.isExportEquals) {
     const expr = node.expression;
-    if (ts10.isIdentifier(expr)) {
+    if (ts11.isIdentifier(expr)) {
       if (ctx.componentName && expr.text === ctx.componentName) {
         ctx.hasDefaultExport = true;
         ctx.isExported = true;
       }
     }
   }
-  ts10.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
+  ts11.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
 }
 function analyzeComponentBody(node, ctx) {
   if (node.parameters.length > 0) {
     extractProps(node.parameters[0], ctx);
   }
-  const body = ts10.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
+  const body = ts11.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
   if (body) {
-    ctx.componentBodyBlock = ts10.isBlock(body) ? body : null;
+    ctx.componentBodyBlock = ts11.isBlock(body) ? body : null;
     if (!ctx.componentBodyBlock) {
       ctx.jsxReturn = unwrapJsxTransparent(body);
     }
@@ -5934,14 +6098,14 @@ function analyzeComponentBody(node, ctx) {
   }
 }
 function getArrowFunctionBody(node) {
-  if (ts10.isBlock(node.body)) {
+  if (ts11.isBlock(node.body)) {
     return node.body;
   }
   return node.body;
 }
 function visitComponentBody(node, ctx) {
   const isTopLevel = ctx.componentBodyBlock !== null && node.parent === ctx.componentBodyBlock;
-  if (ts10.isVariableStatement(node)) {
+  if (ts11.isVariableStatement(node)) {
     for (const decl of node.declarationList.declarations) {
       if (isSignalDeclaration(decl, ctx)) {
         collectSignal(decl, ctx);
@@ -5964,16 +6128,16 @@ function visitComponentBody(node, ctx) {
         collectEffect(decl.initializer, ctx, decl.name.text);
         continue;
       }
-      if (ts10.isIdentifier(decl.name)) {
-        const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+      if (ts11.isIdentifier(decl.name)) {
+        const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx, false, isLet ? "let" : "const");
-      } else if (ts10.isObjectBindingPattern(decl.name) && decl.initializer && ts10.isIdentifier(decl.initializer) && ctx.propsObjectName === decl.initializer.text) {
-        const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+      } else if (ts11.isObjectBindingPattern(decl.name) && decl.initializer && ts11.isIdentifier(decl.initializer) && ctx.propsObjectName === decl.initializer.text) {
+        const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx, false, isLet ? "let" : "const");
       }
     }
   }
-  if (ts10.isExpressionStatement(node)) {
+  if (ts11.isExpressionStatement(node)) {
     if (isEffectCall(node.expression, ctx)) {
       collectEffect(node.expression, ctx);
       return;
@@ -5987,10 +6151,10 @@ function visitComponentBody(node, ctx) {
       return;
     }
   }
-  if (ts10.isFunctionDeclaration(node) && node.name) {
+  if (ts11.isFunctionDeclaration(node) && node.name) {
     collectFunction(node, ctx, false);
   }
-  if (ts10.isIfStatement(node)) {
+  if (ts11.isIfStatement(node)) {
     const jsxReturn = findJsxReturnInBlock(node.thenStatement);
     if (jsxReturn) {
       const scopeVars = collectScopeVariables(node.thenStatement, ctx);
@@ -6009,8 +6173,8 @@ function visitComponentBody(node, ctx) {
       return;
     }
   }
-  if (isTopLevel && (ts10.isTryStatement(node) || ts10.isSwitchStatement(node) || ts10.isForStatement(node) || ts10.isForInStatement(node) || ts10.isForOfStatement(node) || ts10.isWhileStatement(node) || ts10.isDoStatement(node) || ts10.isThrowStatement(node) || ts10.isBlock(node) && node.parent === ctx.componentBodyBlock)) {
-    if (ts10.isBlock(node)) {
+  if (isTopLevel && (ts11.isTryStatement(node) || ts11.isSwitchStatement(node) || ts11.isForStatement(node) || ts11.isForInStatement(node) || ts11.isForOfStatement(node) || ts11.isWhileStatement(node) || ts11.isDoStatement(node) || ts11.isThrowStatement(node) || ts11.isBlock(node) && node.parent === ctx.componentBodyBlock)) {
+    if (ts11.isBlock(node)) {
       const returnedLocal = findBlockBodyReturnedJsxLocalName(node);
       if (returnedLocal) {
         ctx.errors.push(createError(ErrorCodes.RETURN_VALUE_NOT_JSX, getSourceLocation(node, ctx.sourceFile, ctx.filePath), {
@@ -6021,34 +6185,34 @@ function visitComponentBody(node, ctx) {
     collectInitStatement(node, ctx);
     return;
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     ctx.jsxReturn = unwrapJsxTransparent(node.expression);
   }
-  ts10.forEachChild(node, (child) => {
-    if (ts10.isArrowFunction(child) || ts10.isFunctionExpression(child) || ts10.isFunctionDeclaration(child)) {
+  ts11.forEachChild(node, (child) => {
+    if (ts11.isArrowFunction(child) || ts11.isFunctionExpression(child) || ts11.isFunctionDeclaration(child)) {
       return;
     }
     visitComponentBody(child, ctx);
   });
 }
 function findJsxReturnInBlock(node) {
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt) && stmt.expression) {
+      if (ts11.isReturnStatement(stmt) && stmt.expression) {
         const jsx = extractJsxFromExpression(stmt.expression);
         if (jsx)
           return jsx;
       }
     }
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     return extractJsxFromExpression(node.expression);
   }
   return null;
 }
 function unwrapJsxTransparent(expr) {
   let current = expr;
-  while (ts10.isParenthesizedExpression(current) || ts10.isAsExpression(current) || ts10.isSatisfiesExpression(current) || ts10.isNonNullExpression(current) || ts10.isTypeAssertionExpression(current) || current.kind === ts10.SyntaxKind.PartiallyEmittedExpression) {
+  while (ts11.isParenthesizedExpression(current) || ts11.isAsExpression(current) || ts11.isSatisfiesExpression(current) || ts11.isNonNullExpression(current) || ts11.isTypeAssertionExpression(current) || current.kind === ts11.SyntaxKind.PartiallyEmittedExpression) {
     current = current.expression;
   }
   return current;
@@ -6056,22 +6220,22 @@ function unwrapJsxTransparent(expr) {
 function findBlockBodyReturnedJsxLocalName(block) {
   const stmts = block.statements;
   const last = stmts[stmts.length - 1];
-  if (!last || !ts10.isReturnStatement(last) || !last.expression)
+  if (!last || !ts11.isReturnStatement(last) || !last.expression)
     return null;
   const returned = unwrapJsxTransparent(last.expression);
-  if (!ts10.isIdentifier(returned))
+  if (!ts11.isIdentifier(returned))
     return null;
   const name = returned.text;
   for (const stmt of stmts) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts10.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer)
+      if (!ts11.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer)
         continue;
       let init = decl.initializer;
-      while (ts10.isParenthesizedExpression(init))
+      while (ts11.isParenthesizedExpression(init))
         init = init.expression;
-      if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init) || initializerShapeContainsJsx(init) || isMapLikeCallWithJsx(init)) {
+      if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init) || initializerShapeContainsJsx(init) || isMapLikeCallWithJsx(init)) {
         return name;
       }
     }
@@ -6080,16 +6244,16 @@ function findBlockBodyReturnedJsxLocalName(block) {
 }
 function extractJsxFromExpression(expr) {
   const inner = unwrapJsxTransparent(expr);
-  if (ts10.isJsxElement(inner) || ts10.isJsxFragment(inner) || ts10.isJsxSelfClosingElement(inner)) {
+  if (ts11.isJsxElement(inner) || ts11.isJsxFragment(inner) || ts11.isJsxSelfClosingElement(inner)) {
     return inner;
   }
   return null;
 }
 function collectScopeVariables(node, ctx) {
   const variables = [];
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isVariableStatement(stmt)) {
+      if (ts11.isVariableStatement(stmt)) {
         for (const decl of stmt.declarationList.declarations) {
           variables.push(decl);
         }
@@ -6101,13 +6265,13 @@ function collectScopeVariables(node, ctx) {
 function collectParamBindingNames(params) {
   const out = new Set;
   const addBindingNames = (name) => {
-    if (ts10.isIdentifier(name)) {
+    if (ts11.isIdentifier(name)) {
       out.add(name.text);
-    } else if (ts10.isObjectBindingPattern(name)) {
+    } else if (ts11.isObjectBindingPattern(name)) {
       name.elements.forEach((e) => addBindingNames(e.name));
-    } else if (ts10.isArrayBindingPattern(name)) {
+    } else if (ts11.isArrayBindingPattern(name)) {
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name);
       });
     }
@@ -6124,7 +6288,7 @@ function collectEnclosingBranchVars(node, ctx) {
       if (cr.ifStatement.thenStatement !== current)
         continue;
       for (const decl of cr.scopeVariables) {
-        if (!ts10.isIdentifier(decl.name) || !decl.initializer)
+        if (!ts11.isIdentifier(decl.name) || !decl.initializer)
           continue;
         const varName = decl.name.text;
         if (result.has(varName))
@@ -6139,10 +6303,10 @@ function collectEnclosingBranchVars(node, ctx) {
   return result;
 }
 function collectBranchSignals(thenStatement, ctx, branchCondition) {
-  if (!ts10.isBlock(thenStatement))
+  if (!ts11.isBlock(thenStatement))
     return;
   for (const stmt of thenStatement.statements) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
       if (!isSignalDeclaration(decl, ctx))
@@ -6168,13 +6332,13 @@ var ENV_SIGNAL_FACTORIES = {
   createSearchParams: "search"
 };
 function resolvePrimitiveKind(callExpr, ctx) {
-  if (ts10.isIdentifier(callExpr.expression)) {
+  if (ts11.isIdentifier(callExpr.expression)) {
     const hit = PRIMITIVE_CANONICAL_NAMES[callExpr.expression.text];
     if (hit)
       return hit;
     return resolveCalleeViaChecker(callExpr.expression, ctx);
   }
-  if (ts10.isPropertyAccessExpression(callExpr.expression)) {
+  if (ts11.isPropertyAccessExpression(callExpr.expression)) {
     const propName = callExpr.expression.name.text;
     const hit = PRIMITIVE_CANONICAL_NAMES[propName];
     if (!hit)
@@ -6201,7 +6365,7 @@ function resolveCanonicalClientExportName(ident, ctx) {
   if (!symbol)
     return null;
   let target = symbol;
-  if (symbol.flags & ts10.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     try {
       target = ctx.checker.getAliasedSymbol(symbol);
     } catch {
@@ -6217,14 +6381,14 @@ function resolveCanonicalClientExportName(ident, ctx) {
   return null;
 }
 function resolveEnvSignalKey(callExpr, ctx) {
-  if (ts10.isIdentifier(callExpr.expression)) {
+  if (ts11.isIdentifier(callExpr.expression)) {
     const key = ENV_SIGNAL_FACTORIES[callExpr.expression.text];
     if (key)
       return key;
     const canonical = resolveCanonicalClientExportName(callExpr.expression, ctx);
     return canonical ? ENV_SIGNAL_FACTORIES[canonical] ?? null : null;
   }
-  if (ts10.isPropertyAccessExpression(callExpr.expression)) {
+  if (ts11.isPropertyAccessExpression(callExpr.expression)) {
     const key = ENV_SIGNAL_FACTORIES[callExpr.expression.name.text];
     if (key && isBarefootClientNamespace(callExpr.expression.expression, ctx))
       return key;
@@ -6232,7 +6396,7 @@ function resolveEnvSignalKey(callExpr, ctx) {
   return null;
 }
 function isBarefootClientNamespace(expr, ctx) {
-  if (!ts10.isIdentifier(expr))
+  if (!ts11.isIdentifier(expr))
     return false;
   if (!ctx.checker)
     return false;
@@ -6245,22 +6409,22 @@ function isBarefootClientNamespace(expr, ctx) {
   if (!symbol)
     return false;
   for (const decl of symbol.declarations ?? []) {
-    if (!ts10.isNamespaceImport(decl))
+    if (!ts11.isNamespaceImport(decl))
       continue;
     const importDecl = decl.parent.parent;
-    if (!ts10.isImportDeclaration(importDecl))
+    if (!ts11.isImportDeclaration(importDecl))
       continue;
     const mod = importDecl.moduleSpecifier;
-    if (ts10.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
+    if (ts11.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
       return true;
     }
   }
   return false;
 }
 function isSignalDeclaration(node, ctx) {
-  if (!ts10.isArrayBindingPattern(node.name))
+  if (!ts11.isArrayBindingPattern(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "signal";
 }
@@ -6268,14 +6432,14 @@ function collectSignal(node, ctx) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements = pattern.elements;
-  const getterElided = elements.length === 2 && ts10.isOmittedExpression(elements[0]);
-  if (elements.length < 1 || elements.length > 2 || !getterElided && (!ts10.isBindingElement(elements[0]) || !ts10.isIdentifier(elements[0].name))) {
+  const getterElided = elements.length === 2 && ts11.isOmittedExpression(elements[0]);
+  if (elements.length < 1 || elements.length > 2 || !getterElided && (!ts11.isBindingElement(elements[0]) || !ts11.isIdentifier(elements[0].name))) {
     return;
   }
-  if (elements.length === 2 && (!ts10.isBindingElement(elements[1]) || !ts10.isIdentifier(elements[1].name))) {
+  if (elements.length === 2 && (!ts11.isBindingElement(elements[1]) || !ts11.isIdentifier(elements[1].name))) {
     return;
   }
-  const setter = elements.length === 2 && ts10.isBindingElement(elements[1]) && ts10.isIdentifier(elements[1].name) ? elements[1].name.text : null;
+  const setter = elements.length === 2 && ts11.isBindingElement(elements[1]) && ts11.isIdentifier(elements[1].name) ? elements[1].name.text : null;
   if (getterElided && !setter)
     return;
   const getter = getterElided ? `__bfGet_${setter}` : elements[0].name.text;
@@ -6312,33 +6476,33 @@ function collectSignal(node, ctx) {
   });
 }
 function isSignalTupleDeclaration(node) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   const callExpr = node.initializer;
-  return ts10.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
+  return ts11.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
 }
 function isSignalIndexAccess(node, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return null;
-  if (!node.initializer || !ts10.isElementAccessExpression(node.initializer))
+  if (!node.initializer || !ts11.isElementAccessExpression(node.initializer))
     return null;
   const access = node.initializer;
-  if (!ts10.isNumericLiteral(access.argumentExpression))
+  if (!ts11.isNumericLiteral(access.argumentExpression))
     return null;
   const indexValue = Number(access.argumentExpression.text);
   if (indexValue !== 0 && indexValue !== 1)
     return null;
   const index = indexValue;
-  if (ts10.isCallExpression(access.expression)) {
+  if (ts11.isCallExpression(access.expression)) {
     const call = access.expression;
-    if (ts10.isIdentifier(call.expression) && call.expression.text === "createSignal") {
+    if (ts11.isIdentifier(call.expression) && call.expression.text === "createSignal") {
       return { kind: "direct", index, callExpr: call };
     }
     return null;
   }
-  if (ts10.isIdentifier(access.expression)) {
+  if (ts11.isIdentifier(access.expression)) {
     const tupleName = access.expression.text;
     if (ctx.signalTupleRefs.has(tupleName)) {
       return { kind: "tupleRef", index, tupleName };
@@ -6433,30 +6597,30 @@ function flushPendingSignalTuples(ctx) {
   ctx.signalTupleRefs.clear();
 }
 function isMemoDeclaration(node, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "memo";
 }
 function memoBodyIsTemplateLiteral(memoArrow) {
   let node = memoArrow;
-  while (node && ts10.isParenthesizedExpression(node))
+  while (node && ts11.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts10.isArrowFunction(node))
+  if (!node || !ts11.isArrowFunction(node))
     return false;
   let body = node.body;
-  while (ts10.isParenthesizedExpression(body))
+  while (ts11.isParenthesizedExpression(body))
     body = body.expression;
-  if (ts10.isBlock(body)) {
-    const ret = body.statements.find(ts10.isReturnStatement);
+  if (ts11.isBlock(body)) {
+    const ret = body.statements.find(ts11.isReturnStatement);
     if (!ret || !ret.expression)
       return false;
     body = ret.expression;
-    while (ts10.isParenthesizedExpression(body))
+    while (ts11.isParenthesizedExpression(body))
       body = body.expression;
   }
-  return ts10.isTemplateExpression(body) || ts10.isNoSubstitutionTemplateLiteral(body);
+  return ts11.isTemplateExpression(body) || ts11.isNoSubstitutionTemplateLiteral(body);
 }
 function collectMemo(node, ctx) {
   const name = node.name.text;
@@ -6473,7 +6637,7 @@ function collectMemo(node, ctx) {
       type = inferTypeFromValue(arrowBody);
     }
   }
-  if (ctx.checker && (type.kind === "unknown" || type.kind === "object") && callExpr.arguments[0] && (ts10.isArrowFunction(callExpr.arguments[0]) || ts10.isFunctionExpression(callExpr.arguments[0]))) {
+  if (ctx.checker && (type.kind === "unknown" || type.kind === "object") && callExpr.arguments[0] && (ts11.isArrowFunction(callExpr.arguments[0]) || ts11.isFunctionExpression(callExpr.arguments[0]))) {
     const fnType = ctx.checker.getTypeAtLocation(callExpr.arguments[0]);
     const sig = fnType.getCallSignatures()[0];
     if (sig) {
@@ -6483,12 +6647,12 @@ function collectMemo(node, ctx) {
     }
   }
   const memoArrow = callExpr.arguments[0];
-  const parsedBody = memoArrow && ts10.isArrowFunction(memoArrow) && !ts10.isBlock(memoArrow.body) ? parseExpression(ctx.getJS(memoArrow.body)) : undefined;
+  const parsedBody = memoArrow && ts11.isArrowFunction(memoArrow) && !ts11.isBlock(memoArrow.body) ? parseExpression(ctx.getJS(memoArrow.body)) : undefined;
   const parsed = parsedBody && parsedBody.kind !== "unsupported" && parsedBody.kind !== "object-literal" ? parsedBody : undefined;
   let arrowNode = memoArrow;
-  while (arrowNode && ts10.isParenthesizedExpression(arrowNode))
+  while (arrowNode && ts11.isParenthesizedExpression(arrowNode))
     arrowNode = arrowNode.expression;
-  const blockBody = arrowNode && ts10.isArrowFunction(arrowNode) && ts10.isBlock(arrowNode.body) ? arrowNode.body : undefined;
+  const blockBody = arrowNode && ts11.isArrowFunction(arrowNode) && ts11.isBlock(arrowNode.body) ? arrowNode.body : undefined;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx.sourceFile, (node2) => ctx.getJS(node2)) : undefined;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : undefined;
   let templateComputation;
@@ -6515,14 +6679,14 @@ function collectMemo(node, ctx) {
   });
 }
 function isEffectCall(node, ctx) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "effect";
 }
 function isEffectDisposerCapture(node, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "effect";
 }
@@ -6537,7 +6701,7 @@ function collectEffect(node, ctx, captureName) {
   });
 }
 function isOnMountCall(node, ctx) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "onMount";
 }
@@ -6572,19 +6736,19 @@ function leadsWithAsiHazard(body) {
 function extractAssignedIdentifiersFromNode(node) {
   const ids = new Set;
   function addFromTarget(target) {
-    if (ts10.isIdentifier(target)) {
+    if (ts11.isIdentifier(target)) {
       ids.add(target.text);
       return;
     }
-    if (ts10.isParenthesizedExpression(target)) {
+    if (ts11.isParenthesizedExpression(target)) {
       addFromTarget(target.expression);
       return;
     }
-    if (ts10.isArrayLiteralExpression(target)) {
+    if (ts11.isArrayLiteralExpression(target)) {
       for (const el of target.elements) {
-        if (ts10.isOmittedExpression(el))
+        if (ts11.isOmittedExpression(el))
           continue;
-        if (ts10.isSpreadElement(el)) {
+        if (ts11.isSpreadElement(el)) {
           addFromTarget(el.expression);
           continue;
         }
@@ -6592,17 +6756,17 @@ function extractAssignedIdentifiersFromNode(node) {
       }
       return;
     }
-    if (ts10.isObjectLiteralExpression(target)) {
+    if (ts11.isObjectLiteralExpression(target)) {
       for (const prop of target.properties) {
-        if (ts10.isShorthandPropertyAssignment(prop)) {
+        if (ts11.isShorthandPropertyAssignment(prop)) {
           ids.add(prop.name.text);
           continue;
         }
-        if (ts10.isPropertyAssignment(prop)) {
+        if (ts11.isPropertyAssignment(prop)) {
           addFromTarget(prop.initializer);
           continue;
         }
-        if (ts10.isSpreadAssignment(prop)) {
+        if (ts11.isSpreadAssignment(prop)) {
           addFromTarget(prop.expression);
           continue;
         }
@@ -6611,21 +6775,21 @@ function extractAssignedIdentifiersFromNode(node) {
     }
   }
   function visit2(n) {
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n) || ts10.isFunctionDeclaration(n) || ts10.isMethodDeclaration(n) || ts10.isGetAccessorDeclaration(n) || ts10.isSetAccessorDeclaration(n) || ts10.isConstructorDeclaration(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n) || ts11.isFunctionDeclaration(n) || ts11.isMethodDeclaration(n) || ts11.isGetAccessorDeclaration(n) || ts11.isSetAccessorDeclaration(n) || ts11.isConstructorDeclaration(n)) {
       return;
     }
-    if (ts10.isBinaryExpression(n)) {
+    if (ts11.isBinaryExpression(n)) {
       const op = n.operatorToken.kind;
-      if (op === ts10.SyntaxKind.EqualsToken || op === ts10.SyntaxKind.PlusEqualsToken || op === ts10.SyntaxKind.MinusEqualsToken || op === ts10.SyntaxKind.AsteriskEqualsToken || op === ts10.SyntaxKind.SlashEqualsToken || op === ts10.SyntaxKind.PercentEqualsToken || op === ts10.SyntaxKind.AsteriskAsteriskEqualsToken || op === ts10.SyntaxKind.AmpersandEqualsToken || op === ts10.SyntaxKind.BarEqualsToken || op === ts10.SyntaxKind.CaretEqualsToken || op === ts10.SyntaxKind.LessThanLessThanEqualsToken || op === ts10.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === ts10.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === ts10.SyntaxKind.AmpersandAmpersandEqualsToken || op === ts10.SyntaxKind.BarBarEqualsToken || op === ts10.SyntaxKind.QuestionQuestionEqualsToken) {
+      if (op === ts11.SyntaxKind.EqualsToken || op === ts11.SyntaxKind.PlusEqualsToken || op === ts11.SyntaxKind.MinusEqualsToken || op === ts11.SyntaxKind.AsteriskEqualsToken || op === ts11.SyntaxKind.SlashEqualsToken || op === ts11.SyntaxKind.PercentEqualsToken || op === ts11.SyntaxKind.AsteriskAsteriskEqualsToken || op === ts11.SyntaxKind.AmpersandEqualsToken || op === ts11.SyntaxKind.BarEqualsToken || op === ts11.SyntaxKind.CaretEqualsToken || op === ts11.SyntaxKind.LessThanLessThanEqualsToken || op === ts11.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === ts11.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === ts11.SyntaxKind.AmpersandAmpersandEqualsToken || op === ts11.SyntaxKind.BarBarEqualsToken || op === ts11.SyntaxKind.QuestionQuestionEqualsToken) {
         addFromTarget(n.left);
       }
     }
-    if (ts10.isPrefixUnaryExpression(n) || ts10.isPostfixUnaryExpression(n)) {
-      if (n.operator === ts10.SyntaxKind.PlusPlusToken || n.operator === ts10.SyntaxKind.MinusMinusToken) {
+    if (ts11.isPrefixUnaryExpression(n) || ts11.isPostfixUnaryExpression(n)) {
+      if (n.operator === ts11.SyntaxKind.PlusPlusToken || n.operator === ts11.SyntaxKind.MinusMinusToken) {
         addFromTarget(n.operand);
       }
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   const localDecls = collectLocalDeclarations(node);
@@ -6636,30 +6800,30 @@ function extractAssignedIdentifiersFromNode(node) {
 function collectLocalDeclarations(root) {
   const names = new Set;
   function addBindingName(name) {
-    if (ts10.isIdentifier(name)) {
+    if (ts11.isIdentifier(name)) {
       names.add(name.text);
       return;
     }
-    if (ts10.isArrayBindingPattern(name)) {
+    if (ts11.isArrayBindingPattern(name)) {
       for (const el of name.elements) {
-        if (ts10.isBindingElement(el))
+        if (ts11.isBindingElement(el))
           addBindingName(el.name);
       }
       return;
     }
-    if (ts10.isObjectBindingPattern(name)) {
+    if (ts11.isObjectBindingPattern(name)) {
       for (const el of name.elements) {
         addBindingName(el.name);
       }
     }
   }
   function visit2(n) {
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n) || ts10.isFunctionDeclaration(n))
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n) || ts11.isFunctionDeclaration(n))
       return;
-    if (ts10.isVariableDeclaration(n)) {
+    if (ts11.isVariableDeclaration(n)) {
       addBindingName(n.name);
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(root);
   return names;
@@ -6686,6 +6850,7 @@ var CLIENT_EXPORTS = new Set([
   "isSSRPortal",
   "findSiblingSlot",
   "cleanupPortalPlaceholder",
+  "trackPosition",
   "createSearchParams",
   "queryHref",
   "formatDate",
@@ -6693,35 +6858,35 @@ var CLIENT_EXPORTS = new Set([
   "Region"
 ]);
 function collectAmbientGlobals(node, ctx) {
-  if (ts10.isVariableStatement(node)) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false;
+  if (ts11.isVariableStatement(node)) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false;
     if (!isDeclare)
       return;
     for (const decl of node.declarationList.declarations) {
-      if (ts10.isIdentifier(decl.name))
+      if (ts11.isIdentifier(decl.name))
         ctx.ambientGlobals.add(decl.name.text);
     }
     return;
   }
-  if (ts10.isFunctionDeclaration(node) && node.name) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false;
+  if (ts11.isFunctionDeclaration(node) && node.name) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false;
     if (isDeclare)
       ctx.ambientGlobals.add(node.name.text);
     return;
   }
-  if (ts10.isModuleDeclaration(node)) {
-    const isGlobalAugmentation = (node.flags & ts10.NodeFlags.GlobalAugmentation) !== 0;
+  if (ts11.isModuleDeclaration(node)) {
+    const isGlobalAugmentation = (node.flags & ts11.NodeFlags.GlobalAugmentation) !== 0;
     if (!isGlobalAugmentation)
       return;
-    if (!node.body || !ts10.isModuleBlock(node.body))
+    if (!node.body || !ts11.isModuleBlock(node.body))
       return;
     for (const inner of node.body.statements) {
-      if (ts10.isVariableStatement(inner)) {
+      if (ts11.isVariableStatement(inner)) {
         for (const decl of inner.declarationList.declarations) {
-          if (ts10.isIdentifier(decl.name))
+          if (ts11.isIdentifier(decl.name))
             ctx.ambientGlobals.add(decl.name.text);
         }
-      } else if (ts10.isFunctionDeclaration(inner) && inner.name) {
+      } else if (ts11.isFunctionDeclaration(inner) && inner.name) {
         ctx.ambientGlobals.add(inner.name.text);
       }
     }
@@ -6732,7 +6897,7 @@ function collectImport(node, ctx) {
   const specifiers = [];
   const isTypeOnly = !!node.importClause?.isTypeOnly;
   const loc = getSourceLocation(node, ctx.sourceFile, ctx.filePath);
-  if (source === "@barefootjs/client" && !isTypeOnly && node.importClause?.namedBindings && ts10.isNamedImports(node.importClause.namedBindings)) {
+  if (source === "@barefootjs/client" && !isTypeOnly && node.importClause?.namedBindings && ts11.isNamedImports(node.importClause.namedBindings)) {
     const wrongImports = [];
     for (const element of node.importClause.namedBindings.elements) {
       const name = element.propertyName?.text ?? element.name.text;
@@ -6760,7 +6925,7 @@ function collectImport(node, ctx) {
       });
     }
     if (node.importClause.namedBindings) {
-      if (ts10.isNamedImports(node.importClause.namedBindings)) {
+      if (ts11.isNamedImports(node.importClause.namedBindings)) {
         for (const element of node.importClause.namedBindings.elements) {
           specifiers.push({
             name: element.propertyName?.text ?? element.name.text,
@@ -6771,7 +6936,7 @@ function collectImport(node, ctx) {
           });
         }
       }
-      if (ts10.isNamespaceImport(node.importClause.namedBindings)) {
+      if (ts11.isNamespaceImport(node.importClause.namedBindings)) {
         specifiers.push({
           name: node.importClause.namedBindings.name.text,
           alias: null,
@@ -6798,7 +6963,7 @@ function collectInterfaceDefinition(node, ctx) {
   });
 }
 function collectTypeAliasDefinition(node, ctx) {
-  const properties = ts10.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx.sourceFile) : undefined;
+  const properties = ts11.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx.sourceFile) : undefined;
   ctx.typeDefinitions.push({
     kind: "type",
     name: node.name.text,
@@ -6811,20 +6976,20 @@ function extractSingleJsxReturn(body) {
   let jsxReturn = null;
   let returnCount = 0;
   function visit2(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node))
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node))
       return;
-    if (ts10.isReturnStatement(node)) {
+    if (ts11.isReturnStatement(node)) {
       returnCount++;
       if (node.expression) {
         const expr = unwrapJsxTransparent(node.expression);
-        if (ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr)) {
+        if (ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr)) {
           jsxReturn = expr;
         }
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(body, visit2);
+  ts11.forEachChild(body, visit2);
   if (returnCount !== 1)
     return null;
   return jsxReturn;
@@ -6841,9 +7006,9 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
   const stmts = body.statements;
   for (let i = 0;i < stmts.length; i++) {
     const stmt = stmts[i];
-    if (ts10.isIfStatement(stmt)) {
+    if (ts11.isIfStatement(stmt)) {
       let current = stmt;
-      while (ts10.isIfStatement(current)) {
+      while (ts11.isIfStatement(current)) {
         const ifStmt = current;
         if (!isDirectReturnBlock(ifStmt.thenStatement))
           return null;
@@ -6853,7 +7018,7 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
           return null;
         branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null });
         if (ifStmt.elseStatement) {
-          if (ts10.isIfStatement(ifStmt.elseStatement)) {
+          if (ts11.isIfStatement(ifStmt.elseStatement)) {
             current = ifStmt.elseStatement;
             continue;
           }
@@ -6875,18 +7040,18 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
       }
       continue;
     }
-    if (ts10.isSwitchStatement(stmt)) {
+    if (ts11.isSwitchStatement(stmt)) {
       if (branches.length > 0)
         return null;
-      if (!ts10.isIdentifier(stmt.expression) && !ts10.isPropertyAccessExpression(stmt.expression)) {
+      if (!ts11.isIdentifier(stmt.expression) && !ts11.isPropertyAccessExpression(stmt.expression)) {
         return null;
       }
-      const hasDefault = stmt.caseBlock.clauses.some((c) => ts10.isDefaultClause(c));
+      const hasDefault = stmt.caseBlock.clauses.some((c) => ts11.isDefaultClause(c));
       if (!hasDefault)
         return null;
       let pendingCases = [];
       for (const clause of stmt.caseBlock.clauses) {
-        if (ts10.isCaseClause(clause) && clause.statements.length === 0) {
+        if (ts11.isCaseClause(clause) && clause.statements.length === 0) {
           pendingCases.push(clause.expression);
           continue;
         }
@@ -6896,7 +7061,7 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
           return null;
         if (!caseClauseIsDirectReturn(clause))
           return null;
-        if (ts10.isCaseClause(clause)) {
+        if (ts11.isCaseClause(clause)) {
           branches.push({
             condition: clause.expression,
             jsxReturn: jsxReturn ?? null,
@@ -6917,18 +7082,18 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
         return null;
       return { branches, fallback, switchDiscriminant: stmt.expression, preamble };
     }
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr)) {
+      if (ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr)) {
         fallback = expr;
-      } else if (expr.kind === ts10.SyntaxKind.NullKeyword) {} else {
+      } else if (expr.kind === ts11.SyntaxKind.NullKeyword) {} else {
         return null;
       }
       continue;
     }
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       const declFlags = stmt.declarationList.flags;
-      const isConstOrLet = (declFlags & ts10.NodeFlags.Const) !== 0 || (declFlags & ts10.NodeFlags.Let) !== 0;
+      const isConstOrLet = (declFlags & ts11.NodeFlags.Const) !== 0 || (declFlags & ts11.NodeFlags.Let) !== 0;
       if (allowPreamble && isConstOrLet && branches.length === 0 && fallback === null) {
         preamble.push(stmt);
         continue;
@@ -6944,12 +7109,12 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
   return { branches, fallback, preamble };
 }
 function isDirectReturnBlock(node) {
-  if (ts10.isReturnStatement(node))
+  if (ts11.isReturnStatement(node))
     return true;
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     let returnCount = 0;
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt)) {
+      if (ts11.isReturnStatement(stmt)) {
         returnCount++;
         continue;
       }
@@ -6960,25 +7125,25 @@ function isDirectReturnBlock(node) {
   return false;
 }
 function findNullReturnInBlock(node) {
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt) && stmt.expression) {
+      if (ts11.isReturnStatement(stmt) && stmt.expression) {
         const expr = unwrapJsxTransparent(stmt.expression);
-        if (expr.kind === ts10.SyntaxKind.NullKeyword)
+        if (expr.kind === ts11.SyntaxKind.NullKeyword)
           return true;
       }
     }
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     const expr = unwrapJsxTransparent(node.expression);
-    if (expr.kind === ts10.SyntaxKind.NullKeyword)
+    if (expr.kind === ts11.SyntaxKind.NullKeyword)
       return true;
   }
   return false;
 }
 function findJsxReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       return extractJsxFromExpression(stmt.expression);
     }
   }
@@ -6988,12 +7153,12 @@ function caseClauseIsDirectReturn(clause) {
   let returnCount = 0;
   let seenReturn = false;
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt)) {
+    if (ts11.isReturnStatement(stmt)) {
       returnCount++;
       seenReturn = true;
       continue;
     }
-    if (ts10.isBreakStatement(stmt)) {
+    if (ts11.isBreakStatement(stmt)) {
       if (!seenReturn)
         return false;
       continue;
@@ -7004,9 +7169,9 @@ function caseClauseIsDirectReturn(clause) {
 }
 function findNullReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (expr.kind === ts10.SyntaxKind.NullKeyword)
+      if (expr.kind === ts11.SyntaxKind.NullKeyword)
         return true;
     }
   }
@@ -7017,26 +7182,26 @@ function isMultiReturnJsxFunctionBody(body) {
   let hasJsxReturn = false;
   let allReturnsAreJsxOrNull = true;
   function visit2(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node))
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node))
       return;
-    if (ts10.isReturnStatement(node)) {
+    if (ts11.isReturnStatement(node)) {
       returnCount++;
       if (!node.expression) {
         allReturnsAreJsxOrNull = false;
         return;
       }
       const expr = unwrapJsxTransparent(node.expression);
-      const isJsx = ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr);
-      const isNull = expr.kind === ts10.SyntaxKind.NullKeyword;
+      const isJsx = ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr);
+      const isNull = expr.kind === ts11.SyntaxKind.NullKeyword;
       if (isJsx)
         hasJsxReturn = true;
       if (!isJsx && !isNull)
         allReturnsAreJsxOrNull = false;
       return;
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(body, visit2);
+  ts11.forEachChild(body, visit2);
   return returnCount > 1 && hasJsxReturn && allReturnsAreJsxOrNull;
 }
 function collectFunction(node, ctx, _isModule, isExported = false) {
@@ -7106,7 +7271,7 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
       }
     }
   }
-  const isAsync = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.AsyncKeyword) ?? false;
+  const isAsync = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.AsyncKeyword) ?? false;
   const isGenerator = !!node.asteriskToken;
   ctx.localFunctions.push({
     name,
@@ -7127,10 +7292,10 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
   });
 }
 function extractValueBranches(node, ctx) {
-  if (ts10.isParenthesizedExpression(node)) {
+  if (ts11.isParenthesizedExpression(node)) {
     return extractValueBranches(node.expression, ctx);
   }
-  if (ts10.isConditionalExpression(node)) {
+  if (ts11.isConditionalExpression(node)) {
     return [
       ...extractValueBranches(node.whenTrue, ctx),
       ...extractValueBranches(node.whenFalse, ctx)
@@ -7142,46 +7307,46 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundNames = new Set;
   function addBindingNames(name, out) {
-    if (ts10.isIdentifier(name))
+    if (ts11.isIdentifier(name))
       out.push(name.text);
-    else if (ts10.isObjectBindingPattern(name))
+    else if (ts11.isObjectBindingPattern(name))
       name.elements.forEach((e) => addBindingNames(e.name, out));
-    else if (ts10.isArrayBindingPattern(name))
+    else if (ts11.isArrayBindingPattern(name))
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name, out);
       });
   }
   function visit2(n) {
-    if (ts10.isTypeNode(n))
+    if (ts11.isTypeNode(n))
       return;
-    if (ts10.isIdentifier(n)) {
+    if (ts11.isIdentifier(n)) {
       const parent = n.parent;
-      if (parent && ts10.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts10.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts10.isParameter(parent) && parent.name === n)
+      if (parent && ts11.isParameter(parent) && parent.name === n)
         return;
-      if (parent && ts10.isVariableDeclaration(parent) && parent.name === n)
+      if (parent && ts11.isVariableDeclaration(parent) && parent.name === n)
         return;
       if (boundNames.has(n.text))
         return;
       ids.add(n.text);
       return;
     }
-    if (ts10.isArrowFunction(n)) {
+    if (ts11.isArrowFunction(n)) {
       const params = [];
       for (const p of n.parameters)
         addBindingNames(p.name, params);
       for (const name of params)
         boundNames.add(name);
-      ts10.forEachChild(n, visit2);
+      ts11.forEachChild(n, visit2);
       for (const name of params)
         boundNames.delete(name);
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return ids;
@@ -7190,29 +7355,29 @@ function extractFreeTypeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundTypeParams = new Set;
   function rootName(name) {
-    return ts10.isQualifiedName(name) ? rootName(name.left) : name;
+    return ts11.isQualifiedName(name) ? rootName(name.left) : name;
   }
   function visit2(n) {
-    if (ts10.isTypeReferenceNode(n)) {
+    if (ts11.isTypeReferenceNode(n)) {
       const name = rootName(n.typeName).text;
       if (!boundTypeParams.has(name))
         ids.add(name);
     }
-    if (ts10.isTypeQueryNode(n)) {
+    if (ts11.isTypeQueryNode(n)) {
       const name = rootName(n.exprName).text;
       if (!boundTypeParams.has(name))
         ids.add(name);
     }
-    if (ts10.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
+    if (ts11.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
       const names = n.typeParameters.map((p) => p.name.text);
       for (const p of names)
         boundTypeParams.add(p);
-      ts10.forEachChild(n, visit2);
+      ts11.forEachChild(n, visit2);
       for (const p of names)
         boundTypeParams.delete(p);
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return ids;
@@ -7222,22 +7387,22 @@ function initializerShapeContainsJsx(node) {
   function visit2(n) {
     if (found)
       return;
-    if (ts10.isJsxElement(n) || ts10.isJsxSelfClosingElement(n) || ts10.isJsxFragment(n)) {
+    if (ts11.isJsxElement(n) || ts11.isJsxSelfClosingElement(n) || ts11.isJsxFragment(n)) {
       found = true;
       return;
     }
-    if (ts10.isFunctionDeclaration(n) || ts10.isFunctionExpression(n) || ts10.isArrowFunction(n)) {
+    if (ts11.isFunctionDeclaration(n) || ts11.isFunctionExpression(n) || ts11.isArrowFunction(n)) {
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
 }
 function isMapLikeCallWithJsx(node) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
-  if (!ts10.isPropertyAccessExpression(node.expression))
+  if (!ts11.isPropertyAccessExpression(node.expression))
     return false;
   const method = node.expression.name.text;
   if (method !== "map" && method !== "flatMap")
@@ -7245,12 +7410,12 @@ function isMapLikeCallWithJsx(node) {
   const callback = node.arguments[0];
   if (!callback)
     return false;
-  if (!ts10.isArrowFunction(callback) && !ts10.isFunctionExpression(callback))
+  if (!ts11.isArrowFunction(callback) && !ts11.isFunctionExpression(callback))
     return false;
   return containsJsxDeep(callback.body);
 }
 function containsJsxDeep(node) {
-  if (ts10.isJsxElement(node) || ts10.isJsxSelfClosingElement(node) || ts10.isJsxFragment(node))
+  if (ts11.isJsxElement(node) || ts11.isJsxSelfClosingElement(node) || ts11.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -7264,11 +7429,11 @@ function nodeContainsArrow(node) {
   function visit2(n) {
     if (found)
       return;
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n)) {
       found = true;
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
@@ -7316,20 +7481,20 @@ function collectModuleScopeReactive(decl, ctx, isExported) {
   }));
 }
 function getSystemConstructKind(node) {
-  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "createContext")
+  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "createContext")
     return "createContext";
-  if (ts10.isNewExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "WeakMap")
+  if (ts11.isNewExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "WeakMap")
     return "weakMap";
   return;
 }
 function collectConstant(node, ctx, _isModule, declarationKind = "const", isExported = false) {
-  if (!_isModule && ts10.isObjectBindingPattern(node.name) && node.initializer && ts10.isIdentifier(node.initializer) && ctx.propsObjectName === node.initializer.text) {
+  if (!_isModule && ts11.isObjectBindingPattern(node.name) && node.initializer && ts11.isIdentifier(node.initializer) && ctx.propsObjectName === node.initializer.text) {
     const propsName = node.initializer.text;
     for (const el of node.name.elements) {
-      if (!ts10.isBindingElement(el) || !ts10.isIdentifier(el.name) || el.dotDotDotToken)
+      if (!ts11.isBindingElement(el) || !ts11.isIdentifier(el.name) || el.dotDotDotToken)
         continue;
       const localName = el.name.text;
-      const sourceKey = el.propertyName && ts10.isIdentifier(el.propertyName) ? el.propertyName.text : localName;
+      const sourceKey = el.propertyName && ts11.isIdentifier(el.propertyName) ? el.propertyName.text : localName;
       const defaultValueExpr = el.initializer ? ctx.getJS(el.initializer) : undefined;
       const baseValue = `${propsName}.${sourceKey}`;
       const value2 = defaultValueExpr ? `${baseValue} ?? ${defaultValueExpr}` : baseValue;
@@ -7351,7 +7516,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     }
     return;
   }
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return;
   if (isSignalDeclaration(node, ctx) || isMemoDeclaration(node, ctx))
     return;
@@ -7369,9 +7534,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let isJsxFunction = false;
   if (node.initializer) {
     let init = node.initializer;
-    while (ts10.isParenthesizedExpression(init))
+    while (ts11.isParenthesizedExpression(init))
       init = init.expression;
-    if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init)) {
+    if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init)) {
       isJsx = true;
       ctx.jsxConstants.set(name, init);
     } else if (initializerShapeContainsJsx(init)) {
@@ -7379,9 +7544,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     } else if (isMapLikeCallWithJsx(init)) {
       ctx.inlineableJsxConsts.set(name, init);
     }
-    if (ts10.isArrowFunction(init)) {
+    if (ts11.isArrowFunction(init)) {
       const arrowBody = init.body;
-      if (ts10.isBlock(arrowBody)) {
+      if (ts11.isBlock(arrowBody)) {
         const jsxReturn = extractSingleJsxReturn(arrowBody);
         if (jsxReturn) {
           isJsxFunction = true;
@@ -7401,9 +7566,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
         }
       } else {
         let body = arrowBody;
-        while (ts10.isParenthesizedExpression(body))
+        while (ts11.isParenthesizedExpression(body))
           body = body.expression;
-        if (ts10.isJsxElement(body) || ts10.isJsxSelfClosingElement(body) || ts10.isJsxFragment(body)) {
+        if (ts11.isJsxElement(body) || ts11.isJsxSelfClosingElement(body) || ts11.isJsxFragment(body)) {
           isJsxFunction = true;
           ctx.jsxFunctions.set(name, {
             jsxReturn: body,
@@ -7416,9 +7581,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let valueBranches;
   if (node.initializer) {
     let inner = node.initializer;
-    while (ts10.isParenthesizedExpression(inner))
+    while (ts11.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (ts10.isConditionalExpression(inner)) {
+    if (ts11.isConditionalExpression(inner)) {
       valueBranches = extractValueBranches(node.initializer, ctx);
     }
   }
@@ -7496,7 +7661,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
 function hasIgnoreDirective(node, sourceFile, ruleId) {
   const checkComments = (targetNode) => {
     const fullStart = targetNode.getFullStart();
-    const leadingComments = ts10.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
+    const leadingComments = ts11.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
     if (!leadingComments)
       return false;
     for (const range of leadingComments) {
@@ -7509,10 +7674,10 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   };
   if (checkComments(node))
     return true;
-  if (ts10.isArrowFunction(node)) {
+  if (ts11.isArrowFunction(node)) {
     let current = node.parent;
     while (current) {
-      if (ts10.isVariableStatement(current)) {
+      if (ts11.isVariableStatement(current)) {
         if (checkComments(current))
           return true;
         break;
@@ -7523,7 +7688,7 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   return false;
 }
 function extractProps(param, ctx) {
-  if (ts10.isObjectBindingPattern(param.name)) {
+  if (ts11.isObjectBindingPattern(param.name)) {
     const componentNode = ctx.componentNode;
     const ignored = !!(componentNode && hasIgnoreDirective(componentNode, ctx.sourceFile, "props-destructuring"));
     ctx.propsDestructuring = {
@@ -7532,14 +7697,14 @@ function extractProps(param, ctx) {
     };
     const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null;
     for (const element of param.name.elements) {
-      if (ts10.isBindingElement(element) && ts10.isIdentifier(element.name)) {
+      if (ts11.isBindingElement(element) && ts11.isIdentifier(element.name)) {
         const localName = element.name.text;
         const defaultValue = element.initializer ? ctx.getJS(element.initializer) : undefined;
         if (element.dotDotDotToken) {
           ctx.restPropsName = localName;
           continue;
         }
-        const sourcePropName = element.propertyName && ts10.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
+        const sourcePropName = element.propertyName && ts11.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
         const member = memberTypes?.get(sourcePropName);
         const resolvedType = member?.type ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
@@ -7563,7 +7728,7 @@ function extractProps(param, ctx) {
       }
     }
   }
-  if (ts10.isIdentifier(param.name)) {
+  if (ts11.isIdentifier(param.name)) {
     ctx.propsObjectName = param.name.text;
     if (param.type) {
       extractPropsFromType(param.type, ctx);
@@ -7574,24 +7739,24 @@ function extractProps(param, ctx) {
   }
 }
 function collectTypeKeys(typeNode, ctx) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     return collectKeysFromMembers(typeNode.members, ctx);
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (!typeDecl)
       return null;
-    if (ts10.isInterfaceDeclaration(typeDecl)) {
+    if (ts11.isInterfaceDeclaration(typeDecl)) {
       if (typeDecl.heritageClauses && typeDecl.heritageClauses.length > 0)
         return null;
       return collectKeysFromMembers(typeDecl.members, ctx);
     }
-    if (ts10.isTypeAliasDeclaration(typeDecl)) {
-      if (ts10.isTypeLiteralNode(typeDecl.type)) {
+    if (ts11.isTypeAliasDeclaration(typeDecl)) {
+      if (ts11.isTypeLiteralNode(typeDecl.type)) {
         return collectKeysFromMembers(typeDecl.type.members, ctx);
       }
-      if (ts10.isIntersectionTypeNode(typeDecl.type)) {
+      if (ts11.isIntersectionTypeNode(typeDecl.type)) {
         return null;
       }
     }
@@ -7601,9 +7766,9 @@ function collectTypeKeys(typeNode, ctx) {
 function collectKeysFromMembers(members, ctx) {
   const keys = [];
   for (const member of members) {
-    if (ts10.isIndexSignatureDeclaration(member))
+    if (ts11.isIndexSignatureDeclaration(member))
       return null;
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isPropertySignature(member) && member.name) {
       keys.push(member.name.getText(ctx.sourceFile));
     }
   }
@@ -7627,7 +7792,7 @@ function collectMemberTypes(typeNode, ctx) {
   const fromMembers = (members) => {
     const map = new Map;
     for (const member of members) {
-      if (ts10.isPropertySignature(member) && member.name) {
+      if (ts11.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null;
         map.set(member.name.getText(ctx.sourceFile), {
           type: info && isResolvableMemberType(info) ? info : null,
@@ -7637,35 +7802,35 @@ function collectMemberTypes(typeNode, ctx) {
     }
     return map;
   };
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     return fromMembers(typeNode.members);
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (!typeDecl)
       return null;
-    if (ts10.isInterfaceDeclaration(typeDecl)) {
+    if (ts11.isInterfaceDeclaration(typeDecl)) {
       return fromMembers(typeDecl.members);
     }
-    if (ts10.isTypeAliasDeclaration(typeDecl) && ts10.isTypeLiteralNode(typeDecl.type)) {
+    if (ts11.isTypeAliasDeclaration(typeDecl) && ts11.isTypeLiteralNode(typeDecl.type)) {
       return fromMembers(typeDecl.type.members);
     }
   }
   return null;
 }
 function extractPropsFromType(typeNode, ctx) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
     return;
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (typeDecl) {
-      if (ts10.isInterfaceDeclaration(typeDecl)) {
+      if (ts11.isInterfaceDeclaration(typeDecl)) {
         extractPropsFromTypeMembers(typeDecl.members, ctx);
-      } else if (ts10.isTypeAliasDeclaration(typeDecl) && ts10.isTypeLiteralNode(typeDecl.type)) {
+      } else if (ts11.isTypeAliasDeclaration(typeDecl) && ts11.isTypeLiteralNode(typeDecl.type)) {
         extractPropsFromTypeMembers(typeDecl.type.members, ctx);
       }
     }
@@ -7673,7 +7838,7 @@ function extractPropsFromType(typeNode, ctx) {
 }
 function extractPropsFromTypeMembers(members, ctx) {
   for (const member of members) {
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isPropertySignature(member) && member.name) {
       const propName = member.name.getText(ctx.sourceFile);
       const isOptional = !!member.questionToken;
       const propType = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : { kind: "unknown", raw: "unknown" };
@@ -7689,17 +7854,17 @@ function extractPropsFromTypeMembers(members, ctx) {
 function findTypeDeclaration(typeName, sourceFile) {
   let result;
   function visit2(node) {
-    if (ts10.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isInterfaceDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    if (ts10.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(sourceFile, visit2);
+  ts11.forEachChild(sourceFile, visit2);
   return result;
 }
 function inferTypeFromValue(value) {
@@ -7745,12 +7910,12 @@ function inferTypeFromValue(value) {
 }
 function collectCalledIdentifiers(code) {
   const called = new Set;
-  const sf = ts10.createSourceFile("__deps__.tsx", code, ts10.ScriptTarget.Latest, false, ts10.ScriptKind.TSX);
+  const sf = ts11.createSourceFile("__deps__.tsx", code, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
   const visit2 = (node) => {
-    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression)) {
+    if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression)) {
       called.add(node.expression.text);
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   };
   visit2(sf);
   return called;
@@ -7848,16 +8013,16 @@ function isResolvableComponentSource(source) {
 function collectJsxComponentTags(sourceFile) {
   const tags = new Set;
   function visit2(node) {
-    if (ts10.isJsxOpeningElement(node) || ts10.isJsxSelfClosingElement(node)) {
+    if (ts11.isJsxOpeningElement(node) || ts11.isJsxSelfClosingElement(node)) {
       const tagName = node.tagName;
-      if (ts10.isIdentifier(tagName)) {
+      if (ts11.isIdentifier(tagName)) {
         const first = tagName.text.charAt(0);
         if (first >= "A" && first <= "Z") {
           tags.add(tagName.text);
         }
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sourceFile);
   return tags;
@@ -7936,18 +8101,18 @@ function fileHasUseClientDirective(filePath) {
   } catch {
     return true;
   }
-  const sf = ts10.createSourceFile(filePath, content, ts10.ScriptTarget.Latest, false, ts10.ScriptKind.TSX);
+  const sf = ts11.createSourceFile(filePath, content, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
   let found = false;
   function visit2(node) {
     if (found)
       return;
-    if (ts10.isExpressionStatement(node) && ts10.isStringLiteral(node.expression)) {
+    if (ts11.isExpressionStatement(node) && ts11.isStringLiteral(node.expression)) {
       if (node.expression.text === "use client") {
         found = true;
         return;
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sf);
   return found;
@@ -8005,7 +8170,8 @@ var BROWSER_ONLY_CLIENT_APIS = new Set([
   "createPortal",
   "isSSRPortal",
   "findSiblingSlot",
-  "cleanupPortalPlaceholder"
+  "cleanupPortalPlaceholder",
+  "trackPosition"
 ]);
 function importsBrowserOnlyClientApi(ctx) {
   for (const imp of ctx.imports) {
@@ -8024,11 +8190,11 @@ function importsBrowserOnlyClientApi(ctx) {
   return false;
 }
 function listComponentFunctions(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   return listComponentFunctionsFromSourceFile(sourceFile);
 }
 function scanComponentFile(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   return {
     exports: listComponentFunctionsFromSourceFile(sourceFile),
     referencedComponents: [...collectJsxComponentTags(sourceFile)]
@@ -8036,11 +8202,11 @@ function scanComponentFile(source, filePath) {
 }
 function listComponentFunctionsFromSourceFile(sourceFile) {
   const componentNames = [];
-  const hasUseClient = sourceFile.statements.some((stmt) => ts10.isExpressionStatement(stmt) && ts10.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const hasUseClient = sourceFile.statements.some((stmt) => ts11.isExpressionStatement(stmt) && ts11.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   const namedExports = collectNamedExports(sourceFile);
   function collectComponents(node) {
     if (isComponentFunction(node)) {
-      const hasInlineExport = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+      const hasInlineExport = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
       const hasNamedExport = namedExports.has(node.name.text);
       const isExported = hasInlineExport || hasNamedExport;
       if (!hasUseClient && !isExported && node.body && isMultiReturnJsxFunctionBody(node.body)) {} else {
@@ -8050,9 +8216,9 @@ function listComponentFunctionsFromSourceFile(sourceFile) {
     if (isArrowComponentFunction(node)) {
       componentNames.push(node.name.text);
     }
-    ts10.forEachChild(node, collectComponents);
+    ts11.forEachChild(node, collectComponents);
   }
-  ts10.forEachChild(sourceFile, collectComponents);
+  ts11.forEachChild(sourceFile, collectComponents);
   return componentNames;
 }
 var REACTIVE_PRIMITIVES = new Set([
@@ -8064,13 +8230,13 @@ var REACTIVE_PRIMITIVES = new Set([
   "onCleanup"
 ]);
 function prescanReactiveFactoriesInSource(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath + ".prescan", source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath + ".prescan", source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   const factories = new Map;
   const declined = new Map;
   const reactiveShaped = new Set;
   const cleanFactoryImports = new Set;
   function visitTop(node) {
-    if (ts10.isFunctionDeclaration(node) && node.name && node.body) {
+    if (ts11.isFunctionDeclaration(node) && node.name && node.body) {
       const det = detectReactiveFactory(node, sourceFile, filePath);
       if (!det)
         return;
@@ -8087,7 +8253,7 @@ function prescanReactiveFactoriesInSource(source, filePath) {
       }
     }
   }
-  ts10.forEachChild(sourceFile, visitTop);
+  ts11.forEachChild(sourceFile, visitTop);
   const result = { factories, declined, reactiveShaped, cleanFactoryImports, sourceFile };
   prescanImportedReactiveFactories(sourceFile, filePath, result);
   return result;
@@ -8104,15 +8270,15 @@ function toComponentRelativeSpecifier(resolvedAbs, componentFilePath) {
 function buildEntryImportIndex(sf, filePath) {
   const index = new Map;
   for (const stmt of sf.statements) {
-    if (!ts10.isImportDeclaration(stmt))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const src = stmt.moduleSpecifier.text;
     const targetKey = src.startsWith("./") || src.startsWith("../") ? resolveRelativeImportToFile(src, filePath) ?? "unresolved:" + src : src;
     const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
     const namedBindings = stmt.importClause?.namedBindings;
-    if (namedBindings && ts10.isNamedImports(namedBindings)) {
+    if (namedBindings && ts11.isNamedImports(namedBindings)) {
       for (const el of namedBindings.elements) {
         index.set(el.name.text, {
           targetKey,
@@ -8127,31 +8293,31 @@ function buildEntryImportIndex(sf, filePath) {
 function collectEntryBindingNames(sf) {
   const names = new Set;
   function visit2(node) {
-    if (ts10.isImportDeclaration(node) && node.importClause) {
+    if (ts11.isImportDeclaration(node) && node.importClause) {
       if (node.importClause.name)
         names.add(node.importClause.name.text);
       const namedBindings = node.importClause.namedBindings;
-      if (namedBindings && ts10.isNamedImports(namedBindings)) {
+      if (namedBindings && ts11.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements)
           names.add(el.name.text);
       }
-      if (namedBindings && ts10.isNamespaceImport(namedBindings)) {
+      if (namedBindings && ts11.isNamespaceImport(namedBindings)) {
         names.add(namedBindings.name.text);
       }
     }
-    if (ts10.isVariableDeclaration(node)) {
+    if (ts11.isVariableDeclaration(node)) {
       const out = [];
       addBindingNames(node.name, out);
       for (const n of out)
         names.add(n);
     }
-    if ((ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node) || ts10.isEnumDeclaration(node)) && node.name) {
+    if ((ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node) || ts11.isEnumDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
-    if ((ts10.isTypeAliasDeclaration(node) || ts10.isInterfaceDeclaration(node)) && node.name) {
+    if ((ts11.isTypeAliasDeclaration(node) || ts11.isInterfaceDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
-    if (ts10.isFunctionLike(node)) {
+    if (ts11.isFunctionLike(node)) {
       for (const p of node.parameters) {
         const out = [];
         addBindingNames(p.name, out);
@@ -8159,7 +8325,7 @@ function collectEntryBindingNames(sf) {
           names.add(n);
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sf);
   return names;
@@ -8168,19 +8334,19 @@ var MAX_REEXPORT_HOPS = 1;
 function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   const candidateCallees = new Set;
   function collectCandidates(node) {
-    if (ts10.isVariableDeclaration(node) && (ts10.isArrayBindingPattern(node.name) || ts10.isObjectBindingPattern(node.name)) && node.initializer && ts10.isCallExpression(node.initializer) && ts10.isIdentifier(node.initializer.expression)) {
+    if (ts11.isVariableDeclaration(node) && (ts11.isArrayBindingPattern(node.name) || ts11.isObjectBindingPattern(node.name)) && node.initializer && ts11.isCallExpression(node.initializer) && ts11.isIdentifier(node.initializer.expression)) {
       candidateCallees.add(node.initializer.expression.text);
     }
-    ts10.forEachChild(node, collectCandidates);
+    ts11.forEachChild(node, collectCandidates);
   }
   collectCandidates(entrySourceFile);
   if (candidateCallees.size === 0)
     return;
   const importsToCheck = [];
   for (const stmt of entrySourceFile.statements) {
-    if (!ts10.isImportDeclaration(stmt))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const src = stmt.moduleSpecifier.text;
     if (!src.startsWith("./") && !src.startsWith("../"))
@@ -8188,7 +8354,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
     if (stmt.importClause?.isTypeOnly)
       continue;
     const namedBindings = stmt.importClause?.namedBindings;
-    if (!namedBindings || !ts10.isNamedImports(namedBindings))
+    if (!namedBindings || !ts11.isNamedImports(namedBindings))
       continue;
     const specs = [];
     for (const el of namedBindings.elements) {
@@ -8226,14 +8392,14 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
       helperCache.set(abs, "clean");
       return "clean";
     }
-    const sf = ts10.createSourceFile(abs + ".prescan", content, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+    const sf = ts11.createSourceFile(abs + ".prescan", content, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
     const localFns = new Map;
     const exportedFns = new Map;
     for (const stmt of sf.statements) {
-      if (ts10.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
+      if (ts11.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
         localFns.set(stmt.name.text, stmt);
-        const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
-        const hasDefaultModifier = stmt.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword) ?? false;
+        const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
+        const hasDefaultModifier = stmt.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword) ?? false;
         if (hasExportModifier && !hasDefaultModifier) {
           exportedFns.set(stmt.name.text, stmt);
         }
@@ -8242,10 +8408,10 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
     const reexports = new Map;
     let hasStarReexport = false;
     for (const stmt of sf.statements) {
-      if (!ts10.isExportDeclaration(stmt) || stmt.isTypeOnly)
+      if (!ts11.isExportDeclaration(stmt) || stmt.isTypeOnly)
         continue;
       if (!stmt.moduleSpecifier) {
-        if (stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+        if (stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
           for (const el of stmt.exportClause.elements) {
             if (el.isTypeOnly)
               continue;
@@ -8256,9 +8422,9 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
         }
         continue;
       }
-      if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier))
         continue;
-      if (stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+      if (stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
         for (const el of stmt.exportClause.elements) {
           if (el.isTypeOnly)
             continue;
@@ -8408,7 +8574,7 @@ function collectHelperModuleValueBindings(sf) {
   const importedTypes = new Map;
   const imported = new Map;
   for (const stmt of sf.statements) {
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       const out = [];
       for (const decl of stmt.declarationList.declarations) {
         addBindingNames(decl.name, out);
@@ -8417,16 +8583,16 @@ function collectHelperModuleValueBindings(sf) {
         local.add(n);
       continue;
     }
-    if ((ts10.isFunctionDeclaration(stmt) || ts10.isClassDeclaration(stmt) || ts10.isEnumDeclaration(stmt)) && stmt.name) {
+    if ((ts11.isFunctionDeclaration(stmt) || ts11.isClassDeclaration(stmt) || ts11.isEnumDeclaration(stmt)) && stmt.name) {
       local.add(stmt.name.text);
       continue;
     }
-    if ((ts10.isTypeAliasDeclaration(stmt) || ts10.isInterfaceDeclaration(stmt)) && stmt.name) {
+    if ((ts11.isTypeAliasDeclaration(stmt) || ts11.isInterfaceDeclaration(stmt)) && stmt.name) {
       localTypes.add(stmt.name.text);
       continue;
     }
-    if (ts10.isImportDeclaration(stmt)) {
-      if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (ts11.isImportDeclaration(stmt)) {
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier))
         continue;
       const src = stmt.moduleSpecifier.text;
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime")
@@ -8435,7 +8601,7 @@ function collectHelperModuleValueBindings(sf) {
       if (stmt.importClause?.name)
         (wholeTypeOnly ? localTypes : local).add(stmt.importClause.name.text);
       const namedBindings = stmt.importClause?.namedBindings;
-      if (namedBindings && ts10.isNamedImports(namedBindings)) {
+      if (namedBindings && ts11.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) {
           const entry = { source: src, exportedName: (el.propertyName ?? el.name).text };
           if (wholeTypeOnly || el.isTypeOnly)
@@ -8444,7 +8610,7 @@ function collectHelperModuleValueBindings(sf) {
             imported.set(el.name.text, entry);
         }
       }
-      if (namedBindings && ts10.isNamespaceImport(namedBindings)) {
+      if (namedBindings && ts11.isNamespaceImport(namedBindings)) {
         (wholeTypeOnly ? localTypes : local).add(namedBindings.name.text);
       }
     }
@@ -8511,11 +8677,11 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   function checkForReactive(n) {
     if (hasReactiveCall)
       return;
-    if (ts10.isCallExpression(n) && ts10.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
+    if (ts11.isCallExpression(n) && ts11.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
       hasReactiveCall = true;
       return;
     }
-    ts10.forEachChild(n, checkForReactive);
+    ts11.forEachChild(n, checkForReactive);
   }
   checkForReactive(node.body);
   if (!hasReactiveCall)
@@ -8523,29 +8689,29 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   const loc = getSourceLocation(node, sourceFile, filePath);
   let totalReturnCount = 0;
   function countReturns(n) {
-    if (ts10.isFunctionLike(n))
+    if (ts11.isFunctionLike(n))
       return;
-    if (ts10.isReturnStatement(n)) {
+    if (ts11.isReturnStatement(n)) {
       totalReturnCount++;
       return;
     }
-    ts10.forEachChild(n, countReturns);
+    ts11.forEachChild(n, countReturns);
   }
-  ts10.forEachChild(node.body, countReturns);
+  ts11.forEachChild(node.body, countReturns);
   let returnExpr = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
-    if (!ts10.isReturnStatement(stmt))
+    if (!ts11.isReturnStatement(stmt))
       continue;
     returnCount++;
     if (!stmt.expression)
       return { kind: "reactive-shaped" };
     let expr = stmt.expression;
-    while (ts10.isParenthesizedExpression(expr))
+    while (ts11.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts10.isAsExpression(expr))
+    if (ts11.isAsExpression(expr))
       expr = expr.expression;
-    if (ts10.isTypeAssertionExpression(expr))
+    if (ts11.isTypeAssertionExpression(expr))
       expr = expr.expression;
     returnExpr = expr;
   }
@@ -8553,18 +8719,18 @@ function detectReactiveFactory(node, sourceFile, filePath) {
     return { kind: "reactive-shaped" };
   const returnTupleIdentifiers = [];
   let returnKind;
-  if (ts10.isArrayLiteralExpression(returnExpr)) {
+  if (ts11.isArrayLiteralExpression(returnExpr)) {
     returnKind = "tuple";
     for (const el of returnExpr.elements) {
-      if (!ts10.isIdentifier(el))
+      if (!ts11.isIdentifier(el))
         return { kind: "reactive-shaped" };
       returnTupleIdentifiers.push(el.text);
     }
     if (returnTupleIdentifiers.length === 0)
       return { kind: "reactive-shaped" };
-  } else if (ts10.isObjectLiteralExpression(returnExpr)) {
+  } else if (ts11.isObjectLiteralExpression(returnExpr)) {
     returnKind = "object";
-    const hasNonShorthand = returnExpr.properties.some((p) => !ts10.isShorthandPropertyAssignment(p));
+    const hasNonShorthand = returnExpr.properties.some((p) => !ts11.isShorthandPropertyAssignment(p));
     if (hasNonShorthand) {
       return {
         kind: "declined",
@@ -8585,7 +8751,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   }
   const params = [];
   for (const p of node.parameters) {
-    if (ts10.isIdentifier(p.name)) {
+    if (ts11.isIdentifier(p.name)) {
       params.push(p.name.text);
       continue;
     }
@@ -8593,11 +8759,11 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   }
   const localBindings = [];
   for (const stmt of node.body.statements) {
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
         addBindingNames(decl.name, localBindings);
       }
-    } else if (ts10.isFunctionDeclaration(stmt) && stmt.name) {
+    } else if (ts11.isFunctionDeclaration(stmt) && stmt.name) {
       localBindings.push(stmt.name.text);
     }
   }
@@ -8617,47 +8783,47 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       if (!relevantNames.has(id.text))
         return;
       const p = id.parent;
-      if (ts10.isPropertyAccessExpression(p) && p.name === id)
+      if (ts11.isPropertyAccessExpression(p) && p.name === id)
         return;
-      if (ts10.isPropertyAssignment(p) && p.name === id)
+      if (ts11.isPropertyAssignment(p) && p.name === id)
         return;
-      if (ts10.isBindingElement(p) && p.propertyName === id)
+      if (ts11.isBindingElement(p) && p.propertyName === id)
         return;
-      if ((ts10.isMethodDeclaration(p) || ts10.isGetAccessorDeclaration(p) || ts10.isSetAccessorDeclaration(p) || ts10.isPropertyDeclaration(p) || ts10.isEnumMember(p)) && p.name === id)
+      if ((ts11.isMethodDeclaration(p) || ts11.isGetAccessorDeclaration(p) || ts11.isSetAccessorDeclaration(p) || ts11.isPropertyDeclaration(p) || ts11.isEnumMember(p)) && p.name === id)
         return;
-      if (ts10.isJsxAttribute(p) && p.name === id)
+      if (ts11.isJsxAttribute(p) && p.name === id)
         return;
-      if (ts10.isLabeledStatement(p) && p.label === id || (ts10.isBreakStatement(p) || ts10.isContinueStatement(p)) && p.label === id)
+      if (ts11.isLabeledStatement(p) && p.label === id || (ts11.isBreakStatement(p) || ts11.isContinueStatement(p)) && p.label === id)
         return;
-      if ((ts10.isJsxOpeningElement(p) || ts10.isJsxSelfClosingElement(p) || ts10.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
+      if ((ts11.isJsxOpeningElement(p) || ts11.isJsxSelfClosingElement(p) || ts11.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
         return;
-      if (ts10.isShorthandPropertyAssignment(p) && p.name === id) {
+      if (ts11.isShorthandPropertyAssignment(p) && p.name === id) {
         push(id, "shorthand");
         return;
       }
-      if (ts10.isBindingElement(p) && p.name === id && !p.propertyName && ts10.isObjectBindingPattern(p.parent)) {
+      if (ts11.isBindingElement(p) && p.name === id && !p.propertyName && ts11.isObjectBindingPattern(p.parent)) {
         if (params.includes(id.text))
           shadowedParam = id.text;
         push(id, "shorthand");
         return;
       }
-      const isDecl = (ts10.isVariableDeclaration(p) || ts10.isParameter(p) || ts10.isBindingElement(p) || ts10.isFunctionDeclaration(p) || ts10.isFunctionExpression(p) || ts10.isClassDeclaration(p) || ts10.isClassExpression(p)) && p.name === id;
+      const isDecl = (ts11.isVariableDeclaration(p) || ts11.isParameter(p) || ts11.isBindingElement(p) || ts11.isFunctionDeclaration(p) || ts11.isFunctionExpression(p) || ts11.isClassDeclaration(p) || ts11.isClassExpression(p)) && p.name === id;
       if (isDecl && params.includes(id.text))
         shadowedParam = id.text;
       push(id, "plain");
     }
     function visit2(n) {
-      if (ts10.isTypeNode(n) || ts10.isTypeParameterDeclaration(n) || ts10.isTypeAliasDeclaration(n) || ts10.isInterfaceDeclaration(n))
+      if (ts11.isTypeNode(n) || ts11.isTypeParameterDeclaration(n) || ts11.isTypeAliasDeclaration(n) || ts11.isInterfaceDeclaration(n))
         return;
-      if (ts10.isIdentifier(n)) {
+      if (ts11.isIdentifier(n)) {
         classify(n);
         return;
       }
-      ts10.forEachChild(n, visit2);
+      ts11.forEachChild(n, visit2);
     }
     visit2(root);
   }
-  const keptStatements = node.body.statements.filter((s) => !ts10.isReturnStatement(s));
+  const keptStatements = node.body.statements.filter((s) => !ts11.isReturnStatement(s));
   const pieces = [];
   let base = 0;
   for (const stmt of keptStatements) {
@@ -8705,18 +8871,18 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   };
 }
 function addBindingNames(name, out) {
-  if (ts10.isIdentifier(name)) {
+  if (ts11.isIdentifier(name)) {
     out.push(name.text);
     return;
   }
-  if (ts10.isObjectBindingPattern(name)) {
+  if (ts11.isObjectBindingPattern(name)) {
     for (const el of name.elements)
       addBindingNames(el.name, out);
     return;
   }
-  if (ts10.isArrayBindingPattern(name)) {
+  if (ts11.isArrayBindingPattern(name)) {
     for (const el of name.elements) {
-      if (ts10.isOmittedExpression(el))
+      if (ts11.isOmittedExpression(el))
         continue;
       addBindingNames(el.name, out);
     }
@@ -8728,33 +8894,33 @@ function rewriteFactoryCallsInSource(source, prescan) {
   let callSiteIndex = 0;
   const inlinedFactories = new Set;
   function visitStmt(node, inComponent) {
-    if (ts10.isVariableStatement(node) && inComponent) {
+    if (ts11.isVariableStatement(node) && inComponent) {
       for (const decl of node.declarationList.declarations) {
         maybeRewriteDecl(node, decl);
       }
     }
-    ts10.forEachChild(node, (child) => {
-      if (ts10.isFunctionDeclaration(child) && child.name && factories.has(child.name.text))
+    ts11.forEachChild(node, (child) => {
+      if (ts11.isFunctionDeclaration(child) && child.name && factories.has(child.name.text))
         return;
       visitStmt(child, inComponent || isPascalCaseComponentFn(child));
     });
   }
   function maybeRewriteDecl(stmt, decl) {
-    if (!decl.initializer || !ts10.isCallExpression(decl.initializer))
+    if (!decl.initializer || !ts11.isCallExpression(decl.initializer))
       return;
-    if (!ts10.isIdentifier(decl.initializer.expression))
+    if (!ts11.isIdentifier(decl.initializer.expression))
       return;
     const factoryName = decl.initializer.expression.text;
     const factory = factories.get(factoryName);
     if (!factory)
       return;
-    if (ts10.isArrayBindingPattern(decl.name)) {
+    if (ts11.isArrayBindingPattern(decl.name)) {
       if (factory.returnKind !== "tuple")
         return;
       rewriteTupleDecl(stmt, decl.name, decl.initializer, factory);
       return;
     }
-    if (ts10.isObjectBindingPattern(decl.name)) {
+    if (ts11.isObjectBindingPattern(decl.name)) {
       if (factory.returnKind !== "object")
         return;
       rewriteObjectDecl(stmt, decl.name, decl.initializer, factory);
@@ -8767,7 +8933,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
       return;
     const callerNames = [];
     for (const el of elements) {
-      if (ts10.isOmittedExpression(el) || !ts10.isIdentifier(el.name))
+      if (ts11.isOmittedExpression(el) || !ts11.isIdentifier(el.name))
         return;
       callerNames.push(el.name.text);
     }
@@ -8789,7 +8955,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
         return;
       if (el.initializer)
         return;
-      if (!ts10.isIdentifier(el.name))
+      if (!ts11.isIdentifier(el.name))
         return;
       if (!factory.returnTupleIdentifiers.includes(el.name.text))
         return;
@@ -8898,21 +9064,21 @@ function factoryImportInsertionOffset(sf) {
   let lastImportEnd = -1;
   let directiveEnd = -1;
   for (const stmt of sf.statements) {
-    if (ts10.isImportDeclaration(stmt)) {
+    if (ts11.isImportDeclaration(stmt)) {
       lastImportEnd = stmt.getEnd();
       continue;
     }
-    if (directiveEnd === -1 && ts10.isExpressionStatement(stmt) && ts10.isStringLiteral(stmt.expression) && stmt.expression.text === "use client") {
+    if (directiveEnd === -1 && ts11.isExpressionStatement(stmt) && ts11.isStringLiteral(stmt.expression) && stmt.expression.text === "use client") {
       directiveEnd = stmt.getEnd();
     }
   }
   return lastImportEnd >= 0 ? lastImportEnd : directiveEnd >= 0 ? directiveEnd : 0;
 }
 function isPascalCaseComponentFn(node) {
-  if (ts10.isFunctionDeclaration(node) && node.name) {
+  if (ts11.isFunctionDeclaration(node) && node.name) {
     return /^[A-Z]/.test(node.name.text);
   }
-  if (ts10.isVariableDeclaration(node) && ts10.isIdentifier(node.name) && node.initializer && ts10.isArrowFunction(node.initializer)) {
+  if (ts11.isVariableDeclaration(node) && ts11.isIdentifier(node.name) && node.initializer && ts11.isArrowFunction(node.initializer)) {
     return /^[A-Z]/.test(node.name.text);
   }
   return false;
@@ -8941,20 +9107,20 @@ function declinedFactoryErrorCode(code) {
 function validateReactiveFactoryCalls(ctx) {
   if (!ctx.componentNode)
     return;
-  const body = ts10.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts10.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
+  const body = ts11.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts11.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
   if (!body)
     return;
   for (const stmt of body.statements) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts10.isCallExpression(decl.initializer))
+      if (!decl.initializer || !ts11.isCallExpression(decl.initializer))
         continue;
-      if (!ts10.isIdentifier(decl.initializer.expression))
+      if (!ts11.isIdentifier(decl.initializer.expression))
         continue;
       const callee = decl.initializer.expression.text;
       const loc = getSourceLocation(stmt, ctx.sourceFile, ctx.filePath);
-      if (ts10.isArrayBindingPattern(decl.name)) {
+      if (ts11.isArrayBindingPattern(decl.name)) {
         if (callee === "createSignal" || callee === "createMemo")
           continue;
         if (resolveEnvSignalKey(decl.initializer, ctx))
@@ -8981,7 +9147,7 @@ function validateReactiveFactoryCalls(ctx) {
         }));
         continue;
       }
-      if (ts10.isObjectBindingPattern(decl.name)) {
+      if (ts11.isObjectBindingPattern(decl.name)) {
         validateObjectFactoryDestructure(ctx, decl.name, callee, loc);
       }
     }
@@ -8990,25 +9156,25 @@ function validateReactiveFactoryCalls(ctx) {
 function validateNamespaceQualifiedPrimitives(ctx) {
   if (!ctx.componentNode)
     return;
-  const body = ts10.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts10.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
+  const body = ts11.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts11.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
   if (!body)
     return;
   for (const stmt of body.statements) {
     const calls = [];
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
         let init = decl.initializer;
-        if (init && ts10.isElementAccessExpression(init))
+        if (init && ts11.isElementAccessExpression(init))
           init = init.expression;
-        if (init && ts10.isCallExpression(init))
+        if (init && ts11.isCallExpression(init))
           calls.push(init);
       }
-    } else if (ts10.isExpressionStatement(stmt) && ts10.isCallExpression(stmt.expression)) {
+    } else if (ts11.isExpressionStatement(stmt) && ts11.isCallExpression(stmt.expression)) {
       calls.push(stmt.expression);
     }
     for (const call of calls) {
       const callee = call.expression;
-      if (!ts10.isPropertyAccessExpression(callee) || !ts10.isIdentifier(callee.expression))
+      if (!ts11.isPropertyAccessExpression(callee) || !ts11.isIdentifier(callee.expression))
         continue;
       const primitive = callee.name.text;
       if (!(primitive in PRIMITIVE_CANONICAL_NAMES))
@@ -9041,11 +9207,11 @@ function isNamespaceNameShadowedAtComponentTopLevel(name, body, ctx) {
   if (ctx.propsParams.some((p) => p.name === name))
     return true;
   for (const stmt of body.statements) {
-    if (ts10.isFunctionDeclaration(stmt) && stmt.name?.text === name)
+    if (ts11.isFunctionDeclaration(stmt) && stmt.name?.text === name)
       return true;
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
-        if (ts10.isIdentifier(decl.name) && decl.name.text === name)
+        if (ts11.isIdentifier(decl.name) && decl.name.text === name)
           return true;
       }
     }
@@ -9062,7 +9228,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
       }));
       return;
     }
-    const hasUnsupportedElement = pattern.elements.some((el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts10.isIdentifier(el.name));
+    const hasUnsupportedElement = pattern.elements.some((el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts11.isIdentifier(el.name));
     if (hasUnsupportedElement) {
       ctx.errors.push(createError(ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED, loc, {
         severity: "error",
@@ -9070,7 +9236,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
       }));
       return;
     }
-    const unknown = pattern.elements.map((el) => ts10.isIdentifier(el.name) ? el.name.text : "").filter((name) => name && !factory.returnTupleIdentifiers.includes(name));
+    const unknown = pattern.elements.map((el) => ts11.isIdentifier(el.name) ? el.name.text : "").filter((name) => name && !factory.returnTupleIdentifiers.includes(name));
     if (unknown.length > 0) {
       const label = unknown.length === 1 ? "property" : "properties";
       ctx.errors.push(createError(ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY, loc, {
@@ -9213,7 +9379,7 @@ function pickAttrMetaFromIR(src) {
 }
 // ../jsx/src/module-exports.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function generateModuleExports(ir, extraInlineExported = new Set, rewriteRelativeImport, options) {
   const lines = [];
   for (const constant of options?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -9314,21 +9480,21 @@ function findAssignedNames(bodyText, candidates) {
   const assigned = new Set;
   if (candidates.size === 0)
     return assigned;
-  const sf = ts11.createSourceFile("bf-assignment-scan.tsx", bodyText, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
+  const sf = ts12.createSourceFile("bf-assignment-scan.tsx", bodyText, ts12.ScriptTarget.Latest, false, ts12.ScriptKind.TSX);
   const record = (target) => {
-    if (ts11.isIdentifier(target) && candidates.has(target.text)) {
+    if (ts12.isIdentifier(target) && candidates.has(target.text)) {
       assigned.add(target.text);
     }
   };
   const visit2 = (node) => {
-    if (ts11.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts12.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       record(node.left);
-    } else if ((ts11.isPrefixUnaryExpression(node) || ts11.isPostfixUnaryExpression(node)) && (node.operator === ts11.SyntaxKind.PlusPlusToken || node.operator === ts11.SyntaxKind.MinusMinusToken)) {
+    } else if ((ts12.isPrefixUnaryExpression(node) || ts12.isPostfixUnaryExpression(node)) && (node.operator === ts12.SyntaxKind.PlusPlusToken || node.operator === ts12.SyntaxKind.MinusMinusToken)) {
       record(node.operand);
     }
-    ts11.forEachChild(node, visit2);
+    ts12.forEachChild(node, visit2);
   };
-  ts11.forEachChild(sf, visit2);
+  ts12.forEachChild(sf, visit2);
   return assigned;
 }
 function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
@@ -9351,7 +9517,7 @@ function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNam
   return reachable;
 }
 function isAssignmentOperator(kind) {
-  return kind >= ts11.SyntaxKind.FirstAssignment && kind <= ts11.SyntaxKind.LastAssignment;
+  return kind >= ts12.SyntaxKind.FirstAssignment && kind <= ts12.SyntaxKind.LastAssignment;
 }
 // ../jsx/src/builtins.ts
@@ -9374,102 +9540,6 @@ function stripClientBuiltinImports(imports) {
   return result;
 }
-// ../jsx/src/reactivity-checker.ts
-import ts12 from "typescript";
-var REACTIVE_BRAND = "__reactive";
-function queryType(checker, node) {
-  incrementCounter("typeCheckerQueries");
-  return checker.getTypeAtLocation(node);
-}
-function isReactiveType(type) {
-  return type.getProperty(REACTIVE_BRAND) !== undefined;
-}
-var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
-function safeGetText(node) {
-  try {
-    return node.getText();
-  } catch {
-    return "";
-  }
-}
-function analyze(node, checker) {
-  if (ts12.isPropertyAccessExpression(node)) {
-    try {
-      const type = queryType(checker, node);
-      if (isReactiveType(type)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {}
-    const sub = analyze(node.expression, checker);
-    if (sub.isReactive) {
-      return {
-        isReactive: true,
-        reason: {
-          kind: "child",
-          via: "property-access-object",
-          childText: safeGetText(node.expression),
-          childReason: sub.reason
-        }
-      };
-    }
-    return NOT_REACTIVE;
-  }
-  if (ts12.isIdentifier(node)) {
-    try {
-      const type = queryType(checker, node);
-      if (isReactiveType(type)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "identifier", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {}
-    return NOT_REACTIVE;
-  }
-  if (ts12.isCallExpression(node)) {
-    try {
-      const calleeType = queryType(checker, node.expression);
-      if (isReactiveType(calleeType)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "callee", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {}
-  }
-  let foundChild;
-  let foundChildText = "";
-  ts12.forEachChild(node, (child) => {
-    if (foundChild?.isReactive)
-      return;
-    const result = analyze(child, checker);
-    if (result.isReactive) {
-      foundChild = result;
-      foundChildText = safeGetText(child);
-    }
-  });
-  if (foundChild?.isReactive) {
-    return {
-      isReactive: true,
-      reason: {
-        kind: "child",
-        via: "sub-expression",
-        childText: foundChildText,
-        childReason: foundChild.reason
-      }
-    };
-  }
-  return NOT_REACTIVE;
-}
-var brandTypeReactivityAnalyzer = { analyze };
-function containsReactiveExpression(node, checker) {
-  incrementCounter("reactivityChecks");
-  return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive;
-}
 // ../jsx/src/free-refs.ts
 import ts13 from "typescript";
 var _bindingMapCache = new WeakMap;
@@ -10213,9 +10283,8 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
   function visit2(n, parent) {
     if (ts14.isIdentifier(n) && propDepsMap.has(n.text)) {
       const isObjectKey = parent && ts14.isPropertyAssignment(parent) && parent.name === n;
-      const isShorthand = parent && ts14.isShorthandPropertyAssignment(parent) && parent.name === n;
       const isAccessName = parent && ts14.isPropertyAccessExpression(parent) && parent.name === n;
-      if (!isObjectKey && !isShorthand && !isAccessName) {
+      if (!isObjectKey && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
           if (!acc)
@@ -10693,8 +10762,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
     children.push({
       type: "expression",
       expr,
-      templateExpr: `escapeText(${templateExpr ?? expr})`,
-      escapeInClientTemplate: true,
+      templateExpr,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -10705,26 +10773,76 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
   }
   const selectedForLiteral = (optValue) => AttrValueOf.expression(`(${expr}) === ${JSON.stringify(optValue)}`, templateExpr !== undefined ? { templateExpr: `(${templateExpr}) === ${JSON.stringify(optValue)}` } : undefined);
   const selectedForExpr = (optExpr, optTemplateExpr) => AttrValueOf.expression(`(${expr}) === (${optExpr})`, templateExpr !== undefined || optTemplateExpr !== undefined ? { templateExpr: `(${templateExpr ?? expr}) === (${optTemplateExpr ?? optExpr})` } : undefined);
+  const matchConditions = [];
+  let optionSetIsDynamic = false;
   const distribute = (nodes) => {
     for (const n of nodes) {
+      if (n.type === "text")
+        continue;
       if (n.type === "element" && n.tag === "option") {
-        if (n.attrs.some((a) => a.name === "selected"))
+        if (n.attrs.some((a) => a.name === "selected")) {
+          optionSetIsDynamic = true;
           continue;
+        }
         const optValue = n.attrs.find((a) => a.name === "value");
-        if (!optValue)
+        if (!optValue) {
+          optionSetIsDynamic = true;
           continue;
+        }
         if (optValue.value.kind === "literal") {
-          n.attrs.push({ name: "selected", value: selectedForLiteral(optValue.value.value), loc: n.loc });
+          const selected = selectedForLiteral(optValue.value.value);
+          n.attrs.push({ name: "selected", value: selected, loc: n.loc });
+          matchConditions.push(selected);
         } else if (optValue.value.kind === "expression") {
           const selected = selectedForExpr(optValue.value.expr, optValue.value.templateExpr);
           n.attrs.push({ name: "selected", value: selected, loc: n.loc });
+          matchConditions.push(selected);
+        } else {
+          optionSetIsDynamic = true;
         }
-      } else if (n.type === "fragment" || n.type === "loop" || n.type === "element" && n.tag === "optgroup") {
+      } else if (n.type === "fragment" || n.type === "element" && n.tag === "optgroup") {
         distribute(n.children);
+      } else if (n.type === "loop") {
+        optionSetIsDynamic = true;
+        distribute(n.children);
+      } else {
+        optionSetIsDynamic = true;
       }
     }
   };
   distribute(children);
+  if (optionSetIsDynamic || matchConditions.length === 0)
+    return;
+  if (isMultiSelection(attrs))
+    return;
+  const orExpr = matchConditions.map((c) => `(${c.expr})`).join(" || ");
+  const orTemplateExpr = matchConditions.some((c) => c.templateExpr !== undefined) ? matchConditions.map((c) => `(${c.templateExpr ?? c.expr})`).join(" || ") : undefined;
+  children.unshift({
+    type: "element",
+    tag: "option",
+    attrs: [
+      { name: "value", value: AttrValueOf.literal(""), loc: valueAttr.loc },
+      { name: "disabled", value: AttrValueOf.booleanAttr(), loc: valueAttr.loc },
+      { name: "hidden", value: AttrValueOf.booleanAttr(), loc: valueAttr.loc },
+      {
+        name: "selected",
+        value: AttrValueOf.expression(`!(${orExpr})`, orTemplateExpr !== undefined ? { templateExpr: `!(${orTemplateExpr})` } : undefined),
+        loc: valueAttr.loc
+      }
+    ],
+    events: [],
+    ref: null,
+    children: [],
+    slotId: null,
+    needsScope: false,
+    loc: valueAttr.loc
+  });
+}
+function isMultiSelection(attrs) {
+  if (attrs.some((a) => a.name === "multiple"))
+    return true;
+  const sizeAttr = attrs.find((a) => a.name === "size");
+  return sizeAttr?.value.kind === "literal" && Number(sizeAttr.value.value) > 1;
 }
 function transformHtmlElement(node, ctx, tagName) {
   const { attrs, events, ref } = processAttributes(node.openingElement.attributes, ctx);
@@ -11098,7 +11216,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   }
   const ir = transformJsxExpression(expr, ctx, isClientOnly);
   if (ir !== null) {
-    if ((isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx)) && ir.type === "conditional") {
+    if (ir.type === "conditional" && (isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx))) {
       ir.clientOnly = true;
       if (!ir.slotId) {
         ir.slotId = generateSlotId(ctx);
@@ -14045,9 +14163,10 @@ function shouldAutoDeferReactiveBrand(expr, ctx) {
   const checker = ctx.analyzer.checker;
   if (!checker)
     return false;
-  if (!containsReactiveExpression(expr, checker))
+  const leaves = collectReactiveBrandLeaves(expr, checker);
+  if (leaves.length === 0)
     return false;
-  if (isSignalOrMemoReference(ctx.getJS(expr), ctx))
+  if (leaves.some((leaf) => isSignalOrMemoReference(ctx.getJS(leaf), ctx)))
     return false;
   return true;
 }
@@ -14430,10 +14549,10 @@ function getControlledPropName(signal, propsParams, propsObjectName = null) {
 }
 // ../jsx/src/ir-to-client-js/reactivity.ts
-function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex) {
+function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope) {
   if (!loopParam)
     return;
-  return BindingScope.EMPTY.enterLoopRow({
+  return (parentScope ?? BindingScope.EMPTY).enterLoopRow({
     param: loopParam,
     paramBindings: loopParamBindings,
     index: loopIndex,
@@ -14507,16 +14626,22 @@ function needsEffectWrapperCore(expr, ctx, freeIdentifiers2, visitedConstants) {
   }
   return false;
 }
-function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentifiers2) {
+function classifyReactivity(expr, ctx, scope, freeIdentifiers2) {
   const has = (name) => freeIdentifiers2 ? freeIdentifiers2.has(name) : tokenContainsIdent(expr, name);
-  if (loopParamBindings && loopParamBindings.length > 0) {
-    for (const b of loopParamBindings) {
-      if (has(b.name)) {
-        return { kind: "loop-param", param: loopParam ?? b.name };
+  if (scope) {
+    let indexHit;
+    for (const name of scope.valueBoundNames()) {
+      if (!has(name))
+        continue;
+      const source = scope.lookup(name)?.binding.source;
+      if (source === "index") {
+        indexHit ??= name;
+        continue;
       }
+      return { kind: "loop-param", param: name };
     }
-  } else if (loopParam && has(loopParam)) {
-    return { kind: "loop-param", param: loopParam };
+    if (indexHit)
+      return { kind: "loop-index", param: indexHit };
   }
   if (needsEffectWrapper(expr, ctx, freeIdentifiers2)) {
     return { kind: "signal-or-memo-or-prop" };
@@ -14679,9 +14804,9 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex, parentScope) {
   const texts = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
   walkIR(node, false, {
     ...stopAt("loop", "async", "ifStatement"),
     expression: ({ node: n, scope: insideConditional }) => {
@@ -14691,7 +14816,7 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings,
         return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds, scope);
-      const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
+      const reactive = classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
       if (!reactive)
         return;
       texts.push({
@@ -14714,9 +14839,9 @@ function anyNameIn(names, set) {
       return true;
   return false;
 }
-function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex, parentScope) {
   const attrs = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
   traverseElements(node, (el) => {
     if (el.slotId) {
       for (const attr of el.attrs) {
@@ -14731,7 +14856,7 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings,
           continue;
         const expanded = expandConstantForReactivity(valueStr, ctx, attr.freeIdentifiers, scope);
         const readsPreamble = preambleNames !== undefined && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
-        const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
+        const reactive = classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive)
           continue;
         attrs.push({
@@ -15070,7 +15195,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
   const flat = options?.flatBranchMode === true;
   const fixedDepth = options?.templateDepth;
   const collectBindings = options?.collectItemBindings === true;
-  const initialScope = { parentSlotId: null, depth: 0, insideCond: false };
+  const outerSpec = typeof outerLoopParam === "string" ? { param: outerLoopParam } : outerLoopParam;
+  const outerScope = buildLoopRowScope(outerSpec?.param, outerSpec?.bindings, undefined, outerSpec?.index);
+  const initialScope = { parentSlotId: null, depth: 0, insideCond: false, bindingScope: outerScope };
   for (const root of nodes) {
     walkIR(root, initialScope, {
       element: ({ node: el, scope, descend }) => {
@@ -15086,18 +15213,17 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
       },
       loop: ({ node: n, scope, descend }) => {
         const emitDepth = fixedDepth ?? scope.depth + 1;
-        const loopParamsForTemplate = outerLoopParam ? [outerLoopParam, { param: n.param, bindings: n.paramBindings }] : undefined;
+        const loopParamsForTemplate = outerSpec ? [outerSpec, { param: n.param, bindings: n.paramBindings, index: n.index }] : undefined;
         const template = n.children.map((c) => irToPlaceholderTemplate(c, undefined, emitDepth, loopParamsForTemplate)).join("");
-        const refsOuter = outerLoopParam ? identifierPattern(outerLoopParam).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
         const innerPreambleNames = preambleNamesOf(n);
         if (ctx) {
           for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index));
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
-          bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings, innerPreambleNames, n.index));
+          bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings, innerPreambleNames, n.index, loopParamsForTemplate, scope.bindingScope));
         }
         let childComponents;
         if (collectBindings) {
@@ -15139,14 +15265,17 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
           containerSlotId: scope.parentSlotId,
           template,
           preamble: n.preamble,
-          refsOuterParam: refsOuter,
           childComponents,
           insideConditional: !flat && scope.insideCond ? true : undefined,
           offset: flat ? undefined : resolveLoopOffset(siblingOffsets.get(n)),
           bindings
         });
         if (!flat) {
-          descend({ ...scope, depth: scope.depth + 1 });
+          descend({
+            ...scope,
+            depth: scope.depth + 1,
+            bindingScope: buildLoopRowScope(n.param, n.paramBindings, innerPreambleNames, n.index, scope.bindingScope)
+          });
         }
       }
     });
@@ -15155,7 +15284,7 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
 }
 function decideLoopRendering(loop, siblingOffsets, ctx) {
   const hasNestedComps = (loop.nestedComponents?.length ?? 0) > 0;
-  const innerLoops = collectInnerLoops(loop.children, siblingOffsets, loop.param, ctx);
+  const innerLoops = collectInnerLoops(loop.children, siblingOffsets, { param: loop.param, bindings: loop.paramBindings, index: loop.index }, ctx);
   const hasInnerLoops = (innerLoops?.length ?? 0) > 0;
   const useElementReconciliation = !loop.childComponent && !loop.isStaticArray && (hasNestedComps || hasInnerLoops);
   return { useElementReconciliation, innerLoops };
@@ -15323,6 +15452,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       }
       const { useElementReconciliation, innerLoops } = projectionInner ? { useElementReconciliation: false, innerLoops: undefined } : decideLoopRendering(l, siblingOffsets, ctx);
       let template = "";
+      let templateIndexed;
       let staticItemTemplate;
       let skeletonTemplate;
       let skeletonPaths;
@@ -15334,6 +15464,10 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
         template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec);
+        if (l.index) {
+          const loopParamSpecIndexed = [{ param: l.param, bindings: l.paramBindings, index: l.index }];
+          templateIndexed = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpecIndexed) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpecIndexed);
+        }
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0);
         } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
@@ -15362,6 +15496,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         iterationShape: l.iterationShape,
         objectIteration: l.objectIteration,
         template,
+        templateIndexed,
         staticItemTemplate,
         skeletonTemplate,
         skeletonPaths,
@@ -15552,6 +15687,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       const projectionInner = n.method === "flatMap" && n.children.length === 1 && n.children[0].type === "loop" ? n.children[0] : undefined;
       const { useElementReconciliation, innerLoops: innerLoopsCollected } = projectionInner ? { useElementReconciliation: false, innerLoops: undefined } : decideLoopRendering(n, siblingOffsets, undefined);
       let childTemplate;
+      let childTemplateIndexed;
       const branchLoopParamSpec = [{ param: n.param, bindings: n.paramBindings }];
       if (projectionInner) {
         childTemplate = "";
@@ -15560,6 +15696,10 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, undefined, 0, branchLoopParamSpec)).join("");
       }
+      if (n.index && !projectionInner) {
+        const branchLoopParamSpecIndexed = [{ param: n.param, bindings: n.paramBindings, index: n.index }];
+        childTemplateIndexed = useElementReconciliation && n.children[0] ? irToPlaceholderTemplate(n.children[0], restNames, 0, branchLoopParamSpecIndexed) : n.children.map((c) => irToHtmlTemplate(c, undefined, 0, branchLoopParamSpecIndexed)).join("");
+      }
       const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n), n.index) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
@@ -15575,6 +15715,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
         iterationShape: n.iterationShape,
         objectIteration: n.objectIteration,
         template: childTemplate,
+        templateIndexed: childTemplateIndexed,
         containerSlotId: containerSlot,
         preamble: n.preamble,
         preambleRegions: n.preambleRegions,
@@ -15657,19 +15798,10 @@ function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loop
   }
   return bindings;
 }
-function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
+function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex, loopParams, parentScope) {
   const conditionals = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
-  const refsAnyBindingViaFreeIds = (freeIds) => {
-    if (loopParamBindings && loopParamBindings.length > 0) {
-      for (const b of loopParamBindings) {
-        if (freeIds.has(b.name))
-          return true;
-      }
-      return false;
-    }
-    return loopParam ? freeIds.has(loopParam) : false;
-  };
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
+  const refsAnyBindingViaFreeIds = (freeIds) => scope !== undefined && anyNameIn(scope.valueBoundNames(), freeIds);
   walkIR(node, null, {
     ...stopAt("loop", "async", "ifStatement"),
     conditional: ({ node: n }) => {
@@ -15681,9 +15813,9 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
         return;
       const expanded = expandConstantForReactivity(n.condition, ctx, sourceFreeIds, scope);
       const readsPreamble = preambleNames !== undefined && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
-      if (!readsPreamble && classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === "none")
+      if (!readsPreamble && classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind === "none")
         return;
-      const loopParamsForCond = loopParam ? [{ param: loopParam, bindings: loopParamBindings }] : undefined;
+      const loopParamsForCond = loopParams ?? (loopParam ? [{ param: loopParam, bindings: loopParamBindings, index: loopIndex }] : undefined);
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, undefined, 0, loopParamsForCond, "__slots");
       const whenFalseHtml = irToHtmlTemplate(n.whenFalse, undefined, 0, loopParamsForCond, "__slots");
       conditionals.push({
@@ -15701,7 +15833,7 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
   return conditionals;
 }
 function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
-  const inner = collectInnerLoops([node], siblingOffsets, loopParam, ctx, branchInnerLoopOptions);
+  const inner = collectInnerLoops([node], siblingOffsets, loopParam ? { param: loopParam, bindings: loopParamBindings, index: loopIndex } : undefined, ctx, branchInnerLoopOptions);
   return {
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : undefined,
@@ -16267,6 +16399,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeAttr",
   "escapeText",
   "escapeTextOrNode",
+  "escapeCommentText",
   "bfMarkup",
   "escapeTextOrMarkup",
   "markupOrEmpty",
@@ -17326,7 +17459,7 @@ function emitRegistrationAndHydration(lines, ctx, _ir, graph, inlinability) {
   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));
+    const markupSlotIds = markupSlotIdsOf(ctx);
     const templateHtml = irToComponentTemplate(_ir.root, inlinableConstants, restSpreadNames, ctx.propsObjectName, markupSlotIds, ctx.restPropsName);
     if (templateHtml) {
       defParts.push(buildTemplateDefPart(ctx, templateHtml));
@@ -18326,12 +18459,12 @@ function nestedLoopIndexAlias(inner, syntheticIndexVar, paramHead, comps, events
     return null;
   return `const ${index} = ${syntheticIndexVar}`;
 }
-function buildChildRefBindings(refs, loopParam, loopParamBindings) {
+function buildChildRefBindings(refs, loopParam, loopParamBindings, loopIndex) {
   if (refs.length === 0)
     return [];
   return refs.map((r) => ({
     childSlotId: r.childSlotId,
-    callback: wrapLoopParamAsAccessor(r.callback, loopParam, loopParamBindings)
+    callback: wrapLoopParamAsAccessor(r.callback, loopParam, loopParamBindings, loopIndex)
   }));
 }
 function buildStaticChildRefBindings(refs) {
@@ -18364,17 +18497,17 @@ function destructureLoopParam(param, paramBindings) {
   }
   return { head: param, unwrap: "" };
 }
-function buildPreambleRegionPlans(regions, loopParam, loopParamBindings) {
+function buildPreambleRegionPlans(regions, loopParam, loopParamBindings, loopIndex) {
   if (!regions || regions.length === 0)
     return [];
   return regions.map((r) => {
-    const wrapped = wrapLoopParamAsAccessor(r.expr, loopParam, loopParamBindings);
-    const valueExpr = r.joinArrayChild ? `Array.isArray(${wrapped}) ? ${wrapped}.join('') : (${wrapped} ?? '')` : `escapeText(${wrapped})`;
+    const wrapped = wrapLoopParamAsAccessor(r.expr, loopParam, loopParamBindings, loopIndex);
+    const valueExpr = spliceChildValue({ expr: r.expr, slotId: r.slotId, joinArrayChild: r.joinArrayChild }, wrapped, {});
     return { slotId: r.slotId, valueExpr };
   });
 }
-function buildComponentPropsExpr2(comp, loopParam, loopParamBindings) {
-  const wrap = loopParam ? (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings) : (expr) => expr;
+function buildComponentPropsExpr2(comp, loopParam, loopParamBindings, loopIndex) {
+  const wrap = loopParam ? (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings, loopIndex) : (expr) => expr;
   const entries = comp.props.map((p) => {
     if (p.isEventHandler) {
       const handlerExpr = attrValueToString(p.value) ?? "undefined";
@@ -18418,8 +18551,8 @@ function buildDepthLevels(innerLoops, nestedComps, childEvents) {
     loopInfo: loop
   }));
 }
-function emitEventSetup(ls, indent, elVar, ev, loopParam, loopParamBindings, bodyIsMultiRoot = false) {
-  const handler = loopParam ? wrapLoopParamAsAccessor(ev.handler, loopParam, loopParamBindings) : ev.handler;
+function emitEventSetup(ls, indent, elVar, ev, loopParam, loopParamBindings, bodyIsMultiRoot = false, loopIndex) {
+  const handler = loopParam ? wrapLoopParamAsAccessor(ev.handler, loopParam, loopParamBindings, loopIndex) : ev.handler;
   emitListenerBlock(ls, indent, elVar, ev.childSlotId, "__e", ev.eventName, handler, "dom", bodyIsMultiRoot);
 }
 function buildCompSelector(comp) {
@@ -18431,15 +18564,15 @@ function isTextOnlyConditional(node) {
   const checkNode = (n) => n.type === "text" || n.type === "expression" || n.type === "conditional" && isTextOnlyConditional(n);
   return checkNode(node.whenTrue) && checkNode(node.whenFalse);
 }
-function emitComponentAndEventSetup(ls, indent, elVar, comps, events, loopParam, loopParamBindings, bodyIsMultiRoot = false) {
-  const wrap = loopParam ? (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings) : (expr) => expr;
+function emitComponentAndEventSetup(ls, indent, elVar, comps, events, loopParam, loopParamBindings, bodyIsMultiRoot = false, loopIndex) {
+  const wrap = loopParam ? (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings, loopIndex) : (expr) => expr;
   const upsertFn = bodyIsMultiRoot ? "upsertChildItem" : "upsertChild";
   for (const comp of comps) {
-    const propsExpr = buildComponentPropsExpr2(comp, loopParam, loopParamBindings);
+    const propsExpr = buildComponentPropsExpr2(comp, loopParam, loopParamBindings, loopIndex);
     const isTextOnly = comp.children?.length ? comp.children.every((c) => c.type === "expression" || c.type === "text" || isTextOnlyConditional(c)) : false;
     const rawChildrenExpr = isTextOnly ? irChildrenToJsExpr(comp.children) : null;
     const childrenFreeIds = isTextOnly && comp.children ? irChildrenFreeIds(comp.children) : undefined;
-    const childrenRefsLoop = loopParam != null && rawChildrenExpr != null && childrenFreeIds != null && exprRefsLoopBinding(childrenFreeIds, { param: loopParam, paramBindings: loopParamBindings });
+    const childrenRefsLoop = loopParam != null && rawChildrenExpr != null && childrenFreeIds != null && (exprRefsLoopBinding(childrenFreeIds, { param: loopParam, paramBindings: loopParamBindings }) || !!loopIndex && childrenFreeIds.has(loopIndex));
     const slotIdLit = comp.slotId ? `'${comp.slotId}'` : "null";
     const keyProp = comp.props.find((p) => p.name === "key");
     const keyArg = keyProp ? `, ${wrap(attrValueToString(keyProp.value) ?? "undefined")}` : ", undefined";
@@ -18452,7 +18585,7 @@ function emitComponentAndEventSetup(ls, indent, elVar, comps, events, loopParam,
     }
   }
   for (const ev of events) {
-    emitEventSetup(ls, indent, elVar, ev, loopParam, loopParamBindings, bodyIsMultiRoot);
+    emitEventSetup(ls, indent, elVar, ev, loopParam, loopParamBindings, bodyIsMultiRoot, loopIndex);
   }
 }
@@ -18823,6 +18956,7 @@ function buildBranchInnerLoopsPlan(args) {
     condSlotId,
     outerLoopParam,
     outerLoopParamBindings,
+    outerLoopIndex,
     wrapOuter
   } = args;
   if (!innerLoops || innerLoops.length === 0)
@@ -18830,14 +18964,14 @@ function buildBranchInnerLoopsPlan(args) {
   const plan = [];
   for (let i = 0;i < innerLoops.length; i++) {
     const inner = innerLoops[i];
-    if (!inner.refsOuterParam || !inner.template)
+    if (!inner.template)
       continue;
-    const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings);
-    const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings);
+    const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings, inner.index);
+    const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings, inner.index);
     const csl = inner.containerSlotId;
     const containerExpr = csl ? `(${scopeVar}.querySelector('[bf="${csl}"]') ?? ${scopeVar}.querySelector(\`[${BF_HOST}="\${__scopeId}"][${BF_AT}="${csl}"]\`) ?? ${scopeVar})` : `findCondContainer(${scopeVar}, '${condSlotId}')`;
     const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(inner.param, inner.paramBindings);
-    const wrappedKey = inner.key ? wrapLoopParamAsAccessor(inner.key, inner.param, inner.paramBindings) : null;
+    const wrappedKey = inner.key ? wrapLoopParamAsAccessor(inner.key, inner.param, inner.paramBindings, inner.index) : null;
     const wrapIRNode = (node) => {
       if (node.type === "component") {
         return {
@@ -18893,18 +19027,20 @@ function buildBranchInnerLoopsPlan(args) {
         scopeVar: `__belbr_${i}`,
         wrap: wrapBoth,
         loopParam: inner.param,
-        loopParamBindings: inner.paramBindings
+        loopParamBindings: inner.paramBindings,
+        loopIndex: inner.index
       }),
       innerLoopParam: inner.param,
       innerLoopParamBindings: inner.paramBindings,
       outerLoopParam,
-      outerLoopParamBindings
+      outerLoopParamBindings,
+      outerLoopIndex
     });
   }
   return plan;
 }
 function buildLoopChildConditionalsPlan(args) {
-  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings } = args;
+  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings, loopIndex } = args;
   if (!conditionals || conditionals.length === 0)
     return [];
   const plans = [];
@@ -18913,13 +19049,14 @@ function buildLoopChildConditionalsPlan(args) {
       slotId: cond.slotId,
       scopeVar,
       wrappedCondition: wrap(cond.condition),
-      whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-      whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
+      whenTrueTemplateHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+      whenFalseTemplateHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId),
       whenTrueArm: buildLoopChildArmPlan({
         branch: cond.whenTrue,
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
       }),
       whenFalseArm: buildLoopChildArmPlan({
@@ -18927,8 +19064,10 @@ function buildLoopChildConditionalsPlan(args) {
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
-      })
+      }),
+      ...cond.readsPreamble && { readsPreamble: true }
     });
   }
   return plans;
@@ -18952,7 +19091,8 @@ function buildArmAttrsPlan(attrs, wrap) {
       attrs: slotAttrs.map((attr) => ({
         attrName: attr.attrName,
         wrappedExpression: wrap(attr.expression),
-        meta: pickAttrMeta(attr)
+        meta: pickAttrMeta(attr),
+        ...attr.readsPreamble && { readsPreamble: true }
       }))
     });
   }
@@ -18967,7 +19107,7 @@ function buildArmTextsPlan(texts, wrap) {
   }));
 }
 function buildLoopChildArmPlan(args) {
-  const { branch, wrap, loopParam, loopParamBindings, condId } = args;
+  const { branch, wrap, loopParam, loopParamBindings, loopIndex, condId } = args;
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -18983,6 +19123,7 @@ function buildLoopChildArmPlan(args) {
       condSlotId: condId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -18990,7 +19131,8 @@ function buildLoopChildArmPlan(args) {
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -18999,8 +19141,8 @@ function buildLoopChildArmPlan(args) {
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-reactive-effects.ts
 function buildReactiveEffectsPlan(args) {
-  const { attrs, texts, conditionals, loopParam, loopParamBindings, profileComponentName } = args;
-  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings);
+  const { attrs, texts, conditionals, loopParam, loopParamBindings, loopIndex, profileComponentName } = args;
+  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings, loopIndex);
   const attrsBySlot = new Map;
   for (const attr of attrs) {
     let bucket = attrsBySlot.get(attr.childSlotId);
@@ -19032,10 +19174,10 @@ function buildReactiveEffectsPlan(args) {
       conditionalPlans.push({
         slotId: cond.slotId,
         wrappedCondition: wrap(cond.condition),
-        whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-        whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
-        whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, cond.slotId, profileComponentName),
-        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, cond.slotId, profileComponentName),
+        whenTrueTemplateHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+        whenFalseTemplateHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId),
+        whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, loopIndex, cond.slotId, profileComponentName),
+        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, loopIndex, cond.slotId, profileComponentName),
         ...cond.readsPreamble && { readsPreamble: true }
       });
     }
@@ -19047,7 +19189,7 @@ function buildReactiveEffectsPlan(args) {
     profileComponentName
   };
 }
-function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, profileComponentName) {
+function buildOuterArm(branch, wrap, loopParam, loopParamBindings, loopIndex, condSlotId, profileComponentName) {
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -19064,6 +19206,7 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       condSlotId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19071,7 +19214,8 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -19084,6 +19228,7 @@ function buildLoopReactiveEffectsPlan(elem, profileComponentName) {
     conditionals: elem.bindings.conditionals,
     loopParam: elem.param,
     loopParamBindings: elem.paramBindings,
+    loopIndex: elem.index,
     profileComponentName
   });
 }
@@ -19110,8 +19255,8 @@ function wrapAttrValueExpression2(value, wrap) {
   }
 }
 function buildInnerLoopsPlan(args) {
-  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings } = args;
-  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings) : (expr) => expr;
+  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings, outerLoopIndex } = args;
+  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings, outerLoopIndex) : (expr) => expr;
   const plan = [];
   let i = 0;
   while (i < levels.length) {
@@ -19133,15 +19278,14 @@ function buildInnerLoopsPlan(args) {
     }
     const uidSuffix = `${inner.depth}_${i}`;
     const containerExpr = inner.containerSlotId ? `qsa(${parentElVar}, '[bf="${inner.containerSlotId}"]')` : parentElVar;
-    const refsParent = !!outerLoopParam && (inner.arrayFreeIdentifiers?.has(outerLoopParam) ?? false);
-    const useReactive = refsParent && !!inner.template;
-    const emit = useReactive ? buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings) : buildStaticEmit(inner, level, uidSuffix);
-    const arrayExpr = useReactive ? wrapOuter(inner.array) : inner.array;
+    const emit = buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings, outerLoopIndex);
+    const arrayExpr = wrapOuter(inner.array);
     const childLevelsPlan = childLevels.length > 0 ? buildInnerLoopsPlan({
       levels: childLevels,
       parentElVar: `__innerEl${uidSuffix}`,
       outerLoopParam: inner.param,
-      outerLoopParamBindings: inner.paramBindings
+      outerLoopParamBindings: inner.paramBindings,
+      outerLoopIndex: inner.index
     }) : [];
     plan.push({
       uidSuffix,
@@ -19155,17 +19299,18 @@ function buildInnerLoopsPlan(args) {
       emit,
       childLevels: childLevelsPlan,
       outerLoopParam,
-      outerLoopParamBindings
+      outerLoopParamBindings,
+      outerLoopIndex
     });
     i = j;
   }
   return plan;
 }
-function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings) {
-  const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings);
-  const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings);
+function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings, outerLoopIndex) {
+  const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings, inner.index);
+  const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings, inner.index);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(inner.param, inner.paramBindings);
-  const wrappedKey = inner.key ? wrapLoopParamAsAccessor(inner.key, inner.param, inner.paramBindings) : null;
+  const wrappedKey = inner.key ? wrapLoopParamAsAccessor(inner.key, inner.param, inner.paramBindings, inner.index) : null;
   const wrapIRNode = (node) => {
     if (node.type === "component") {
       return {
@@ -19196,11 +19341,11 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
   }));
   const reactiveTexts = inner.bindings.reactiveTexts.map((text) => ({
     slotId: text.slotId,
-    wrappedExpression: wrapLoopParamAsAccessor(wrapOuter(text.expression), inner.param, inner.paramBindings),
+    wrappedExpression: wrapLoopParamAsAccessor(wrapOuter(text.expression), inner.param, inner.paramBindings, inner.index),
     insideConditional: !!text.insideConditional
   }));
   const reactiveAttrs = inner.bindings.reactiveAttrs.map((attr) => {
-    const wrapped = wrapLoopParamAsAccessor(wrapOuter(attr.expression), inner.param, inner.paramBindings);
+    const wrapped = wrapLoopParamAsAccessor(wrapOuter(attr.expression), inner.param, inner.paramBindings, inner.index);
     return {
       slotId: attr.childSlotId,
       attrName: attr.attrName,
@@ -19216,21 +19361,22 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     preludeStatements.push(paramUnwrap);
   if (inner.preamble) {
     const leafLoopParams = outerLoopParam ? [
-      { param: outerLoopParam, bindings: outerLoopParamBindings },
-      { param: inner.param, bindings: inner.paramBindings }
-    ] : [{ param: inner.param, bindings: inner.paramBindings }];
+      { param: outerLoopParam, bindings: outerLoopParamBindings, index: outerLoopIndex },
+      { param: inner.param, bindings: inner.paramBindings, index: inner.index }
+    ] : [{ param: inner.param, bindings: inner.paramBindings, index: inner.index }];
     preludeStatements.push(renderPreamble(inner.preamble, {
       transformJs: (t) => wrapInner(wrapOuter(t)),
       renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, leafLoopParams, undefined)
     }));
   }
-  const childRefs = buildChildRefBindings(inner.bindings.refs, inner.param, inner.paramBindings);
+  const childRefs = buildChildRefBindings(inner.bindings.refs, inner.param, inner.paramBindings, inner.index);
   const conditionals = buildLoopChildConditionalsPlan({
     conditionals: inner.bindings.conditionals,
     scopeVar: `__innerEl${uidSuffix}`,
     wrap: wrapBoth,
     loopParam: inner.param,
-    loopParamBindings: inner.paramBindings
+    loopParamBindings: inner.paramBindings,
+    loopIndex: inner.index
   });
   return {
     mode: "reactive",
@@ -19248,32 +19394,13 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     childRefs
   };
 }
-function buildStaticEmit(inner, level, uidSuffix) {
-  const preludeStatements = [];
-  const indexAlias = nestedLoopIndexAlias(inner, `__innerIdx${uidSuffix}`, inner.param, level.comps, level.events);
-  if (indexAlias)
-    preludeStatements.push(indexAlias);
-  if (inner.preamble) {
-    preludeStatements.push(renderPreamble(inner.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
-    }));
-  }
-  return {
-    mode: "static",
-    rawKey: inner.key ?? null,
-    preludeStatements,
-    components: level.comps,
-    events: level.events,
-    childRefs: buildStaticChildRefBindings(inner.bindings.refs)
-  };
-}
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-composite-loop.ts
 function buildTopLevelCompositePlan(elem, profileComponentName) {
   const nestedComps = elem.nestedComponents;
   const depthLevels = buildDepthLevels(elem.innerLoops ?? [], nestedComps, elem.bindings.events);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
-  const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings);
+  const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings, elem.index);
   const outerCompsByDepth = nestedComps.filter((c) => !c.loopDepth || c.loopDepth === 0);
   return {
     kind: "composite",
@@ -19287,26 +19414,29 @@ function buildTopLevelCompositePlan(elem, profileComponentName) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.preamble ? renderPreamble(elem.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings, index: elem.index }], undefined)
     }) : "",
     template: elem.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, elem.bindings.conditionals),
     outerEvents: elem.bindings.events.filter((ev) => ev.nestedLoops.length === 0),
-    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
+    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings, elem.index),
     innerLoops: buildInnerLoopsPlan({
       levels: depthLevels,
       parentElVar: "__el",
       outerLoopParam: elem.param,
-      outerLoopParamBindings: elem.paramBindings
+      outerLoopParamBindings: elem.paramBindings,
+      outerLoopIndex: elem.index
     }),
     loopParam: elem.param,
     loopParamBindings: elem.paramBindings,
+    loopIndex: elem.index,
     reactiveEffects: hasReactive(elem) ? buildReactiveEffectsPlan({
       attrs: elem.bindings.reactiveAttrs,
       texts: elem.bindings.reactiveTexts,
       conditionals: elem.bindings.conditionals,
       loopParam: elem.param,
       loopParamBindings: elem.paramBindings,
+      loopIndex: elem.index,
       profileComponentName
     }) : null,
     branchClearChildren: false,
@@ -19323,7 +19453,7 @@ function buildBranchCompositePlan(loop, cv, profileComponentName) {
   const childEvents = loop.bindings.events;
   const depthLevels = buildDepthLevels(innerLoops, nestedComps, childEvents);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(loop.param, loop.paramBindings);
-  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings);
+  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings, loop.index);
   const outerCompsByDepth = nestedComps.filter((c) => !c.loopDepth || c.loopDepth === 0);
   return {
     kind: "composite",
@@ -19337,26 +19467,29 @@ function buildBranchCompositePlan(loop, cv, profileComponentName) {
     indexParam: loop.index || "__idx",
     mapPreambleWrapped: loop.preamble ? renderPreamble(loop.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings, index: loop.index }], undefined)
     }) : "",
     template: loop.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, loop.bindings.conditionals),
     outerEvents: childEvents.filter((ev) => ev.nestedLoops.length === 0),
-    childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings),
+    childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings, loop.index),
     innerLoops: buildInnerLoopsPlan({
       levels: depthLevels,
       parentElVar: "__el",
       outerLoopParam: loop.param,
-      outerLoopParamBindings: loop.paramBindings
+      outerLoopParamBindings: loop.paramBindings,
+      outerLoopIndex: loop.index
     }),
     loopParam: loop.param,
     loopParamBindings: loop.paramBindings,
+    loopIndex: loop.index,
     reactiveEffects: hasReactiveBranch(loop) ? buildReactiveEffectsPlan({
       attrs: loop.bindings.reactiveAttrs,
       texts: loop.bindings.reactiveTexts,
       conditionals: loop.bindings.conditionals,
       loopParam: loop.param,
       loopParamBindings: loop.paramBindings,
+      loopIndex: loop.index,
       profileComponentName
     }) : null,
     branchClearChildren: true,
@@ -19491,7 +19624,7 @@ function wiringOn(branch) {
     found.push("reactive text");
   return found;
 }
-function analyzeLazyConditional(cond, indexParam, arms) {
+function analyzeLazyConditional(cond, arms) {
   for (const [label, branch] of [["true", cond.whenTrue], ["false", cond.whenFalse]]) {
     const wiring = wiringOn(branch);
     if (wiring.length > 0) {
@@ -19512,9 +19645,6 @@ function analyzeLazyConditional(cond, indexParam, arms) {
   if (!cond.conditionFreeIdentifiers) {
     return NO(`conditional on slot ${cond.slotId}: condition has no analyzable identifier set`);
   }
-  if (cond.conditionFreeIdentifiers.has(indexParam)) {
-    return NO(`conditional on slot ${cond.slotId}: condition reads the loop index parameter '${indexParam}'`);
-  }
   return {
     lazySafe: true,
     facts: {
@@ -19533,7 +19663,7 @@ var NO_PREAMBLE = {
   facts: { declaredNames: new Set, freeNames: new Set }
 };
 var NO2 = (reason) => ({ lazySafe: false, reason });
-function analyzeLazyPreamble(preamble, indexParam, primableNames) {
+function analyzeLazyPreamble(preamble, primableNames) {
   if (!preamble)
     return NO_PREAMBLE;
   if (preamble.builderNames.length > 0) {
@@ -19572,9 +19702,6 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
     }
   }
   const readNames = extractFreeIdentifiersFromStatementText(text);
-  if (readNames.has(indexParam) && !declaredNames.has(indexParam)) {
-    return NO2(`map-callback preamble reads the loop index parameter '${indexParam}'`);
-  }
   const freeNames = new Set(readNames);
   for (const declared of declaredNames)
     freeNames.delete(declared);
@@ -19724,9 +19851,6 @@ function lazyRowEligibility(args) {
   if (shape.hasParamUnwrap)
     return NO3("destructured loop param without param bindings");
   for (const b of bindings) {
-    if (b.referencesIndex) {
-      return NO3(`binding on slot ${b.slotId} references the loop index parameter`);
-    }
     if (b.opaqueOuterNames.includes(UNKNOWN_IDENTIFIERS)) {
       return NO3(`binding on slot ${b.slotId} has no analyzable identifier set`);
     }
@@ -19811,6 +19935,7 @@ function classifyLazyBinding(args) {
     }
     if (name === indexParam) {
       referencesIndex = true;
+      readsItem = true;
       return;
     }
     if (INERT_BINDING_GLOBALS.has(name))
@@ -19860,14 +19985,14 @@ function decideLazyRow(args) {
   for (const b of loop.paramBindings ?? [])
     rowLocalNames.add(b.name);
   const primableNames = new Set([...scope.signals.keys(), ...scope.memos]);
-  const preambleAnalysis = analyzeLazyPreamble(loop.preamble, args.indexParam, primableNames);
+  const preambleAnalysis = analyzeLazyPreamble(loop.preamble, primableNames);
   const rawConditionals = loop.bindings.conditionals ?? [];
   const condFacts = [];
   let conditionalRefusal = null;
   for (const cond of rawConditionals) {
-    const verdict = analyzeLazyConditional(cond, args.indexParam, {
-      whenTrueHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-      whenFalseHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId)
+    const verdict = analyzeLazyConditional(cond, {
+      whenTrueHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+      whenFalseHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId)
     });
     if (!verdict.lazySafe) {
       conditionalRefusal = verdict.reason;
@@ -20007,7 +20132,8 @@ function decideLazyRow(args) {
       preambleStatements: args.mapPreambleWrapped,
       itemNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsItem && b.readsPreamble),
       outerNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsOuter && b.readsPreamble),
-      conditionals
+      conditionals,
+      readsIndex: classified.some((c) => c.referencesIndex)
     },
     decision
   };
@@ -20058,6 +20184,43 @@ function loopSourceIdentifiers(loop, arrayExpr) {
   return names;
 }
+// ../jsx/src/ir-to-client-js/control-flow/plan/build-plain-row.ts
+function buildPlainRowCore(inputs) {
+  const { loop, arrayExpr, callSite, flatMapLeafItem, anchored, scope } = inputs;
+  const wrapItem = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings);
+  const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(loop.param, loop.paramBindings);
+  const indexParam = loop.index || "__idx";
+  const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
+    transformJs: wrapItem,
+    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings, loop.index);
+  const lazyRow = buildLazyRowPlan({
+    loop,
+    arrayExpr,
+    indexParam,
+    paramUnwrap,
+    mapPreambleWrapped,
+    preambleRegionCount: preambleRegions.length,
+    callSite,
+    flatMapLeafItem,
+    anchored,
+    scope
+  }) ?? undefined;
+  const mapPreambleWrappedFinal = !lazyRow && loop.index ? wrapIndexParamAsAccessor(mapPreambleWrapped, loop.index) : mapPreambleWrapped;
+  const templateFinal = !lazyRow && loop.index ? loop.templateIndexed ?? loop.template : loop.template;
+  return {
+    indexParam,
+    paramHead,
+    paramUnwrap,
+    preambleRegions,
+    lazyRow,
+    mapPreambleWrapped: mapPreambleWrappedFinal,
+    template: templateFinal,
+    wrapItem
+  };
+}
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-branch-loop.ts
 function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const containerSlotId = loop.containerSlotId;
@@ -20072,16 +20235,18 @@ function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
     };
     return composite;
   }
-  const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(loop.param, loop.paramBindings);
   const hasReactiveEffects = loop.bindings.reactiveAttrs.length > 0 || loop.bindings.reactiveTexts.length > 0 || loop.bindings.conditionals.length > 0;
   const fm = loop.flatMapClient;
   const arrayExpr = fm ? `(${buildChainedArrayExpr(loop)}).flatMap(${fm.params} => ${fm.body})` : buildChainedArrayExpr(loop);
-  const indexParam = loop.index || "__idx";
-  const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
-    transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined)
-  }) : "";
-  const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
+  const core = buildPlainRowCore({
+    loop,
+    arrayExpr,
+    callSite: "branch-plain",
+    flatMapLeafItem: Boolean(fm),
+    anchored: false,
+    scope: lazyScope
+  });
+  const { paramHead, paramUnwrap, indexParam, preambleRegions, lazyRow } = core;
   const plan = {
     kind: "plain",
     rowConstruction: "string-template",
@@ -20094,30 +20259,20 @@ function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
     paramHead,
     paramUnwrap,
     indexParam,
-    mapPreambleWrapped,
-    lazyRow: buildLazyRowPlan({
-      loop,
-      arrayExpr,
-      indexParam,
-      paramUnwrap,
-      mapPreambleWrapped,
-      preambleRegionCount: preambleRegions.length,
-      callSite: "branch-plain",
-      flatMapLeafItem: Boolean(fm),
-      anchored: false,
-      scope: lazyScope
-    }) ?? undefined,
-    template: loop.template,
+    mapPreambleWrapped: core.mapPreambleWrapped,
+    lazyRow,
+    template: core.template,
     reactiveEffects: hasReactiveEffects ? buildReactiveEffectsPlan({
       attrs: loop.bindings.reactiveAttrs,
       texts: loop.bindings.reactiveTexts,
       conditionals: loop.bindings.conditionals,
       loopParam: loop.param,
       loopParamBindings: loop.paramBindings,
+      loopIndex: loop.index,
       profileComponentName
     }) : null,
     eventDelegation: buildBranchLoopDelegationPlan(loop, cv, profileComponentName),
-    childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings),
+    childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings, loop.index),
     preambleRegions,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${containerSlotId}` : undefined
@@ -20242,6 +20397,24 @@ function emitAttrUpdate(target, attrName, expression, meta) {
     `{ const __v = ${expression}; if (__v != null) ${target}.setAttribute('${htmlName}', String(__v)); else ${target}.removeAttribute('${htmlName}') }`
   ];
 }
+var DEDUP_STORE_DECL = "const __l = []";
+function dedupGuard(ordinal) {
+  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
+}
+function emitDedupedAttrUpdate(target, attrName, expression, meta, ordinal, guard = dedupGuard(ordinal)) {
+  const write = emitAttrUpdate(target, attrName, "__x", meta);
+  const lines = [`{ const __x = ${expression}`];
+  if (guard) {
+    lines.push(`if (${guard}) {`);
+    for (const stmt of write)
+      lines.push(`  ${stmt}`);
+    lines.push(`}`);
+  } else {
+    lines.push(...write);
+  }
+  lines.push(`__l[${ordinal}] = __x }`);
+  return lines;
+}
 function rewriteDestructuredPropsInExpr(expr, ctx) {
   if (ctx.propsObjectName)
     return expr;
@@ -20402,7 +20575,7 @@ function emitDynamicTextUpdates(lines, ctx) {
       const __textSlot = (normalElems[0] ?? conditionalElems[0])?.slotId;
       let writer = "";
       if (normalElems.length > 0) {
-        const slots = normalElems.map((elem) => ({ id: elem.slotId, kind: "markup", path: [] }));
+        const slots = normalElems.map((elem) => ({ id: elem.slotId, kind: DYNAMIC_ELEMENT_WRITER_KIND, path: [] }));
         writer = claimWriterVarName(slots, varSlotId);
         lines.push(`  const ${writer} = lazySlots(__scope, ${claimPlanLiteral(slots)})`);
       }
@@ -20456,16 +20629,18 @@ function emitReactiveAttributeUpdates(lines, ctx) {
     }
     for (const [slotId, attrs] of attrsBySlot) {
       const v = varSlotId(slotId);
+      lines.push(`  { ${DEDUP_STORE_DECL}`);
       lines.push(`  createEffect(() => {`);
       lines.push(`    if (_${v}) {`);
+      let ordinal = 0;
       for (const attr of attrs) {
         const expression = rewriteDestructuredPropsInExpr(lower(attr.expression), ctx);
-        for (const stmt of emitAttrUpdate(`_${v}`, attr.attrName, expression, attr)) {
+        for (const stmt of emitDedupedAttrUpdate(`_${v}`, attr.attrName, expression, attr, ordinal++)) {
           lines.push(`      ${stmt}`);
         }
       }
       lines.push(`    }`);
-      lines.push(`  }${bindingIdArg(ctx, slotId)})`);
+      lines.push(`  }${bindingIdArg(ctx, slotId)}) }`);
       lines.push("");
     }
   }
@@ -20518,6 +20693,7 @@ function emitReactiveChildProps(lines, ctx) {
   if (ctx.reactiveChildProps.length > 0) {
     lines.push("");
     lines.push(`  // Reactive child component props`);
+    lines.push(`  { ${DEDUP_STORE_DECL}`);
     lines.push(`  createEffect(() => {`);
     const propsByComponent = new Map;
     for (const prop of ctx.reactiveChildProps) {
@@ -20527,6 +20703,7 @@ function emitReactiveChildProps(lines, ctx) {
       }
       propsByComponent.get(key).push(prop);
     }
+    let ordinal = 0;
     for (const [, props] of propsByComponent) {
       const first = props[0];
       const isCommentRoot = first.slotId !== null && first.slotId === ctx.commentScopeRootSlotId;
@@ -20538,26 +20715,31 @@ function emitReactiveChildProps(lines, ctx) {
       }
       lines.push(`    if (${varName}) {`);
       for (const prop of props) {
-        const stmts = toHTMLAttrName(prop.attrName) === "value" ? emitChildValueMirrorStatements(varName, prop.expression) : emitAttrUpdate(varName, prop.attrName, prop.expression, prop);
+        const stmts = toHTMLAttrName(prop.attrName) === "value" ? emitChildValueMirrorStatements(varName, prop.expression) : emitDedupedAttrUpdate(varName, prop.attrName, prop.expression, prop, ordinal++);
         for (const stmt of stmts) {
           lines.push(`      ${stmt}`);
         }
       }
       lines.push(`    }`);
     }
-    lines.push(`  }${bindingIdArg(ctx, ctx.reactiveChildProps[0]?.slotId ?? undefined)})`);
+    lines.push(`  }${bindingIdArg(ctx, ctx.reactiveChildProps[0]?.slotId ?? undefined)}) }`);
   }
 }
 // ../jsx/src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts
-function stringifyBranchReactiveAttrs(lines, plan, indent, pc) {
+function stringifyBranchReactiveAttrs(lines, plan, indent, pc, mapPreambleWrapped) {
   for (const slot of plan) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}{ const ${varName} = qsa(__branchScope, '[bf="${slot.slotId}"]')`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${varName}) {`);
+    let ordinal = 0;
     for (const attr of slot.attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      if (attr.readsPreamble && mapPreambleWrapped) {
+        lines.push(`${indent}    ${mapPreambleWrapped}`);
+      }
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${profileBindingId(pc, slot.slotId)}))`);
@@ -20600,7 +20782,7 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       lines.push(`${indent}  __bel${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${inner.wrappedKey}))`);
     }
     if (inner.legacyComponents.length > 0 || inner.legacyEvents.length > 0) {
-      emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings);
+      emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings, false, inner.outerLoopIndex);
     }
     const conditionalTexts = inner.reactiveTexts.filter((t) => t.insideConditional);
     const plainTexts = inner.reactiveTexts.filter((t) => !t.insideConditional);
@@ -20617,32 +20799,35 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       }
     }
     if (inner.nestedConditionals.length > 0) {
-      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc);
+      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc, undefined);
     }
     lines.push(`${indent}  return __bel${uid}`);
     lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!inner.wrappedKey, inner.keyDepth)}) }`);
   }
 }
-function stringifyLoopChildConditionals(lines, conditionals, indent, pc) {
+function stringifyLoopChildConditionals(lines, conditionals, indent, pc, mapPreambleWrapped) {
   for (const cond of conditionals) {
-    stringifyLoopChildConditional(lines, cond, indent, pc);
+    stringifyLoopChildConditional(lines, cond, indent, pc, mapPreambleWrapped);
   }
 }
-function stringifyLoopChildConditional(lines, cond, indent, pc) {
+function conditionGetterExpr(wrappedCondition, readsPreamble, mapPreambleWrapped) {
+  return readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${wrappedCondition}) }` : `() => ${wrappedCondition}`;
+}
+function stringifyLoopChildConditional(lines, cond, indent, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
+  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', ${conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped)}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
-function stringifyLoopChildArm(lines, arm, armIndent, pc) {
+function stringifyLoopChildArm(lines, arm, armIndent, pc, mapPreambleWrapped) {
   stringifyBranchEventBindings(lines, arm.events, armIndent);
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
   stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
@@ -20650,10 +20835,10 @@ function stringifyLoopChildArm(lines, arm, armIndent, pc) {
   if (!hasDisposables)
     return;
   lines.push(`${armIndent}const __disposers = []`);
-  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc);
+  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc, mapPreambleWrapped);
   for (const cond of arm.nestedConditionals) {
     lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => {`);
-    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc);
+    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc, mapPreambleWrapped);
     lines.push(`${armIndent}}))`);
   }
   if (arm.texts.length > 0) {
@@ -20692,13 +20877,15 @@ function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementI
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot);
     lines.push(`${indent}{ const ${varName} = ${lookupExpr}`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${varName}) {`);
+    let ordinal = 0;
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`);
       if (attr.readsPreamble && mapPreambleWrapped) {
         lines.push(`${indent}    ${mapPreambleWrapped}`);
       }
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${bindingBfId(slot.slotId)})`);
@@ -20734,6 +20921,8 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}const ${varName} = ${attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot)}`);
   }
+  if (attrSlots.length > 0)
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
   const claimSlots = [
     ...outerTexts.map((t) => ({ id: t.slotId, kind: "text", path: [], pathExpr: textClaimPathExprs?.get(t.slotId) })),
     ...preambleRegions.map((r) => ({ id: r.slotId, kind: "markup", path: [] }))
@@ -20751,15 +20940,14 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
   if (mapPreambleWrapped && (preambleRegions.length > 0 || attrsReadPreamble(attrSlots))) {
     lines.push(`${indent}  ${mapPreambleWrapped}`);
   }
+  let ordinal = 0;
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}  if (${varName}) {`);
     for (const attr of slot.attrs) {
-      lines.push(`${indent}    {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
-        lines.push(`${indent}      ${stmt}`);
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
+        lines.push(`${indent}    ${stmt}`);
       }
-      lines.push(`${indent}    }`);
     }
     lines.push(`${indent}  }`);
   }
@@ -20788,16 +20976,16 @@ function emitOuterTexts(lines, indent, elVar, texts, bindingBfId, textClaimPathE
 }
 function emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  const conditionGetter = cond.readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${cond.wrappedCondition}) }` : `() => ${cond.wrappedCondition}`;
+  const conditionGetter = conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped);
   lines.push(`${indent}insert(${elVar}, '${cond.slotId}', ${conditionGetter}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
@@ -20940,6 +21128,8 @@ function stringifyLazyRowLoop(lines, o) {
   lines.push(`${indent}${o.guardContainer ? `if (${o.containerVar}) ` : ""}${call}`);
   const b1 = `${indent}  `;
   const b2 = `${indent}    `;
+  if (lazyRow.readsIndex)
+    lines.push(`${b1}indexDriven: true,`);
   lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`);
   lines.push(`${b2}const ${paramHead} = () => __e.item`);
   if (lazyRow.preambleStatements)
@@ -20969,6 +21159,8 @@ function stringifyLazyRowLoop(lines, o) {
   } else {
     lines.push(`${b1}applyItem: (__e) => {`);
     lines.push(`${b2}const ${paramHead} = () => __e.item`);
+    if (lazyRow.readsIndex)
+      lines.push(`${b2}const ${o.indexParam} = __e.index`);
     lines.push(`${b2}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b2}const __l = __e.last ?? (__e.last = [])`);
     if (lazyRow.itemNeedsPreamble && lazyRow.preambleStatements) {
@@ -20995,6 +21187,8 @@ function stringifyLazyRowLoop(lines, o) {
       lines.push(`${b2}${g}()`);
     lines.push(`${b2}for (const __e of __es) {`);
     lines.push(`${b3}const ${paramHead} = () => __e.item`);
+    if (lazyRow.readsIndex)
+      lines.push(`${b3}const ${o.indexParam} = __e.index`);
     lines.push(`${b3}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b3}const __l = __e.last ?? (__e.last = [])`);
     if (lazyRow.outerNeedsPreamble && lazyRow.preambleStatements) {
@@ -21060,24 +21254,14 @@ function emitConditional(lines, ind, mid, c, mode) {
   lines.push(`${ind}  __l[${c.ordinal}] = __x`);
   lines.push(`${ind}} }`);
 }
-function dedupGuard(ordinal) {
-  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
-}
 function emitAttrBinding(lines, ind, a, mode) {
   const target = mode === "create" ? `__r[${a.refIndex}]` : elementAccess(a);
+  const guard = mode === "create" ? null : mode === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
   lines.push(`${ind}{ const __t = ${target}`);
   lines.push(`${ind}if (__t) {`);
-  lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
-  const guard = mode === "create" ? null : mode === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
-  const writeIndent = guard ? `${ind}    ` : `${ind}  `;
-  if (guard)
-    lines.push(`${ind}  if (${guard}) {`);
-  for (const stmt of emitAttrUpdate("__t", a.attrName, "__x", a.meta)) {
-    lines.push(`${writeIndent}${stmt}`);
-  }
-  if (guard)
-    lines.push(`${ind}  }`);
-  lines.push(`${ind}  __l[${a.ordinal}] = __x`);
+  for (const stmt of emitDedupedAttrUpdate("__t", a.attrName, a.wrappedExpression, a.meta, a.ordinal, guard)) {
+    lines.push(`${ind}  ${stmt}`);
+  }
   lines.push(`${ind}} }`);
 }
 function emitTextBinding(lines, ind, t, doorExpr, mode, rwDoor) {
@@ -21367,13 +21551,16 @@ function stringifyStaticLoop(lines, plan) {
     lines.push(`      }`);
   }
   lines.push(`      if (__iterEl) {`);
+  if (attrsBySlot.length > 0)
+    lines.push(`        ${DEDUP_STORE_DECL}`);
+  let ordinal = 0;
   for (const [slotId, attrs] of attrsBySlot) {
     const varName = `__t_${varSlotId(slotId)}`;
     lines.push(`        const ${varName} = qsa(__iterEl, '[bf="${slotId}"]')`);
     lines.push(`        if (${varName}) {`);
     for (const attr of attrs) {
       lines.push(`          createEffect(() => {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`            ${stmt}`);
       }
       lines.push(`          }${profileBindingId(pc, slotId)})`);
@@ -21398,18 +21585,12 @@ function stringifyStaticLoop(lines, plan) {
 // ../jsx/src/ir-to-client-js/control-flow/stringify/inner-loop.ts
 function stringifyInnerLoops(lines, plan, indent, pc) {
   for (const inner of plan) {
-    if (inner.emit.mode === "reactive") {
-      emitReactive(lines, inner, indent, pc);
-    } else {
-      emitStatic(lines, inner, indent, pc);
-    }
+    emitReactive(lines, inner, indent, pc);
   }
 }
 function emitReactive(lines, inner, indent, pc) {
   const uid = inner.uidSuffix;
   const emit = inner.emit;
-  if (emit.mode !== "reactive")
-    return;
   lines.push(`${indent}// Reactive inner loop: ${inner.arraySrc}`);
   lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`);
   lines.push(`${indent}if (__ic${uid}) mapArray(() => ${inner.arrayExpr} || [], __ic${uid}, ${emit.keyFn}, (${emit.paramHead}, __innerIdx${uid}, __existing) => {`);
@@ -21435,7 +21616,7 @@ function emitReactive(lines, inner, indent, pc) {
     lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${emit.wrappedKey}))`);
   }
   if (emit.components.length > 0 || emit.events.length > 0) {
-    emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
+    emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings, false, inner.outerLoopIndex);
   }
   if (inner.childLevels.length > 0) {
     stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
@@ -21454,17 +21635,20 @@ function emitReactive(lines, inner, indent, pc) {
       lines.push(`${indent}  createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)})`);
     }
   }
+  if (emit.reactiveAttrs.length > 0)
+    lines.push(`${indent}  ${DEDUP_STORE_DECL}`);
+  let attrOrdinal = 0;
   for (const attr of emit.reactiveAttrs) {
     const targetVar = `__ta_${attr.slotId.replace(/[^a-zA-Z0-9]/g, "_")}`;
     lines.push(`${indent}  { const ${targetVar} = qsa(__innerEl${uid}, '[bf="${attr.slotId}"]')`);
     lines.push(`${indent}  if (${targetVar}) createEffect(() => {`);
-    for (const stmt of emitAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta)) {
+    for (const stmt of emitDedupedAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta, attrOrdinal++)) {
       lines.push(`${indent}    ${stmt}`);
     }
     lines.push(`${indent}  }${profileBindingId(pc, attr.slotId)}) }`);
   }
   if (emit.conditionals.length > 0) {
-    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc);
+    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc, undefined);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -21474,33 +21658,6 @@ function emitReactive(lines, inner, indent, pc) {
   lines.push(`${indent}  return __innerEl${uid}`);
   lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!emit.wrappedKey, inner.keyDepth)}) }`);
 }
-function emitStatic(lines, inner, indent, pc) {
-  const uid = inner.uidSuffix;
-  const emit = inner.emit;
-  if (emit.mode !== "static")
-    return;
-  lines.push(`${indent}// Initialize ${inner.arraySrc} loop components and events`);
-  lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`);
-  lines.push(`${indent}if (__ic${uid} && ${inner.arrayExpr}) ${inner.arrayExpr}.forEach((${inner.param}, __innerIdx${uid}) => {`);
-  lines.push(`${indent}  const __innerEl${uid} = __ic${uid}.children[__innerIdx${uid}]`);
-  lines.push(`${indent}  if (!__innerEl${uid}) return`);
-  for (const stmt of emit.preludeStatements) {
-    lines.push(`${indent}  ${stmt}`);
-  }
-  if (emit.rawKey) {
-    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${emit.rawKey}))`);
-  }
-  emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
-  if (inner.childLevels.length > 0) {
-    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
-  }
-  emitLoopChildRefs(lines, emit.childRefs, {
-    indent: `${indent}  `,
-    elVar: `__innerEl${uid}`,
-    bodyIsMultiRoot: false
-  });
-  lines.push(`${indent}}) }`);
-}
 // ../jsx/src/ir-to-client-js/control-flow/stringify/composite-loop.ts
 function stringifyCompositeLoop(lines, plan) {
@@ -21519,6 +21676,7 @@ function stringifyCompositeLoop(lines, plan) {
     innerLoops,
     loopParam,
     loopParamBindings,
+    loopIndex,
     reactiveEffects,
     childRefs,
     branchClearChildren,
@@ -21551,7 +21709,7 @@ function stringifyCompositeLoop(lines, plan) {
     singleRootLayout: "multiline",
     mountRow: true
   });
-  emitComponentAndEventSetup(lines, bodyIndent, "__el", compsArr, eventsArr, loopParam, loopParamBindings, bodyIsMultiRoot);
+  emitComponentAndEventSetup(lines, bodyIndent, "__el", compsArr, eventsArr, loopParam, loopParamBindings, bodyIsMultiRoot, loopIndex);
   if (innerLoops.length > 0) {
     stringifyInnerLoops(lines, innerLoops, bodyIndent, pc);
   }
@@ -21928,10 +22086,12 @@ function emitArmBody(lines, body, mode, indent, profileComponentName) {
     const v = varSlotId(slotId);
     const elVar = `__ra_${v}`;
     lines.push(`${indent}{ const ${elVar} = qsa(__branchScope, '[bf="${slotId}"]')`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${elVar}) {`);
+    let ordinal = 0;
     for (const attr of attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`);
-      for (const stmt of emitAttrUpdate(elVar, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(elVar, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${bindingBfId(slotId)}))`);
@@ -21973,11 +22133,11 @@ function scopeRefToVar(ref) {
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-component-loop.ts
 function buildComponentLoopPlan(elem, profileComponentName) {
   const { name } = elem.childComponent;
-  const propsExpr = buildComponentPropsExpr2(elem.childComponent, elem.param);
-  const keyExpr = wrapLoopParamAsAccessor(elem.key || "__idx", elem.param, elem.paramBindings);
+  const propsExpr = buildComponentPropsExpr2(elem.childComponent, elem.param, undefined, elem.index);
+  const keyExpr = wrapLoopParamAsAccessor(elem.key || "__idx", elem.param, elem.paramBindings, elem.index);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
   const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
-    transformJs: (text) => wrapLoopParamAsAccessor(text, elem.param, elem.paramBindings),
+    transformJs: (text) => wrapLoopParamAsAccessor(text, elem.param, elem.paramBindings, elem.index),
     renderLeaf: () => {
       internalInvariant(false, "component-root loop received a JSX-bearing preamble — Phase 1 should have refused it");
     }
@@ -21987,12 +22147,12 @@ function buildComponentLoopPlan(elem, profileComponentName) {
     const isTextOnly = comp.children?.length ? comp.children.every((c) => c.type === "expression" || c.type === "text" || isTextOnlyConditional(c)) : false;
     const rawChildrenExpr = isTextOnly ? irChildrenToJsExpr(comp.children) : null;
     const childrenFreeIds = isTextOnly && comp.children ? irChildrenFreeIds(comp.children) : undefined;
-    const childrenRefsLoop = rawChildrenExpr != null && childrenFreeIds != null && childrenFreeIds.has(elem.param);
+    const childrenRefsLoop = rawChildrenExpr != null && childrenFreeIds != null && (childrenFreeIds.has(elem.param) || !!elem.index && childrenFreeIds.has(elem.index));
     return {
       componentName: comp.name,
       selector: buildCompSelector(comp),
-      propsExpr: buildComponentPropsExpr2(comp, elem.param),
-      childrenTextEffect: childrenRefsLoop ? { wrappedChildren: wrapLoopParamAsAccessor(rawChildrenExpr, elem.param, elem.paramBindings) } : null
+      propsExpr: buildComponentPropsExpr2(comp, elem.param, undefined, elem.index),
+      childrenTextEffect: childrenRefsLoop ? { wrappedChildren: wrapLoopParamAsAccessor(rawChildrenExpr, elem.param, elem.paramBindings, elem.index) } : null
     };
   });
   const hasChildConds = elem.bindings.conditionals.length > 0;
@@ -22011,7 +22171,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
     componentPropsExpr: propsExpr,
     keyExpr,
     nestedComps,
-    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
+    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings, elem.index),
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : undefined,
     childConditionalEffects: hasChildConds ? buildReactiveEffectsPlan({
       attrs: [],
@@ -22019,6 +22179,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
       conditionals: elem.bindings.conditionals,
       loopParam: elem.param,
       loopParamBindings: elem.paramBindings,
+      loopIndex: elem.index,
       profileComponentName
     }) : null
   };
@@ -22042,8 +22203,6 @@ function buildLoopPlan(elem, opts) {
   return buildPlainLoopPlan(elem, opts.profileComponentName, opts.lazyScope);
 }
 function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
-  const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings);
-  const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
   const hasReactive2 = elem.bindings.reactiveAttrs.length > 0 || elem.bindings.reactiveTexts.length > 0 || elem.bindings.conditionals.length > 0;
   if (elem.flatMapClient) {
     return {
@@ -22069,12 +22228,15 @@ function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
     };
   }
   const arrayExpr = buildChainedArrayExpr(elem);
-  const indexParam = elem.index || "__idx";
-  const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
-    transformJs: wrap,
-    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
-  }) : "";
-  const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings);
+  const core = buildPlainRowCore({
+    loop: elem,
+    arrayExpr,
+    callSite: "plain",
+    flatMapLeafItem: false,
+    anchored: elem.bodyIsItemConditional ?? false,
+    scope: lazyScope
+  });
+  const { paramHead, paramUnwrap, indexParam, preambleRegions, lazyRow, wrapItem: wrap } = core;
   return {
     kind: "plain",
     rowConstruction: "string-template",
@@ -22086,28 +22248,17 @@ function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
     paramHead,
     paramUnwrap,
     indexParam,
-    lazyRow: buildLazyRowPlan({
-      loop: elem,
-      arrayExpr,
-      indexParam,
-      paramUnwrap,
-      mapPreambleWrapped,
-      preambleRegionCount: preambleRegions.length,
-      callSite: "plain",
-      flatMapLeafItem: false,
-      anchored: elem.bodyIsItemConditional ?? false,
-      scope: lazyScope
-    }) ?? undefined,
-    mapPreambleWrapped,
-    template: elem.template,
+    lazyRow,
+    mapPreambleWrapped: core.mapPreambleWrapped,
+    template: core.template,
     skeletonTemplate: elem.skeletonTemplate,
     skeletonPaths: elem.skeletonPaths,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
-    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
+    childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings, elem.index),
     preambleRegions,
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
     anchored: elem.bodyIsItemConditional ?? false,
-    anchorKeyExpr: elem.key ? wrap(elem.key) : elem.index || "__idx"
+    anchorKeyExpr: elem.key ? wrap(elem.key) : `${indexParam}()`
   };
 }
 function buildStaticLoopPlan(elem, unsafeLocalNames, profileComponentName) {
@@ -22149,7 +22300,7 @@ function buildStaticLoopMaterialize(elem, unsafeLocalNames) {
   return {
     itemTemplate: elem.staticItemTemplate,
     mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings, index: elem.index }], undefined)
     }) : "",
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false
   };
@@ -22725,7 +22876,7 @@ function generateTemplateOnlyMount(ir, ctx) {
   const restSpreadNames = resolveRestSpreadNames(ctx);
   let templateHtml;
   if (canGenerateStaticTemplate(ir.root, propNamesForStaticCheck, inlinableConstants, unsafeLocalNames)) {
-    const markupSlotIds = new Set(ctx.dynamicElements.map((e) => e.slotId));
+    const markupSlotIds = markupSlotIdsOf(ctx);
     templateHtml = irToComponentTemplate(ir.root, inlinableConstants, restSpreadNames, ctx.propsObjectName, markupSlotIds, ctx.restPropsName);
   }
   if (!templateHtml) {
@@ -23443,6 +23594,21 @@ function extractSsrDefaults(metadata) {
     }
     bindings[memo.name] = value;
   }
+  {
+    const getterNames = collectAliasableGetterNames(metadata.signals, metadata.memos);
+    for (const [alias, origin] of resolveGetterAliases(metadata.localConstants ?? [], (n) => getterNames.has(n))) {
+      if (alias in out)
+        continue;
+      out[alias] = out[origin];
+    }
+  }
+  for (const [local, callerKey] of resolveBodyDestructuredPropAliases(metadata.localConstants ?? [], metadata.propsObjectName)) {
+    if (local in out)
+      continue;
+    const origin = out[callerKey];
+    if (origin)
+      out[local] = origin;
+  }
   if (metadata.propsObjectName !== null) {
     const referenced = new Set;
     for (const sig of metadata.signals) {