@barefootjs/jsx 0.34.0 → 0.35.1

package/dist/index.js

@@ -180,7 +180,7 @@ function findTopLevelTemplateLiterals(code) {
 import ts25 from "typescript";
 
 // src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 
 // src/expression-parser.ts
 import ts2 from "typescript";
@@ -2689,12 +2689,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;
@@ -2741,7 +2751,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;
 }
@@ -3028,6 +3038,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;
@@ -3260,6 +3284,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) {
@@ -3439,6 +3475,65 @@ class BindingScope {
   }
 }
 
+// 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);
+}
+
+// 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));
+}
+
 // src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -3608,22 +3703,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) {
@@ -3739,7 +3823,7 @@ function buildSpreadAttrsMergeCall(args) {
   return `\${spreadAttrs({${objMembers.join(", ")}})}`;
 }
 function itemAnchorTemplate(keyExpr) {
-  return `<!--${loopItemMarker("${" + keyExpr + "}")}-->`;
+  return `<!--${loopItemMarker("${escapeCommentText(" + keyExpr + ")}")}-->`;
 }
 function renderPreamble(preamble, opts) {
   let out = "";
@@ -3748,9 +3832,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;
@@ -3795,36 +3879,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 = {
@@ -3870,25 +3930,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("");
@@ -3914,7 +3966,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}`;
           }
         }
@@ -3925,7 +3977,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);
@@ -3943,12 +3995,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)}-->`;
     }
@@ -4207,20 +4259,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("");
@@ -4244,12 +4291,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)}-->`;
     }
@@ -4451,13 +4498,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) {
@@ -4467,7 +4509,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("");
@@ -4505,7 +4547,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 };
@@ -4515,7 +4557,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":
@@ -4603,7 +4645,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) {
@@ -4802,13 +4844,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) {
@@ -4818,7 +4855,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("");
@@ -4867,7 +4904,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);
@@ -4900,19 +4937,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":
@@ -5013,8 +5050,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);
@@ -5116,7 +5151,7 @@ function incrementCounter(key) {
 }
 
 // src/analyzer-context.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // src/strip-types.ts
 import ts8 from "typescript";
@@ -5333,6 +5368,140 @@ function findAngleBracketAfter(lastTypeArg, fullText) {
   return -1;
 }
 
+// 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;
+}
+
 // src/analyzer-context.ts
 function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
   return {
@@ -5384,7 +5553,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) {
@@ -5394,11 +5563,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());
@@ -5415,20 +5579,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);
 }
@@ -5439,56 +5603,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]) };
     }
@@ -5497,7 +5661,7 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
       raw
     };
   }
-  if (ts9.isFunctionTypeNode(typeNode)) {
+  if (ts10.isFunctionTypeNode(typeNode)) {
     if (synthetic)
       return { kind: "function", raw };
     return {
@@ -5517,15 +5681,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";
     }
@@ -5536,16 +5700,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;
 }
@@ -6191,9 +6355,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;
@@ -6212,21 +6376,21 @@ function createProgramForFile(source, filePath) {
   try {
     const normalizedPath = path_default.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: path_default.dirname(normalizedPath)
     };
-    const defaultHost = ts10.createCompilerHost(compilerOptions);
+    const defaultHost = ts11.createCompilerHost(compilerOptions);
     const virtualHost = {
       ...defaultHost,
       getSourceFile(fileName, languageVersion) {
         if (path_default.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);
       },
@@ -6241,7 +6405,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;
@@ -6274,7 +6438,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);
@@ -6320,23 +6484,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);
@@ -6346,22 +6510,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);
@@ -6376,9 +6540,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;
         }
       }
@@ -6392,10 +6556,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);
@@ -6407,10 +6571,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)) {
@@ -6421,19 +6585,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,
@@ -6461,24 +6625,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);
     }
@@ -6488,14 +6652,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);
@@ -6518,16 +6682,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;
@@ -6541,10 +6705,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);
@@ -6563,8 +6727,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), {
@@ -6575,34 +6739,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;
@@ -6610,22 +6774,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;
       }
     }
@@ -6634,16 +6798,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);
         }
@@ -6655,13 +6819,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);
       });
     }
@@ -6678,7 +6842,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))
@@ -6693,10 +6857,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))
@@ -6722,13 +6886,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)
@@ -6755,7 +6919,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 {
@@ -6771,14 +6935,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;
@@ -6786,7 +6950,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;
@@ -6799,22 +6963,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";
 }
@@ -6822,14 +6986,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;
@@ -6866,33 +7030,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 };
@@ -6987,30 +7151,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;
@@ -7027,7 +7191,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) {
@@ -7037,12 +7201,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;
@@ -7069,14 +7233,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";
 }
@@ -7091,7 +7255,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";
 }
@@ -7126,19 +7290,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;
         }
@@ -7146,17 +7310,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;
         }
@@ -7165,21 +7329,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);
@@ -7190,30 +7354,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;
@@ -7240,6 +7404,7 @@ var CLIENT_EXPORTS = new Set([
   "isSSRPortal",
   "findSiblingSlot",
   "cleanupPortalPlaceholder",
+  "trackPosition",
   "createSearchParams",
   "queryHref",
   "formatDate",
@@ -7247,35 +7412,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);
       }
     }
@@ -7286,7 +7451,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;
@@ -7314,7 +7479,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,
@@ -7325,7 +7490,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,
@@ -7352,7 +7517,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,
@@ -7365,20 +7530,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;
@@ -7395,9 +7560,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;
@@ -7407,7 +7572,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;
           }
@@ -7429,18 +7594,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;
         }
@@ -7450,7 +7615,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,
@@ -7471,18 +7636,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;
@@ -7498,12 +7663,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;
       }
@@ -7514,25 +7679,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);
     }
   }
@@ -7542,12 +7707,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;
@@ -7558,9 +7723,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;
     }
   }
@@ -7571,26 +7736,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) {
@@ -7660,7 +7825,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,
@@ -7681,10 +7846,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)
@@ -7696,46 +7861,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;
@@ -7744,29 +7909,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;
@@ -7776,22 +7941,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")
@@ -7799,12 +7964,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) => {
@@ -7818,11 +7983,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;
@@ -7870,20 +8035,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;
@@ -7905,7 +8070,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;
@@ -7923,9 +8088,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)) {
@@ -7933,9 +8098,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;
@@ -7955,9 +8120,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,
@@ -7970,9 +8135,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);
     }
   }
@@ -8050,7 +8215,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) {
@@ -8063,10 +8228,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;
@@ -8077,7 +8242,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 = {
@@ -8086,14 +8251,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;
@@ -8117,7 +8282,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);
@@ -8128,24 +8293,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;
       }
     }
@@ -8155,9 +8320,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));
     }
   }
@@ -8181,7 +8346,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,
@@ -8191,35 +8356,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);
       }
     }
@@ -8227,7 +8392,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" };
@@ -8243,17 +8408,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) {
@@ -8299,12 +8464,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;
@@ -8402,16 +8567,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;
@@ -8490,18 +8655,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;
@@ -8559,7 +8724,8 @@ var BROWSER_ONLY_CLIENT_APIS = new Set([
   "createPortal",
   "isSSRPortal",
   "findSiblingSlot",
-  "cleanupPortalPlaceholder"
+  "cleanupPortalPlaceholder",
+  "trackPosition"
 ]);
 function importsBrowserOnlyClientApi(ctx) {
   for (const imp of ctx.imports) {
@@ -8578,11 +8744,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)]
@@ -8590,11 +8756,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 {
@@ -8604,9 +8770,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([
@@ -8618,13 +8784,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;
@@ -8641,7 +8807,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;
@@ -8658,15 +8824,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,
@@ -8681,31 +8847,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);
@@ -8713,7 +8879,7 @@ function collectEntryBindingNames(sf) {
           names.add(n);
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sf);
   return names;
@@ -8722,19 +8888,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("../"))
@@ -8742,7 +8908,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) {
@@ -8780,14 +8946,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);
         }
@@ -8796,10 +8962,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;
@@ -8810,9 +8976,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;
@@ -8962,7 +9128,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);
@@ -8971,16 +9137,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")
@@ -8989,7 +9155,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)
@@ -8998,7 +9164,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);
       }
     }
@@ -9065,11 +9231,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)
@@ -9077,29 +9243,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;
   }
@@ -9107,18 +9273,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",
@@ -9139,7 +9305,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;
     }
@@ -9147,11 +9313,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);
     }
   }
@@ -9171,47 +9337,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) {
@@ -9259,18 +9425,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);
     }
@@ -9282,33 +9448,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);
@@ -9321,7 +9487,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);
     }
@@ -9343,7 +9509,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;
@@ -9452,21 +9618,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;
@@ -9495,20 +9661,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))
@@ -9535,7 +9701,7 @@ function validateReactiveFactoryCalls(ctx) {
         }));
         continue;
       }
-      if (ts10.isObjectBindingPattern(decl.name)) {
+      if (ts11.isObjectBindingPattern(decl.name)) {
         validateObjectFactoryDestructure(ctx, decl.name, callee, loc);
       }
     }
@@ -9544,25 +9710,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))
@@ -9595,11 +9761,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;
       }
     }
@@ -9616,7 +9782,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",
@@ -9624,7 +9790,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, {
@@ -9779,7 +9945,7 @@ var ESCAPE_SSR_COST = {
 };
 
 // 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) {
@@ -9880,21 +10046,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) {
@@ -9917,7 +10083,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;
 }
 function extractFunctionParams(value) {
   const arrowMatch = value.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
@@ -9955,102 +10121,6 @@ function stripClientBuiltinImports(imports) {
   return result;
 }
 
-// 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;
-}
-
 // src/free-refs.ts
 import ts13 from "typescript";
 var _bindingMapCache = new WeakMap;
@@ -10795,9 +10865,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)
@@ -11275,8 +11344,7 @@ function lowerFormControlValueSsr(tagName, attrs, children) {
     children.push({
       type: "expression",
       expr,
-      templateExpr: `escapeText(${templateExpr ?? expr})`,
-      escapeInClientTemplate: true,
+      templateExpr,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -11287,26 +11355,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);
@@ -11680,7 +11798,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);
@@ -14627,9 +14745,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;
 }
@@ -15012,10 +15131,10 @@ function getControlledPropName(signal, propsParams, propsObjectName = null) {
 }
 
 // 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,
@@ -15089,16 +15208,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" };
@@ -15261,9 +15386,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 }) => {
@@ -15273,7 +15398,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({
@@ -15296,9 +15421,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) {
@@ -15313,7 +15438,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({
@@ -15653,7 +15778,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 }) => {
@@ -15669,18 +15796,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) {
@@ -15722,14 +15848,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)
+          });
         }
       }
     });
@@ -15738,7 +15867,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 };
@@ -15906,6 +16035,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;
@@ -15917,6 +16047,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) {
@@ -15945,6 +16079,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         iterationShape: l.iterationShape,
         objectIteration: l.objectIteration,
         template,
+        templateIndexed,
         staticItemTemplate,
         skeletonTemplate,
         skeletonPaths,
@@ -16135,6 +16270,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 = "";
@@ -16143,6 +16279,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",
@@ -16158,6 +16298,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
         iterationShape: n.iterationShape,
         objectIteration: n.objectIteration,
         template: childTemplate,
+        templateIndexed: childTemplateIndexed,
         containerSlotId: containerSlot,
         preamble: n.preamble,
         preambleRegions: n.preambleRegions,
@@ -16240,19 +16381,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 }) => {
@@ -16264,9 +16396,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({
@@ -16284,7 +16416,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,
@@ -16850,6 +16982,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "escapeAttr",
   "escapeText",
   "escapeTextOrNode",
+  "escapeCommentText",
   "bfMarkup",
   "escapeTextOrMarkup",
   "markupOrEmpty",
@@ -17909,7 +18042,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));
@@ -18934,12 +19067,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) {
@@ -18972,17 +19105,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";
@@ -19026,8 +19159,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) {
@@ -19039,15 +19172,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";
@@ -19060,7 +19193,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);
   }
 }
 
@@ -19432,6 +19565,7 @@ function buildBranchInnerLoopsPlan(args) {
     condSlotId,
     outerLoopParam,
     outerLoopParamBindings,
+    outerLoopIndex,
     wrapOuter
   } = args;
   if (!innerLoops || innerLoops.length === 0)
@@ -19439,14 +19573,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_HOST2}="\${__scopeId}"][${BF_AT2}="${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 {
@@ -19502,18 +19636,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 = [];
@@ -19522,13 +19658,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({
@@ -19536,8 +19673,10 @@ function buildLoopChildConditionalsPlan(args) {
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
-      })
+      }),
+      ...cond.readsPreamble && { readsPreamble: true }
     });
   }
   return plans;
@@ -19561,7 +19700,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 }
       }))
     });
   }
@@ -19576,7 +19716,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,
@@ -19592,6 +19732,7 @@ function buildLoopChildArmPlan(args) {
       condSlotId: condId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19599,7 +19740,8 @@ function buildLoopChildArmPlan(args) {
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -19608,8 +19750,8 @@ function buildLoopChildArmPlan(args) {
 
 // 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);
@@ -19641,10 +19783,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 }
       });
     }
@@ -19656,7 +19798,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,
@@ -19673,6 +19815,7 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       condSlotId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19680,7 +19823,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)
@@ -19693,6 +19837,7 @@ function buildLoopReactiveEffectsPlan(elem, profileComponentName) {
     conditionals: elem.bindings.conditionals,
     loopParam: elem.param,
     loopParamBindings: elem.paramBindings,
+    loopIndex: elem.index,
     profileComponentName
   });
 }
@@ -19719,8 +19864,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) {
@@ -19742,15 +19887,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,
@@ -19764,17 +19908,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 {
@@ -19805,11 +19950,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,
@@ -19825,21 +19970,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",
@@ -19857,32 +20003,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)
-  };
-}
 
 // 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",
@@ -19896,26 +20023,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,
@@ -19932,7 +20062,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",
@@ -19946,26 +20076,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,
@@ -20100,7 +20233,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) {
@@ -20121,9 +20254,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: {
@@ -20142,7 +20272,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) {
@@ -20181,9 +20311,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);
@@ -20333,9 +20460,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`);
     }
@@ -20420,6 +20544,7 @@ function classifyLazyBinding(args) {
     }
     if (name === indexParam) {
       referencesIndex = true;
+      readsItem = true;
       return;
     }
     if (INERT_BINDING_GLOBALS.has(name))
@@ -20469,14 +20594,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;
@@ -20616,7 +20741,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
   };
@@ -20667,6 +20793,43 @@ function loopSourceIdentifiers(loop, arrayExpr) {
   return names;
 }
 
+// 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
+  };
+}
+
 // src/ir-to-client-js/control-flow/plan/build-branch-loop.ts
 function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const containerSlotId = loop.containerSlotId;
@@ -20681,16 +20844,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",
@@ -20703,30 +20868,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
@@ -20851,6 +21006,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;
@@ -21011,7 +21184,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)})`);
       }
@@ -21065,16 +21238,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("");
     }
   }
@@ -21127,6 +21302,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) {
@@ -21136,6 +21312,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;
@@ -21147,26 +21324,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)}) }`);
   }
 }
 
 // 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)}))`);
@@ -21209,7 +21391,7 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       lines.push(`${indent}  __bel${uid}.setAttribute('${keyAttrName(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);
@@ -21226,32 +21408,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);
@@ -21259,10 +21444,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) {
@@ -21301,13 +21486,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)})`);
@@ -21343,6 +21530,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: [] }))
@@ -21360,15 +21549,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}  }`);
   }
@@ -21397,16 +21585,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)})`);
 }
@@ -21549,6 +21737,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)
@@ -21578,6 +21768,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) {
@@ -21604,6 +21796,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) {
@@ -21669,24 +21863,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) {
@@ -21976,13 +22160,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)})`);
@@ -22007,18 +22194,12 @@ function stringifyStaticLoop(lines, plan) {
 // 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) => {`);
@@ -22044,7 +22225,7 @@ function emitReactive(lines, inner, indent, pc) {
     lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(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);
@@ -22063,17 +22244,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}  `,
@@ -22083,33 +22267,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('${keyAttrName(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}}) }`);
-}
 
 // src/ir-to-client-js/control-flow/stringify/composite-loop.ts
 function stringifyCompositeLoop(lines, plan) {
@@ -22128,6 +22285,7 @@ function stringifyCompositeLoop(lines, plan) {
     innerLoops,
     loopParam,
     loopParamBindings,
+    loopIndex,
     reactiveEffects,
     childRefs,
     branchClearChildren,
@@ -22160,7 +22318,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);
   }
@@ -22537,10 +22695,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)}))`);
@@ -22582,11 +22742,11 @@ function scopeRefToVar(ref) {
 // 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");
     }
@@ -22596,12 +22756,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;
@@ -22620,7 +22780,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: [],
@@ -22628,6 +22788,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
       conditionals: elem.bindings.conditionals,
       loopParam: elem.param,
       loopParamBindings: elem.paramBindings,
+      loopIndex: elem.index,
       profileComponentName
     }) : null
   };
@@ -22651,8 +22812,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 {
@@ -22678,12 +22837,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",
@@ -22695,28 +22857,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) {
@@ -22758,7 +22909,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
   };
@@ -23335,7 +23486,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) {
@@ -24072,6 +24223,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) {
@@ -29750,7 +29916,9 @@ export {
   rewriteDynamicImportsInSource,
   resolveStaticLoopSource,
   resolveSetters,
+  resolveGetterAliases,
   resolveDangerousInnerHtml,
+  resolveBodyDestructuredPropAliases,
   resetCompilerCounters,
   registerLoweringPlugin,
   registerBuiltinLoweringPlugins,
@@ -29863,6 +30031,7 @@ export {
   collectModuleStringConsts,
   collectLoopBoundNames,
   collectContextConsumers,
+  collectAliasableGetterNames,
   buildWhyUpdate,
   buildStaticBudget,
   buildSourceMapFromIR,