@barefootjs/vite 0.31.3 → 0.31.5

package/dist/index.js

@@ -3,7 +3,7 @@ import { mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } f
 import { relative as relative2, resolve as resolve7, sep as sep3 } from "node:path";
 
 // ../jsx/src/compiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 
 // ../jsx/src/analyzer.ts
 import ts9 from "typescript";
@@ -1655,6 +1655,24 @@ function templatePartsToJsExpr(parts, opts) {
   return result;
 }
 
+// ../jsx/src/identifier-pattern.ts
+function withUnicodeFlag(flags) {
+  return flags.includes("u") ? flags : `${flags}u`;
+}
+function escapeIdentifierForRegex(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ID_BOUNDARY_BEFORE = "(?<![\\p{ID_Continue}$])";
+var ID_BOUNDARY_AFTER = "(?![\\p{ID_Continue}$])";
+function identifierPattern(name, flags = "") {
+  const esc = escapeIdentifierForRegex(name);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}${ID_BOUNDARY_AFTER}`, withUnicodeFlag(flags));
+}
+function identifierCallPattern(name, flags = "") {
+  const esc = escapeIdentifierForRegex(name);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}\\s*\\(`, withUnicodeFlag(flags));
+}
+
 // ../jsx/src/scanner/js-scanner.ts
 import ts2 from "typescript";
 function* iterateJsTokens(text, start = 0, end = text.length) {
@@ -2227,9 +2245,6 @@ function inferDefaultValue(type) {
     return "{}";
   return "undefined";
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function freeIdsFromRefs(refs) {
   const out = new Set;
   if (!refs)
@@ -2357,16 +2372,16 @@ function wrapLoopParamAsAccessor(expr, paramName, bindings) {
   if (bindings && bindings.length > 0) {
     return rewriteLoopBindingRefs(expr, bindings, "__bfItem()");
   }
-  const re = new RegExp(`\\b${escapeRegExp(paramName)}\\b(?!\\s*\\()(?!-)`, "g");
-  return replaceInExprContexts(expr, re, `${paramName}()`);
+  const re = new RegExp(`${ID_BOUNDARY_BEFORE}${escapeIdentifierForRegex(paramName)}(?!\\s*\\()(?!-)${ID_BOUNDARY_AFTER}`, "gu");
+  return replaceInExprContexts(expr, re, () => `${paramName}()`);
 }
 function rewriteLoopBindingRefs(expr, bindings, accessor) {
   const byName = new Map;
   for (const b of bindings)
     byName.set(b.name, b);
   const preprocessed = expandShorthandBindings(expr, new Set(byName.keys()));
-  const alt = bindings.map((b) => escapeRegExp(b.name)).join("|");
-  const re = new RegExp(`\\b(${alt})\\b`, "g");
+  const alt = bindings.map((b) => escapeIdentifierForRegex(b.name)).join("|");
+  const re = new RegExp(`${ID_BOUNDARY_BEFORE}(${alt})${ID_BOUNDARY_AFTER}`, "gu");
   return replaceInExprContexts(preprocessed, re, (_m, name) => renderLoopBindingAccess(byName.get(name), accessor));
 }
 function expandShorthandBindings(expr, bindingNames) {
@@ -2633,7 +2648,7 @@ function stopAt(...kinds) {
 
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 import ts4 from "typescript";
-function csrSubstitute(value, env) {
+function csrSubstitute(value, env, enclosingScope) {
   if (!value || value.trim().length === 0) {
     return { rewritten: value, freeIdentifiers: new Set };
   }
@@ -2641,7 +2656,7 @@ function csrSubstitute(value, env) {
   let current = value;
   let lastFreeIdentifiers = new Set;
   for (let i = 0;i < maxIter; i++) {
-    const step = csrSubstituteOnce(current, env);
+    const step = csrSubstituteOnce(current, env, enclosingScope);
     lastFreeIdentifiers = step.freeIdentifiers;
     if (step.rewritten === current)
       break;
@@ -2649,7 +2664,7 @@ function csrSubstitute(value, env) {
   }
   return { rewritten: current, freeIdentifiers: lastFreeIdentifiers };
 }
-function csrSubstituteOnce(value, env) {
+function csrSubstituteOnce(value, env, enclosingScope) {
   if (!value || value.trim().length === 0) {
     return { rewritten: value, freeIdentifiers: new Set };
   }
@@ -2667,7 +2682,7 @@ function csrSubstituteOnce(value, env) {
       if (boundStack[i].has(name))
         return true;
     }
-    return false;
+    return enclosingScope?.isBound(name) ?? false;
   };
   const recordSubstitution = (start, end, sub) => {
     splices.push({ start: start - OFFSET, end: end - OFFSET, text: `(${sub.replacement})` });
@@ -2852,6 +2867,83 @@ function derivesScopeFromSlot(comp) {
   return comp.slotId != null && comp.loopItemRoot !== true;
 }
 
+// ../jsx/src/scope/binding-scope.ts
+class BindingScope {
+  frames;
+  static EMPTY = new BindingScope([]);
+  constructor(frames) {
+    this.frames = frames;
+  }
+  enterLoopRow(loop) {
+    const bindings = new Map;
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      for (const b of loop.paramBindings)
+        bindings.set(b.name, { source: "destructure" });
+    } else {
+      bindings.set(loop.param, { source: "item" });
+    }
+    if (loop.index != null)
+      bindings.set(loop.index, { source: "index" });
+    for (const name of loop.preamble?.declaredNames ?? [])
+      bindings.set(name, { source: "preamble" });
+    const frame = { kind: "loop-row", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  enterCallback(params) {
+    const bindings = new Map;
+    for (const name of params)
+      bindings.set(name, { source: "param" });
+    const frame = { kind: "callback", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  isBound(name) {
+    for (const frame of this.frames) {
+      if (frame.bindings.has(name))
+        return true;
+    }
+    return false;
+  }
+  lookup(name) {
+    for (let depth = 0;depth < this.frames.length; depth++) {
+      const frame = this.frames[depth];
+      const binding = frame.bindings.get(name);
+      if (binding)
+        return { depth, frame, binding };
+    }
+    return null;
+  }
+  boundNames() {
+    if (this.boundNamesCache)
+      return this.boundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const name of frame.bindings.keys())
+        names.add(name);
+    }
+    this.boundNamesCache = names;
+    return names;
+  }
+  boundNamesCache;
+  valueBoundNamesCache;
+  valueBoundNames() {
+    if (this.valueBoundNamesCache)
+      return this.valueBoundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const [name, binding] of frame.bindings) {
+        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+          names.add(name);
+        }
+      }
+    }
+    this.valueBoundNamesCache = names;
+    return names;
+  }
+  asShadowPredicate() {
+    return (name) => this.isBound(name);
+  }
+}
+
 // ../jsx/src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -4077,7 +4169,7 @@ function generateCsrTemplateWithOpts(node, opts) {
     const source = templateExpr ?? expr;
     if (!source)
       return source;
-    const { rewritten, freeIdentifiers: freeIdentifiers2 } = csrSubstitute(source, env);
+    const { rewritten, freeIdentifiers: freeIdentifiers2 } = csrSubstitute(source, env, opts.scope);
     if (unsafeLocalNames && unsafeLocalNames.size > 0 && setIntersects(freeIdentifiers2, unsafeLocalNames)) {
       return UNSAFE_TEMPLATE_EXPR;
     }
@@ -4219,15 +4311,8 @@ function generateCsrTemplateWithOpts(node, opts) {
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
-      const boundHere = new Set(opts.loopBoundNames ?? []);
-      if (node.paramBindings && node.paramBindings.length > 0) {
-        for (const b of node.paramBindings)
-          boundHere.add(b.name);
-      } else if (!node.param.startsWith("[") && !node.param.startsWith("{")) {
-        boundHere.add(node.param);
-      }
-      if (node.index)
-        boundHere.add(node.index);
+      const childScope = (opts.scope ?? BindingScope.EMPTY).enterLoopRow(node);
+      const boundHere = childScope.boundNames();
       const childEnv = {
         ...env,
         substitutions: new Map([...env.substitutions].filter(([name]) => !boundHere.has(name)))
@@ -4236,7 +4321,7 @@ function generateCsrTemplateWithOpts(node, opts) {
         ...opts,
         loopDepth: loopDepth + 1,
         inHoistedChildren: false,
-        loopBoundNames: boundHere,
+        scope: childScope,
         csrEnv: childEnv
       });
       let childTemplate = node.children.map(recurseInLoopBody).join("");
@@ -8576,7 +8661,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
 }
 
 // ../jsx/src/jsx-to-ir.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -8675,6 +8760,7 @@ function pickAttrMetaFromIR(src) {
 }
 
 // ../jsx/src/module-exports.ts
+import ts10 from "typescript";
 function generateModuleExports(ir, extraInlineExported = new Set, rewriteRelativeImport, options) {
   const lines = [];
   for (const constant of options?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -8754,7 +8840,7 @@ function findReachableNames(primaryRefs, declarations) {
   const reachable = new Set;
   const queue = [];
   for (const name of allNames) {
-    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+    if (identifierPattern(name).test(primaryRefs)) {
       reachable.add(name);
       queue.push(name);
     }
@@ -8763,7 +8849,7 @@ function findReachableNames(primaryRefs, declarations) {
     const current = queue.shift();
     const body = bodyMap.get(current) || "";
     for (const name of allNames) {
-      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+      if (!reachable.has(name) && identifierPattern(name).test(body)) {
         reachable.add(name);
         queue.push(name);
       }
@@ -8771,6 +8857,49 @@ function findReachableNames(primaryRefs, declarations) {
   }
   return reachable;
 }
+function findAssignedNames(bodyText, candidates) {
+  const assigned = new Set;
+  if (candidates.size === 0)
+    return assigned;
+  const sf = ts10.createSourceFile("bf-assignment-scan.tsx", bodyText, ts10.ScriptTarget.Latest, false, ts10.ScriptKind.TSX);
+  const record = (target) => {
+    if (ts10.isIdentifier(target) && candidates.has(target.text)) {
+      assigned.add(target.text);
+    }
+  };
+  const visit2 = (node) => {
+    if (ts10.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+      record(node.left);
+    } else if ((ts10.isPrefixUnaryExpression(node) || ts10.isPostfixUnaryExpression(node)) && (node.operator === ts10.SyntaxKind.PlusPlusToken || node.operator === ts10.SyntaxKind.MinusMinusToken)) {
+      record(node.operand);
+    }
+    ts10.forEachChild(node, visit2);
+  };
+  ts10.forEachChild(sf, visit2);
+  return assigned;
+}
+function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
+  let reachable = findReachableNames(primaryRefs, declarations);
+  if (mutableNames.size === 0)
+    return reachable;
+  let seedText = primaryRefs;
+  for (let round = 0;round <= declarations.length; round++) {
+    const survivingMutables = new Set([...reachable].filter((name) => mutableNames.has(name)));
+    if (survivingMutables.size === 0)
+      return reachable;
+    const added = declarations.filter((d) => !reachable.has(d.name)).filter((d) => findAssignedNames(d.body, survivingMutables).size > 0).map((d) => d.name);
+    if (added.length === 0)
+      return reachable;
+    seedText += `
+` + added.join(`
+`);
+    reachable = findReachableNames(seedText, declarations);
+  }
+  return reachable;
+}
+function isAssignmentOperator(kind) {
+  return kind >= ts10.SyntaxKind.FirstAssignment && kind <= ts10.SyntaxKind.LastAssignment;
+}
 
 // ../jsx/src/builtins.ts
 var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
@@ -8793,7 +8922,7 @@ function stripClientBuiltinImports(imports) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var REACTIVE_BRAND = "__reactive";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
@@ -8811,7 +8940,7 @@ function safeGetText(node) {
   }
 }
 function analyze(node, checker) {
-  if (ts10.isPropertyAccessExpression(node)) {
+  if (ts11.isPropertyAccessExpression(node)) {
     try {
       const type = queryType(checker, node);
       if (isReactiveType(type)) {
@@ -8835,7 +8964,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (ts10.isIdentifier(node)) {
+  if (ts11.isIdentifier(node)) {
     try {
       const type = queryType(checker, node);
       if (isReactiveType(type)) {
@@ -8847,7 +8976,7 @@ function analyze(node, checker) {
     } catch {}
     return NOT_REACTIVE;
   }
-  if (ts10.isCallExpression(node)) {
+  if (ts11.isCallExpression(node)) {
     try {
       const calleeType = queryType(checker, node.expression);
       if (isReactiveType(calleeType)) {
@@ -8860,7 +8989,7 @@ function analyze(node, checker) {
   }
   let foundChild;
   let foundChildText = "";
-  ts10.forEachChild(node, (child) => {
+  ts11.forEachChild(node, (child) => {
     if (foundChild?.isReactive)
       return;
     const result = analyze(child, checker);
@@ -8889,7 +9018,7 @@ function containsReactiveExpression(node, checker) {
 }
 
 // ../jsx/src/free-refs.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 var _bindingMapCache = new WeakMap;
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
@@ -8927,8 +9056,8 @@ function buildBindingMap(env) {
   for (const m of env.memos) {
     map.set(m.name, "memo-getter");
   }
-  if (env.loopParams) {
-    for (const name of env.loopParams)
+  if (env.loopValueBoundNames) {
+    for (const name of env.loopValueBoundNames)
       map.set(name, "render-item");
   }
   _bindingMapCache.set(env, map);
@@ -8957,20 +9086,20 @@ function defaultBindingScope(kind) {
 function collectIdentifiers2(node) {
   const out = [];
   const visit2 = (n, parent) => {
-    if (ts11.isIdentifier(n)) {
-      if (parent && ts11.isPropertyAccessExpression(parent) && parent.name === n)
+    if (ts12.isIdentifier(n)) {
+      if (parent && ts12.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts11.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts12.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && (ts11.isJsxOpeningElement(parent) || ts11.isJsxClosingElement(parent) || ts11.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
+      if (parent && (ts12.isJsxOpeningElement(parent) || ts12.isJsxClosingElement(parent) || ts12.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
         return;
       }
-      if (parent && ts11.isJsxAttribute(parent) && parent.name === n)
+      if (parent && ts12.isJsxAttribute(parent) && parent.name === n)
         return;
       out.push(n);
       return;
     }
-    ts11.forEachChild(n, (child) => visit2(child, n));
+    ts12.forEachChild(n, (child) => visit2(child, n));
   };
   visit2(node);
   return out;
@@ -8979,7 +9108,7 @@ function collectReactiveBrandRefs(node, checker) {
   const out = [];
   const seen = new Set;
   const visit2 = (n) => {
-    if (ts11.isPropertyAccessExpression(n)) {
+    if (ts12.isPropertyAccessExpression(n)) {
       try {
         const type = checker.getTypeAtLocation(n);
         if (isReactiveType(type)) {
@@ -8997,7 +9126,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    ts11.forEachChild(n, visit2);
+    ts12.forEachChild(n, visit2);
   };
   visit2(node);
   return out;
@@ -9007,14 +9136,14 @@ function resolveConstantInitializerRefs(c, env, visited) {
     return [];
   if (c.containsArrow)
     return [];
-  const sf = ts11.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, ts11.ScriptTarget.Latest, true);
+  const sf = ts12.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, ts12.ScriptTarget.Latest, true);
   const stmt = sf.statements[0];
-  if (!stmt || !ts11.isVariableStatement(stmt))
+  if (!stmt || !ts12.isVariableStatement(stmt))
     return [];
   const decl = stmt.declarationList.declarations[0];
   if (!decl || !decl.initializer)
     return [];
-  const expr = ts11.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  const expr = ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
   return resolveFreeRefsInternal(expr, env, visited);
 }
 function resolveFreeRefsInternal(node, env, visited) {
@@ -9026,7 +9155,7 @@ function resolveFreeRefsInternal(node, env, visited) {
     const name = ident.text;
     if (env.propsObjectName === name) {
       const parent = ident.parent;
-      if (parent && ts11.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
+      if (parent && ts12.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
         continue;
       }
     }
@@ -9429,83 +9558,6 @@ var toLocaleDatePlugin = {
   }
 };
 
-// ../jsx/src/scope/binding-scope.ts
-class BindingScope {
-  frames;
-  static EMPTY = new BindingScope([]);
-  constructor(frames) {
-    this.frames = frames;
-  }
-  enterLoopRow(loop) {
-    const bindings = new Map;
-    if (loop.paramBindings && loop.paramBindings.length > 0) {
-      for (const b of loop.paramBindings)
-        bindings.set(b.name, { source: "destructure" });
-    } else {
-      bindings.set(loop.param, { source: "item" });
-    }
-    if (loop.index != null)
-      bindings.set(loop.index, { source: "index" });
-    for (const name of loop.preamble?.declaredNames ?? [])
-      bindings.set(name, { source: "preamble" });
-    const frame = { kind: "loop-row", bindings };
-    return new BindingScope([frame, ...this.frames]);
-  }
-  enterCallback(params) {
-    const bindings = new Map;
-    for (const name of params)
-      bindings.set(name, { source: "param" });
-    const frame = { kind: "callback", bindings };
-    return new BindingScope([frame, ...this.frames]);
-  }
-  isBound(name) {
-    for (const frame of this.frames) {
-      if (frame.bindings.has(name))
-        return true;
-    }
-    return false;
-  }
-  lookup(name) {
-    for (let depth = 0;depth < this.frames.length; depth++) {
-      const frame = this.frames[depth];
-      const binding = frame.bindings.get(name);
-      if (binding)
-        return { depth, frame, binding };
-    }
-    return null;
-  }
-  boundNames() {
-    if (this.boundNamesCache)
-      return this.boundNamesCache;
-    const names = new Set;
-    for (const frame of this.frames) {
-      for (const name of frame.bindings.keys())
-        names.add(name);
-    }
-    this.boundNamesCache = names;
-    return names;
-  }
-  boundNamesCache;
-  valueBoundNamesCache;
-  valueBoundNames() {
-    if (this.valueBoundNamesCache)
-      return this.valueBoundNamesCache;
-    const names = new Set;
-    for (const frame of this.frames) {
-      for (const [name, binding] of frame.bindings) {
-        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
-          names.add(name);
-        }
-      }
-    }
-    this.valueBoundNamesCache = names;
-    return names;
-  }
-  asShadowPredicate() {
-    return (name) => this.isBound(name);
-  }
-}
-
 // ../jsx/src/jsx-to-ir.ts
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
@@ -9531,13 +9583,13 @@ function exprCallsReactiveGetters(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression)) {
       if (names.has(n.expression.text)) {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -9564,11 +9616,11 @@ function exprReferencesModuleClientSignal(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression) && names.has(n.expression.text)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression) && names.has(n.expression.text)) {
       found = true;
       return;
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -9578,11 +9630,11 @@ function exprHasFunctionCalls(expr) {
   function visit2(n) {
     if (found)
       return;
-    if (ts12.isCallExpression(n)) {
+    if (ts13.isCallExpression(n)) {
       found = true;
       return;
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -9619,10 +9671,10 @@ function lowerDateCalls(text, expr, ctx) {
     return text;
   const candidates = [];
   function visit2(n) {
-    if (ts12.isCallExpression(n) && n.arguments.length === 0 && ts12.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts13.isCallExpression(n) && n.arguments.length === 0 && ts13.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   }
   visit2(expr);
   if (candidates.length === 0)
@@ -9647,10 +9699,10 @@ function lowerToLocaleDateCalls(text, expr, ctx) {
     return text;
   const candidates = [];
   function visit2(n) {
-    if (ts12.isCallExpression(n) && n.arguments.length === 2 && ts12.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts13.isCallExpression(n) && n.arguments.length === 2 && ts13.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   }
   visit2(expr);
   if (candidates.length === 0)
@@ -9704,10 +9756,10 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
     return;
   let acc;
   function visit2(n, parent) {
-    if (ts12.isIdentifier(n) && propDepsMap.has(n.text)) {
-      const isObjectKey = parent && ts12.isPropertyAssignment(parent) && parent.name === n;
-      const isShorthand = parent && ts12.isShorthandPropertyAssignment(parent) && parent.name === n;
-      const isAccessName = parent && ts12.isPropertyAccessExpression(parent) && parent.name === n;
+    if (ts13.isIdentifier(n) && propDepsMap.has(n.text)) {
+      const isObjectKey = parent && ts13.isPropertyAssignment(parent) && parent.name === n;
+      const isShorthand = parent && ts13.isShorthandPropertyAssignment(parent) && parent.name === n;
+      const isAccessName = parent && ts13.isPropertyAccessExpression(parent) && parent.name === n;
       if (!isObjectKey && !isShorthand && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
@@ -9718,7 +9770,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
         }
       }
     }
-    ts12.forEachChild(n, (child) => visit2(child, n));
+    ts13.forEachChild(n, (child) => visit2(child, n));
   }
   visit2(node);
   return acc;
@@ -9769,17 +9821,17 @@ function createTransformContext(analyzer) {
     patterns: {
       signals: analyzer.signals.map((s) => ({
         getter: s.getter,
-        pattern: new RegExp(`\\b${s.getter}\\s*\\(`)
+        pattern: identifierCallPattern(s.getter)
       })),
       memos: analyzer.memos.map((m) => ({
         name: m.name,
-        pattern: new RegExp(`\\b${m.name}\\s*\\(`)
+        pattern: identifierCallPattern(m.name)
       })),
-      props: analyzer.propsParams.filter((p) => p.name !== "children").map((p) => ({ name: p.name, pattern: new RegExp(`\\b${p.name}\\b`) })),
+      props: analyzer.propsParams.filter((p) => p.name !== "children").map((p) => ({ name: p.name, pattern: identifierPattern(p.name) })),
       constants: analyzer.localConstants.map((c) => ({
         name: c.name,
         value: c.value,
-        pattern: new RegExp(`\\b${c.name}\\b`)
+        pattern: identifierPattern(c.name)
       }))
     },
     getJS(node) {
@@ -9794,21 +9846,21 @@ function createTransformContext(analyzer) {
 function buildComponentNamespaces(ctx) {
   const result = new Map;
   for (const stmt of ctx.sourceFile.statements) {
-    if (!ts12.isVariableStatement(stmt))
+    if (!ts13.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts12.isIdentifier(decl.name))
+      if (!decl.initializer || !ts13.isIdentifier(decl.name))
         continue;
       let init = decl.initializer;
-      while (ts12.isParenthesizedExpression(init))
+      while (ts13.isParenthesizedExpression(init))
         init = init.expression;
-      if (!ts12.isObjectLiteralExpression(init))
+      if (!ts13.isObjectLiteralExpression(init))
         continue;
       const members = new Map;
       for (const prop of init.properties) {
-        if (ts12.isShorthandPropertyAssignment(prop)) {
+        if (ts13.isShorthandPropertyAssignment(prop)) {
           members.set(prop.name.text, prop.name.text);
-        } else if (ts12.isPropertyAssignment(prop) && (ts12.isIdentifier(prop.name) || ts12.isStringLiteral(prop.name)) && ts12.isIdentifier(prop.initializer)) {
+        } else if (ts13.isPropertyAssignment(prop) && (ts13.isIdentifier(prop.name) || ts13.isStringLiteral(prop.name)) && ts13.isIdentifier(prop.initializer)) {
           members.set(prop.name.text, prop.initializer.text);
         }
       }
@@ -9820,11 +9872,11 @@ function buildComponentNamespaces(ctx) {
   return result;
 }
 function resolveMemberExpressionTag(tagNode, ctx) {
-  if (!ts12.isPropertyAccessExpression(tagNode))
+  if (!ts13.isPropertyAccessExpression(tagNode))
     return null;
-  if (!ts12.isIdentifier(tagNode.expression))
+  if (!ts13.isIdentifier(tagNode.expression))
     return null;
-  if (!ts12.isIdentifier(tagNode.name))
+  if (!ts13.isIdentifier(tagNode.name))
     return null;
   if (!ctx._componentNamespaces) {
     ctx._componentNamespaces = buildComponentNamespaces(ctx);
@@ -9857,7 +9909,7 @@ function makeBindingEnv(ctx) {
     localFunctions: a.localFunctions,
     imports: a.imports,
     ambientGlobals: a.ambientGlobals,
-    loopParams: boundNames,
+    loopValueBoundNames: boundNames,
     checker: a.checker
   };
   ctx._bindingEnv = env;
@@ -9981,7 +10033,7 @@ function buildIRRoot(analyzer) {
     return null;
   const ctx = createTransformContext(analyzer);
   const jsxReturn = analyzer.jsxReturn;
-  if (ts12.isJsxElement(jsxReturn) || ts12.isJsxSelfClosingElement(jsxReturn) || ts12.isJsxFragment(jsxReturn)) {
+  if (ts13.isJsxElement(jsxReturn) || ts13.isJsxSelfClosingElement(jsxReturn) || ts13.isJsxFragment(jsxReturn)) {
     const ir2 = transformNode(jsxReturn, ctx);
     if (ir2 && needsScopeWrapper(ir2)) {
       return wrapInScopeElement(ir2);
@@ -10037,22 +10089,22 @@ function wrapInScopeElement(node) {
   };
 }
 function transformNode(node, ctx) {
-  if (ts12.isJsxElement(node)) {
+  if (ts13.isJsxElement(node)) {
     return transformJsxElement(node, ctx);
   }
-  if (ts12.isJsxSelfClosingElement(node)) {
+  if (ts13.isJsxSelfClosingElement(node)) {
     return transformSelfClosingElement(node, ctx);
   }
-  if (ts12.isJsxFragment(node)) {
+  if (ts13.isJsxFragment(node)) {
     return transformFragment(node, ctx);
   }
-  if (ts12.isJsxText(node)) {
+  if (ts13.isJsxText(node)) {
     return transformText(node, ctx);
   }
-  if (ts12.isJsxExpression(node)) {
+  if (ts13.isJsxExpression(node)) {
     return transformExpression(node, ctx);
   }
-  if (ts12.isConditionalExpression(node)) {
+  if (ts13.isConditionalExpression(node)) {
     return transformConditional(node, ctx);
   }
   return null;
@@ -10409,7 +10461,7 @@ function transformSelfClosingComponent(node, ctx, name) {
 }
 function isTransparentFragment(node, ctx) {
   const children = node.children.filter((child2) => {
-    if (ts12.isJsxText(child2)) {
+    if (ts13.isJsxText(child2)) {
       return child2.text.trim() !== "";
     }
     return true;
@@ -10417,7 +10469,7 @@ function isTransparentFragment(node, ctx) {
   if (children.length !== 1)
     return false;
   const child = children[0];
-  if (!ts12.isJsxExpression(child))
+  if (!ts13.isJsxExpression(child))
     return false;
   if (!child.expression)
     return false;
@@ -10461,7 +10513,7 @@ function transformChildren(children, ctx) {
   const result = [];
   for (let i = 0;i < children.length; i++) {
     const child = children[i];
-    if (ts12.isJsxExpression(child) && !child.expression) {
+    if (ts13.isJsxExpression(child) && !child.expression) {
       continue;
     }
     const transformed = transformNode(child, ctx);
@@ -10476,10 +10528,10 @@ function transformChildren(children, ctx) {
 }
 function isRenderNothingLiteral(expr, ctx) {
   let e = expr;
-  while (ts12.isParenthesizedExpression(e) || ts12.isAsExpression(e) || ts12.isSatisfiesExpression(e) || ts12.isNonNullExpression(e)) {
+  while (ts13.isParenthesizedExpression(e) || ts13.isAsExpression(e) || ts13.isSatisfiesExpression(e) || ts13.isNonNullExpression(e)) {
     e = e.expression;
   }
-  return e.kind === ts12.SyntaxKind.NullKeyword || e.kind === ts12.SyntaxKind.TrueKeyword || e.kind === ts12.SyntaxKind.FalseKeyword || ts12.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx));
+  return e.kind === ts13.SyntaxKind.NullKeyword || e.kind === ts13.SyntaxKind.TrueKeyword || e.kind === ts13.SyntaxKind.FalseKeyword || ts13.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx));
 }
 function transformText(node, ctx) {
   const text = node.text.replace(/\s+/g, " ");
@@ -10505,7 +10557,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
     return null;
   }
   checkBareSignalOrMemoIdentifier(expr, ctx);
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
       return transformNode(jsxNode, ctx);
@@ -10551,7 +10603,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   };
   const reactive = isReactiveExpression(exprText, ctx, expr) || isReactiveOrigin(origin);
   const scopeValueNames = ctx.scope.valueBoundNames();
-  const refsLoopParam = scopeValueNames.size > 0 && Array.from(scopeValueNames).some((p) => new RegExp(`\\b${p}\\b`).test(exprText));
+  const refsLoopParam = scopeValueNames.size > 0 && Array.from(scopeValueNames).some((p) => identifierPattern(p).test(exprText));
   const callsReactive = exprCallsReactiveGetters(expr, ctx);
   const hasCalls = exprHasFunctionCalls(expr);
   const needsSlot = reactive || isClientOnly || refsLoopParam || callsReactive || hasCalls;
@@ -10586,7 +10638,7 @@ function transformJsxFunctionCall(callExpr, jsxFunc, ctx, _isClientOnly) {
   const substitutedGetJS = (node) => {
     let text = baseGetJS(node);
     for (const [paramName, argExpr] of substitutions) {
-      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+      text = text.replace(identifierPattern(paramName, "g"), () => argExpr);
     }
     return text;
   };
@@ -10628,7 +10680,7 @@ function transformMultiReturnJsxFunctionCall(callExpr, info, ctx) {
   const substitutedGetJS = (node) => {
     let text = baseGetJS(node);
     for (const [paramName, argExpr] of substitutions) {
-      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+      text = text.replace(identifierPattern(paramName, "g"), () => argExpr);
     }
     return text;
   };
@@ -10784,38 +10836,38 @@ function transformLogicalAnd(node, ctx) {
   };
 }
 function containsJsxInExpression(node) {
-  if (ts12.isJsxElement(node) || ts12.isJsxSelfClosingElement(node) || ts12.isJsxFragment(node)) {
+  if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node)) {
     return true;
   }
-  return ts12.forEachChild(node, containsJsxInExpression) ?? false;
+  return ts13.forEachChild(node, containsJsxInExpression) ?? false;
 }
 function callsJsxHelper(node, ctx) {
   let found = false;
   const visit2 = (n) => {
     if (found)
       return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression)) {
       const name = n.expression.text;
       if (ctx.analyzer.jsxFunctions.has(name) || ctx.analyzer.jsxMultiReturnFunctions.has(name)) {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   };
   visit2(node);
   return found;
 }
 function containsAwaitExpression(node) {
-  if (ts12.isAwaitExpression(node))
+  if (ts13.isAwaitExpression(node))
     return true;
-  if (ts12.isFunctionDeclaration(node) || ts12.isFunctionExpression(node) || ts12.isArrowFunction(node))
+  if (ts13.isFunctionDeclaration(node) || ts13.isFunctionExpression(node) || ts13.isArrowFunction(node))
     return false;
-  return ts12.forEachChild(node, containsAwaitExpression) ?? false;
+  return ts13.forEachChild(node, containsAwaitExpression) ?? false;
 }
 function transformNullishCoalescing(node, ctx) {
   const leftText = ctx.getJS(node.left);
-  const isNullish = node.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken;
+  const isNullish = node.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken;
   const condition = isNullish ? `${leftText} != null` : leftText;
   const leftOrigin = {
     phase: "tick",
@@ -10861,36 +10913,36 @@ function transformNullishCoalescing(node, ctx) {
 }
 function assertNever2(expr) {
   const kind = expr?.kind;
-  throw new Error(`transformJsxExpression: unhandled ts.SyntaxKind ${kind !== undefined ? ts12.SyntaxKind[kind] : "unknown"} ` + `(kind=${kind}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`);
+  throw new Error(`transformJsxExpression: unhandled ts.SyntaxKind ${kind !== undefined ? ts13.SyntaxKind[kind] : "unknown"} ` + `(kind=${kind}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`);
 }
 function transformJsxExpression(expr, ctx, isClientOnly = false) {
   const node = expr;
   switch (node.kind) {
-    case ts12.SyntaxKind.ParenthesizedExpression:
-    case ts12.SyntaxKind.AsExpression:
-    case ts12.SyntaxKind.SatisfiesExpression:
-    case ts12.SyntaxKind.NonNullExpression:
-    case ts12.SyntaxKind.TypeAssertionExpression:
-    case ts12.SyntaxKind.PartiallyEmittedExpression:
+    case ts13.SyntaxKind.ParenthesizedExpression:
+    case ts13.SyntaxKind.AsExpression:
+    case ts13.SyntaxKind.SatisfiesExpression:
+    case ts13.SyntaxKind.NonNullExpression:
+    case ts13.SyntaxKind.TypeAssertionExpression:
+    case ts13.SyntaxKind.PartiallyEmittedExpression:
       return transformJsxExpression(node.expression, ctx, isClientOnly);
-    case ts12.SyntaxKind.JsxElement:
+    case ts13.SyntaxKind.JsxElement:
       return transformJsxElement(node, ctx);
-    case ts12.SyntaxKind.JsxFragment:
+    case ts13.SyntaxKind.JsxFragment:
       return transformFragment(node, ctx);
-    case ts12.SyntaxKind.JsxSelfClosingElement:
+    case ts13.SyntaxKind.JsxSelfClosingElement:
       return transformSelfClosingElement(node, ctx);
-    case ts12.SyntaxKind.ConditionalExpression:
+    case ts13.SyntaxKind.ConditionalExpression:
       return transformConditional(node, ctx);
-    case ts12.SyntaxKind.BinaryExpression: {
-      if (node.operatorToken.kind === ts12.SyntaxKind.AmpersandAmpersandToken) {
+    case ts13.SyntaxKind.BinaryExpression: {
+      if (node.operatorToken.kind === ts13.SyntaxKind.AmpersandAmpersandToken) {
         return transformLogicalAnd(node, ctx);
       }
-      if ((node.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts12.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx))) {
+      if ((node.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts13.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx))) {
         return transformNullishCoalescing(node, ctx);
       }
       return null;
     }
-    case ts12.SyntaxKind.CallExpression: {
+    case ts13.SyntaxKind.CallExpression: {
       const mapMethod = getMapLikeMethod(node);
       if (mapMethod) {
         const mapResult = transformMapCall(node, ctx, isClientOnly, mapMethod);
@@ -10898,7 +10950,7 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
           return mapResult;
       }
       const callee = node.expression;
-      if (ts12.isIdentifier(callee)) {
+      if (ts13.isIdentifier(callee)) {
         const jsxFunc = ctx.analyzer.jsxFunctions.get(callee.text);
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx, isClientOnly);
@@ -10910,39 +10962,39 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
       }
       return null;
     }
-    case ts12.SyntaxKind.Identifier:
-    case ts12.SyntaxKind.StringLiteral:
-    case ts12.SyntaxKind.NumericLiteral:
-    case ts12.SyntaxKind.BigIntLiteral:
-    case ts12.SyntaxKind.RegularExpressionLiteral:
-    case ts12.SyntaxKind.NoSubstitutionTemplateLiteral:
-    case ts12.SyntaxKind.TemplateExpression:
-    case ts12.SyntaxKind.TaggedTemplateExpression:
-    case ts12.SyntaxKind.TrueKeyword:
-    case ts12.SyntaxKind.FalseKeyword:
-    case ts12.SyntaxKind.NullKeyword:
-    case ts12.SyntaxKind.ThisKeyword:
-    case ts12.SyntaxKind.SuperKeyword:
-    case ts12.SyntaxKind.ImportKeyword:
-    case ts12.SyntaxKind.PropertyAccessExpression:
-    case ts12.SyntaxKind.ElementAccessExpression:
-    case ts12.SyntaxKind.PrefixUnaryExpression:
-    case ts12.SyntaxKind.PostfixUnaryExpression:
-    case ts12.SyntaxKind.TypeOfExpression:
-    case ts12.SyntaxKind.VoidExpression:
-    case ts12.SyntaxKind.DeleteExpression:
-    case ts12.SyntaxKind.NewExpression:
-    case ts12.SyntaxKind.ObjectLiteralExpression:
-    case ts12.SyntaxKind.ArrowFunction:
-    case ts12.SyntaxKind.FunctionExpression:
-    case ts12.SyntaxKind.ClassExpression:
-    case ts12.SyntaxKind.MetaProperty:
-    case ts12.SyntaxKind.ExpressionWithTypeArguments:
-    case ts12.SyntaxKind.CommaListExpression:
-    case ts12.SyntaxKind.SyntheticExpression:
-    case ts12.SyntaxKind.ArrayLiteralExpression:
+    case ts13.SyntaxKind.Identifier:
+    case ts13.SyntaxKind.StringLiteral:
+    case ts13.SyntaxKind.NumericLiteral:
+    case ts13.SyntaxKind.BigIntLiteral:
+    case ts13.SyntaxKind.RegularExpressionLiteral:
+    case ts13.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case ts13.SyntaxKind.TemplateExpression:
+    case ts13.SyntaxKind.TaggedTemplateExpression:
+    case ts13.SyntaxKind.TrueKeyword:
+    case ts13.SyntaxKind.FalseKeyword:
+    case ts13.SyntaxKind.NullKeyword:
+    case ts13.SyntaxKind.ThisKeyword:
+    case ts13.SyntaxKind.SuperKeyword:
+    case ts13.SyntaxKind.ImportKeyword:
+    case ts13.SyntaxKind.PropertyAccessExpression:
+    case ts13.SyntaxKind.ElementAccessExpression:
+    case ts13.SyntaxKind.PrefixUnaryExpression:
+    case ts13.SyntaxKind.PostfixUnaryExpression:
+    case ts13.SyntaxKind.TypeOfExpression:
+    case ts13.SyntaxKind.VoidExpression:
+    case ts13.SyntaxKind.DeleteExpression:
+    case ts13.SyntaxKind.NewExpression:
+    case ts13.SyntaxKind.ObjectLiteralExpression:
+    case ts13.SyntaxKind.ArrowFunction:
+    case ts13.SyntaxKind.FunctionExpression:
+    case ts13.SyntaxKind.ClassExpression:
+    case ts13.SyntaxKind.MetaProperty:
+    case ts13.SyntaxKind.ExpressionWithTypeArguments:
+    case ts13.SyntaxKind.CommaListExpression:
+    case ts13.SyntaxKind.SyntheticExpression:
+    case ts13.SyntaxKind.ArrayLiteralExpression:
       return null;
-    case ts12.SyntaxKind.AwaitExpression:
+    case ts13.SyntaxKind.AwaitExpression:
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(node, ctx.sourceFile, ctx.filePath)));
       return {
         type: "expression",
@@ -10953,16 +11005,16 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
         loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
         origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
       };
-    case ts12.SyntaxKind.YieldExpression:
+    case ts13.SyntaxKind.YieldExpression:
       return null;
-    case ts12.SyntaxKind.SpreadElement:
-    case ts12.SyntaxKind.OmittedExpression:
-    case ts12.SyntaxKind.JsxExpression:
-    case ts12.SyntaxKind.JsxOpeningElement:
-    case ts12.SyntaxKind.JsxOpeningFragment:
-    case ts12.SyntaxKind.JsxClosingFragment:
-    case ts12.SyntaxKind.JsxAttributes:
-    case ts12.SyntaxKind.MissingDeclaration:
+    case ts13.SyntaxKind.SpreadElement:
+    case ts13.SyntaxKind.OmittedExpression:
+    case ts13.SyntaxKind.JsxExpression:
+    case ts13.SyntaxKind.JsxOpeningElement:
+    case ts13.SyntaxKind.JsxOpeningFragment:
+    case ts13.SyntaxKind.JsxClosingFragment:
+    case ts13.SyntaxKind.JsxAttributes:
+    case ts13.SyntaxKind.MissingDeclaration:
       return null;
     default:
       return assertNever2(node);
@@ -10999,7 +11051,7 @@ function transformConditionalBranch(node, ctx) {
   };
 }
 function getMapLikeMethod(node) {
-  if (!ts12.isPropertyAccessExpression(node.expression))
+  if (!ts13.isPropertyAccessExpression(node.expression))
     return null;
   const name = node.expression.name.text;
   if (name === "map")
@@ -11009,9 +11061,9 @@ function getMapLikeMethod(node) {
   return null;
 }
 function isFilterCall(node) {
-  if (!ts12.isCallExpression(node))
+  if (!ts13.isCallExpression(node))
     return null;
-  if (!ts12.isPropertyAccessExpression(node.expression))
+  if (!ts13.isPropertyAccessExpression(node.expression))
     return null;
   if (node.expression.name.text !== "filter")
     return null;
@@ -11023,9 +11075,9 @@ function isFilterCall(node) {
   };
 }
 function isSortCall(node) {
-  if (!ts12.isCallExpression(node))
+  if (!ts13.isCallExpression(node))
     return null;
-  if (!ts12.isPropertyAccessExpression(node.expression))
+  if (!ts13.isPropertyAccessExpression(node.expression))
     return null;
   const methodName = node.expression.name.text;
   if (methodName !== "sort" && methodName !== "toSorted")
@@ -11039,9 +11091,9 @@ function isSortCall(node) {
   };
 }
 function isIteratorShapeCall(node) {
-  if (!ts12.isCallExpression(node))
+  if (!ts13.isCallExpression(node))
     return null;
-  if (!ts12.isPropertyAccessExpression(node.expression))
+  if (!ts13.isPropertyAccessExpression(node.expression))
     return null;
   if (node.arguments.length !== 0)
     return null;
@@ -11051,11 +11103,11 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name };
 }
 function isObjectIteratorCall(node) {
-  if (!ts12.isCallExpression(node))
+  if (!ts13.isCallExpression(node))
     return null;
-  if (!ts12.isPropertyAccessExpression(node.expression))
+  if (!ts13.isPropertyAccessExpression(node.expression))
     return null;
-  if (!ts12.isIdentifier(node.expression.expression))
+  if (!ts13.isIdentifier(node.expression.expression))
     return null;
   if (node.expression.expression.text !== "Object")
     return null;
@@ -11080,7 +11132,7 @@ function extractSortComparator(callback, _method, ctx) {
 ` + `(reverse the operands for descending order).`
   });
   let resolvedNode = callback;
-  if (ts12.isIdentifier(callback)) {
+  if (ts13.isIdentifier(callback)) {
     const resolved = resolveSortComparatorIdentifier(callback.text, ctx);
     if (!resolved) {
       return {
@@ -11090,7 +11142,7 @@ function extractSortComparator(callback, _method, ctx) {
     }
     resolvedNode = resolved;
   }
-  if (!ts12.isArrowFunction(resolvedNode) && !ts12.isFunctionExpression(resolvedNode)) {
+  if (!ts13.isArrowFunction(resolvedNode) && !ts13.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
@@ -11117,11 +11169,11 @@ function resolveSortComparatorIdentifier(name, ctx) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -11132,11 +11184,11 @@ function resolveCallbackMethodFunctionReferenceIdentifier(name, analyzer) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -11192,13 +11244,13 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
   return visit2(expr, bound);
 }
 function extractFilterPredicate(callback, ctx) {
-  if (!ts12.isArrowFunction(callback))
+  if (!ts13.isArrowFunction(callback))
     return { result: null };
   if (callback.parameters.length < 1)
     return { result: null };
   const firstParam = callback.parameters[0];
-  if (!ts12.isIdentifier(firstParam.name)) {
-    if (ts12.isBlock(callback.body)) {
+  if (!ts13.isIdentifier(firstParam.name)) {
+    if (ts13.isBlock(callback.body)) {
       return {
         result: null,
         unsupportedReason: "Block body in a destructured filter param is not supported. Workaround: use an expression-body arrow, or add /* @client */."
@@ -11218,7 +11270,7 @@ function extractFilterPredicate(callback, ctx) {
     return { result: null };
   }
   const param = firstParam.name.getText(ctx.sourceFile);
-  if (ts12.isBlock(callback.body)) {
+  if (ts13.isBlock(callback.body)) {
     const raw2 = ctx.getJS(callback.body);
     const statements = parseBlockBody(callback.body, ctx.sourceFile, (n) => ctx.getJS(n));
     if (!statements) {
@@ -11244,7 +11296,7 @@ function extractFilterPredicate(callback, ctx) {
   return { result: { param, predicate, raw } };
 }
 function extractLoopParamBindings(pattern) {
-  if (ts12.isIdentifier(pattern))
+  if (ts13.isIdentifier(pattern))
     return null;
   const bindings = [];
   let unsupported = false;
@@ -11253,7 +11305,7 @@ function extractLoopParamBindings(pattern) {
       return false;
     for (let i = 0;i < key.length; ) {
       const cp = key.codePointAt(i);
-      const ok = i === 0 ? ts12.isIdentifierStart(cp, ts12.ScriptTarget.Latest) : ts12.isIdentifierPart(cp, ts12.ScriptTarget.Latest);
+      const ok = i === 0 ? ts13.isIdentifierStart(cp, ts13.ScriptTarget.Latest) : ts13.isIdentifierPart(cp, ts13.ScriptTarget.Latest);
       if (!ok)
         return false;
       i += cp > 65535 ? 2 : 1;
@@ -11266,17 +11318,17 @@ function extractLoopParamBindings(pattern) {
   const walk = (p, prefix, segments) => {
     if (unsupported)
       return;
-    if (ts12.isArrayBindingPattern(p)) {
+    if (ts13.isArrayBindingPattern(p)) {
       const elements2 = p.elements;
       for (let index = 0;index < elements2.length; index++) {
         if (unsupported)
           return;
         const el = elements2[index];
-        if (ts12.isOmittedExpression(el))
+        if (ts13.isOmittedExpression(el))
           continue;
         if (el.dotDotDotToken) {
           internalInvariant(index === elements2.length - 1, "extractLoopParamBindings: array rest token in non-final position (parser should reject)");
-          internalInvariant(ts12.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
+          internalInvariant(ts13.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
           bindings.push({
             name: el.name.text,
             path: prefix,
@@ -11287,7 +11339,7 @@ function extractLoopParamBindings(pattern) {
         }
         const path3 = `${prefix}[${index}]`;
         const nextSegments = [...segments, { kind: "index", index }];
-        if (ts12.isIdentifier(el.name)) {
+        if (ts13.isIdentifier(el.name)) {
           bindings.push({ name: el.name.text, path: path3, segments: nextSegments });
         } else {
           walk(el.name, path3, nextSegments);
@@ -11303,7 +11355,7 @@ function extractLoopParamBindings(pattern) {
       const el = elements[i];
       if (el.dotDotDotToken) {
         internalInvariant(i === elements.length - 1, "extractLoopParamBindings: object rest token in non-final position (parser should reject)");
-        internalInvariant(ts12.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
+        internalInvariant(ts13.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
         bindings.push({
           name: el.name.text,
           path: prefix,
@@ -11315,17 +11367,17 @@ function extractLoopParamBindings(pattern) {
       let keyText = null;
       if (el.propertyName) {
         const pn = el.propertyName;
-        if (ts12.isIdentifier(pn))
+        if (ts13.isIdentifier(pn))
           keyText = pn.text;
-        else if (ts12.isStringLiteral(pn))
+        else if (ts13.isStringLiteral(pn))
           keyText = pn.text;
-        else if (ts12.isNumericLiteral(pn))
+        else if (ts13.isNumericLiteral(pn))
           keyText = pn.text;
         else {
           unsupported = true;
           return;
         }
-      } else if (ts12.isIdentifier(el.name)) {
+      } else if (ts13.isIdentifier(el.name)) {
         keyText = el.name.text;
       } else {
         unsupported = true;
@@ -11335,14 +11387,14 @@ function extractLoopParamBindings(pattern) {
       collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path3 = appendDotAccess(prefix, keyText);
       const nextSegments = [...segments, { kind: "field", key: keyText, isIdent: keyIsIdent }];
-      if (ts12.isIdentifier(el.name)) {
+      if (ts13.isIdentifier(el.name)) {
         bindings.push({ name: el.name.text, path: path3, segments: nextSegments });
       } else {
         walk(el.name, path3, nextSegments);
       }
     }
   };
-  if (ts12.isArrayBindingPattern(pattern) || ts12.isObjectBindingPattern(pattern)) {
+  if (ts13.isArrayBindingPattern(pattern) || ts13.isObjectBindingPattern(pattern)) {
     walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
@@ -11352,7 +11404,7 @@ function extractLoopParamBindings(pattern) {
 }
 function findKeyJsxAttribute(opening) {
   for (const prop of opening.attributes.properties) {
-    if (ts12.isJsxAttribute(prop) && prop.name.getText() === "key") {
+    if (ts13.isJsxAttribute(prop) && prop.name.getText() === "key") {
       return prop;
     }
   }
@@ -11397,7 +11449,7 @@ function keyAttrValueToExpr(v) {
 function normalizeKeyExpr(expr) {
   let out = "";
   for (const tok of iterateJsTokens(expr)) {
-    if (tok.kind === ts12.SyntaxKind.WhitespaceTrivia || tok.kind === ts12.SyntaxKind.NewLineTrivia) {
+    if (tok.kind === ts13.SyntaxKind.WhitespaceTrivia || tok.kind === ts13.SyntaxKind.NewLineTrivia) {
       continue;
     }
     out += expr.slice(tok.pos, tok.end);
@@ -11409,13 +11461,13 @@ function conditionalHasExplicitNullishBranch(cond) {
 }
 function branchHasExplicitNullish(branch) {
   let b = branch;
-  while (ts12.isParenthesizedExpression(b))
+  while (ts13.isParenthesizedExpression(b))
     b = b.expression;
-  if (b.kind === ts12.SyntaxKind.NullKeyword)
+  if (b.kind === ts13.SyntaxKind.NullKeyword)
     return true;
-  if (ts12.isIdentifier(b) && b.text === "undefined")
+  if (ts13.isIdentifier(b) && b.text === "undefined")
     return true;
-  if (ts12.isConditionalExpression(b))
+  if (ts13.isConditionalExpression(b))
     return conditionalHasExplicitNullishBranch(b);
   return false;
 }
@@ -11424,26 +11476,26 @@ function classifyKeyProblem(keyAttr, checker) {
     return "missing";
   if (!keyAttr.initializer)
     return "missing";
-  if (ts12.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
+  if (ts13.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
     return "missing";
   }
   let expr;
-  if (ts12.isStringLiteral(keyAttr.initializer)) {
+  if (ts13.isStringLiteral(keyAttr.initializer)) {
     return null;
-  } else if (ts12.isJsxExpression(keyAttr.initializer)) {
+  } else if (ts13.isJsxExpression(keyAttr.initializer)) {
     expr = keyAttr.initializer.expression;
   }
   if (!expr)
     return null;
-  if (expr.kind === ts12.SyntaxKind.NullKeyword)
+  if (expr.kind === ts13.SyntaxKind.NullKeyword)
     return null;
-  if (ts12.isIdentifier(expr) && expr.text === "undefined")
+  if (ts13.isIdentifier(expr) && expr.text === "undefined")
     return null;
-  if (ts12.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr))
+  if (ts13.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr))
     return null;
   if (checker) {
     const type = checker.getTypeAtLocation(expr);
-    const isNullable = type.isUnion() ? type.types.some((t) => (t.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0) : (type.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0;
+    const isNullable = type.isUnion() ? type.types.some((t) => (t.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0) : (type.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0;
     if (isNullable)
       return "nullable-type";
   }
@@ -11469,81 +11521,81 @@ function checkLoopKey(callback, ctx, isNested) {
     ctx.analyzer.errors.push(createError(errorCode, getSourceLocation(locNode, ctx.sourceFile, ctx.filePath), { suggestion: { message: keyErrorSuggestion(problem) } }));
   }
   let body = callback.body;
-  if (ts12.isBlock(body)) {
-    const ret = body.statements.find((s) => ts12.isReturnStatement(s) && s.expression != null);
+  if (ts13.isBlock(body)) {
+    const ret = body.statements.find((s) => ts13.isReturnStatement(s) && s.expression != null);
     if (!ret?.expression)
       return;
     body = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(body))
+  while (ts13.isParenthesizedExpression(body))
     body = body.expression;
   function checkJsxOperand(node) {
     let n = node;
-    while (ts12.isParenthesizedExpression(n))
+    while (ts13.isParenthesizedExpression(n))
       n = n.expression;
-    if (ts12.isJsxElement(n))
+    if (ts13.isJsxElement(n))
       checkOpening(n.openingElement);
-    else if (ts12.isJsxSelfClosingElement(n))
+    else if (ts13.isJsxSelfClosingElement(n))
       checkOpening(n);
   }
-  if (ts12.isConditionalExpression(body)) {
+  if (ts13.isConditionalExpression(body)) {
     checkJsxOperand(body.whenTrue);
     checkJsxOperand(body.whenFalse);
     return;
   }
-  if (ts12.isBinaryExpression(body) && (body.operatorToken.kind === ts12.SyntaxKind.AmpersandAmpersandToken || body.operatorToken.kind === ts12.SyntaxKind.BarBarToken || body.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken)) {
+  if (ts13.isBinaryExpression(body) && (body.operatorToken.kind === ts13.SyntaxKind.AmpersandAmpersandToken || body.operatorToken.kind === ts13.SyntaxKind.BarBarToken || body.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken)) {
     checkJsxOperand(body.left);
     checkJsxOperand(body.right);
     return;
   }
-  if (ts12.isJsxElement(body)) {
+  if (ts13.isJsxElement(body)) {
     checkOpening(body.openingElement);
     return;
   }
-  if (ts12.isJsxSelfClosingElement(body)) {
+  if (ts13.isJsxSelfClosingElement(body)) {
     checkOpening(body);
     return;
   }
 }
 function flatMapProjectionCall(body) {
   let expr;
-  if (ts12.isBlock(body)) {
+  if (ts13.isBlock(body)) {
     const real = body.statements;
-    if (real.length !== 1 || !ts12.isReturnStatement(real[0]) || !real[0].expression)
+    if (real.length !== 1 || !ts13.isReturnStatement(real[0]) || !real[0].expression)
       return null;
     expr = real[0].expression;
   } else {
     expr = body;
   }
-  while (ts12.isParenthesizedExpression(expr))
+  while (ts13.isParenthesizedExpression(expr))
     expr = expr.expression;
-  if (!ts12.isCallExpression(expr))
+  if (!ts13.isCallExpression(expr))
     return null;
   if (!getMapLikeMethod(expr))
     return null;
   const cb = expr.arguments[0];
-  if (!cb || !ts12.isArrowFunction(cb) && !ts12.isFunctionExpression(cb))
+  if (!cb || !ts13.isArrowFunction(cb) && !ts13.isFunctionExpression(cb))
     return null;
   for (const p of cb.parameters) {
-    if (!ts12.isIdentifier(p.name))
+    if (!ts13.isIdentifier(p.name))
       return null;
   }
   let innerBody = cb.body;
-  if (ts12.isBlock(innerBody)) {
-    const ret = innerBody.statements.find((s) => ts12.isReturnStatement(s) && s.expression != null);
+  if (ts13.isBlock(innerBody)) {
+    const ret = innerBody.statements.find((s) => ts13.isReturnStatement(s) && s.expression != null);
     if (innerBody.statements.length !== 1 || !ret?.expression)
       return null;
     innerBody = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(innerBody))
+  while (ts13.isParenthesizedExpression(innerBody))
     innerBody = innerBody.expression;
   const isElementish = (n) => {
     let m = n;
-    while (ts12.isParenthesizedExpression(m))
+    while (ts13.isParenthesizedExpression(m))
       m = m.expression;
-    if (ts12.isJsxElement(m) || ts12.isJsxSelfClosingElement(m))
+    if (ts13.isJsxElement(m) || ts13.isJsxSelfClosingElement(m))
       return leafIsWirelessElement(m);
-    if (ts12.isConditionalExpression(m))
+    if (ts13.isConditionalExpression(m))
       return isElementish(m.whenTrue) && isElementish(m.whenFalse);
     return false;
   };
@@ -11556,19 +11608,19 @@ function leafIsWirelessElement(el) {
   const visit2 = (n) => {
     if (!ok)
       return;
-    if (ts12.isJsxOpeningElement(n) || ts12.isJsxSelfClosingElement(n)) {
+    if (ts13.isJsxOpeningElement(n) || ts13.isJsxSelfClosingElement(n)) {
       const tagNode = n.tagName;
-      const isIntrinsic = ts12.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : ts12.isJsxNamespacedName(tagNode);
+      const isIntrinsic = ts13.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : ts13.isJsxNamespacedName(tagNode);
       if (!isIntrinsic) {
         ok = false;
         return;
       }
       for (const attr of n.attributes.properties) {
-        if (ts12.isJsxSpreadAttribute(attr)) {
+        if (ts13.isJsxSpreadAttribute(attr)) {
           ok = false;
           return;
         }
-        if (ts12.isJsxAttribute(attr)) {
+        if (ts13.isJsxAttribute(attr)) {
           const name = attr.name.getText();
           if (/^on[A-Z]/.test(name)) {
             ok = false;
@@ -11577,11 +11629,11 @@ function leafIsWirelessElement(el) {
         }
       }
     }
-    if (ts12.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
+    if (ts13.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
       ok = false;
       return;
     }
-    ts12.forEachChild(n, visit2);
+    ts13.forEachChild(n, visit2);
   };
   visit2(el);
   return ok;
@@ -11761,7 +11813,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let children = [];
   let paramBindings;
   let flatMapCallback;
-  if (ts12.isArrowFunction(callback)) {
+  if (ts13.isArrowFunction(callback)) {
     if (callback.parameters.length > 0) {
       const firstParam = callback.parameters[0];
       param = firstParam.name.getText(ctx.sourceFile);
@@ -11769,9 +11821,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         paramType = firstParam.type.getText(ctx.sourceFile);
       }
       const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
-      if (isEntriesShape && ts12.isArrayBindingPattern(firstParam.name)) {
-        const elements = firstParam.name.elements.filter((el) => !ts12.isOmittedExpression(el));
-        if (elements.length === 2 && ts12.isBindingElement(elements[0]) && ts12.isIdentifier(elements[0].name) && ts12.isBindingElement(elements[1]) && ts12.isIdentifier(elements[1].name)) {
+      if (isEntriesShape && ts13.isArrayBindingPattern(firstParam.name)) {
+        const elements = firstParam.name.elements.filter((el) => !ts13.isOmittedExpression(el));
+        if (elements.length === 2 && ts13.isBindingElement(elements[0]) && ts13.isIdentifier(elements[0].name) && ts13.isBindingElement(elements[1]) && ts13.isIdentifier(elements[1].name)) {
           index = elements[0].name.text;
           param = elements[1].name.text;
         } else {
@@ -11802,10 +11854,10 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     ctx.scope = ctx.scope.enterLoopRow({ param, index, paramBindings });
     ctx.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
-      if (!ts12.isBinaryExpression(expr))
+      if (!ts13.isBinaryExpression(expr))
         return;
       const op = expr.operatorToken.kind;
-      if (op !== ts12.SyntaxKind.AmpersandAmpersandToken && op !== ts12.SyntaxKind.BarBarToken && op !== ts12.SyntaxKind.QuestionQuestionToken) {
+      if (op !== ts13.SyntaxKind.AmpersandAmpersandToken && op !== ts13.SyntaxKind.BarBarToken && op !== ts13.SyntaxKind.QuestionQuestionToken) {
         return;
       }
       if (!containsJsxInExpression(expr) && !callsJsxHelper(expr, ctx))
@@ -11815,33 +11867,33 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         children = [transformed];
     };
     const body = callback.body;
-    if (ts12.isJsxElement(body) || ts12.isJsxSelfClosingElement(body) || ts12.isJsxFragment(body)) {
+    if (ts13.isJsxElement(body) || ts13.isJsxSelfClosingElement(body) || ts13.isJsxFragment(body)) {
       const transformed = transformNode(body, ctx);
       if (transformed) {
         children = [transformed];
       }
-    } else if (ts12.isConditionalExpression(body)) {
+    } else if (ts13.isConditionalExpression(body)) {
       children = [transformConditional(body, ctx)];
-    } else if (ts12.isParenthesizedExpression(body)) {
+    } else if (ts13.isParenthesizedExpression(body)) {
       let inner = body.expression;
-      while (ts12.isParenthesizedExpression(inner)) {
+      while (ts13.isParenthesizedExpression(inner)) {
         inner = inner.expression;
       }
-      if (ts12.isJsxElement(inner) || ts12.isJsxSelfClosingElement(inner) || ts12.isJsxFragment(inner)) {
+      if (ts13.isJsxElement(inner) || ts13.isJsxSelfClosingElement(inner) || ts13.isJsxFragment(inner)) {
         const transformed = transformNode(inner, ctx);
         if (transformed) {
           children = [transformed];
         }
-      } else if (ts12.isConditionalExpression(inner)) {
+      } else if (ts13.isConditionalExpression(inner)) {
         children = [transformConditional(inner, ctx)];
-      } else if (method === "flatMap" && ts12.isArrayLiteralExpression(inner)) {
+      } else if (method === "flatMap" && ts13.isArrayLiteralExpression(inner)) {
         children = transformArrayLiteralChildren(inner, ctx);
       } else {
         tryTransformRenderableBody(inner);
       }
-    } else if (method === "flatMap" && ts12.isArrayLiteralExpression(body)) {
+    } else if (method === "flatMap" && ts13.isArrayLiteralExpression(body)) {
       children = transformArrayLiteralChildren(body, ctx);
-    } else if (ts12.isBlock(body)) {
+    } else if (ts13.isBlock(body)) {
       const multiReturn = method !== "flatMap" ? extractMultiReturnJsxBranches(body, true) : null;
       if (multiReturn && multiReturn.branches.length > 0) {
         const loc = getSourceLocation(body, ctx.sourceFile, ctx.filePath);
@@ -11859,7 +11911,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           }
         }
       }
-      const returnStmt = children.length === 0 ? body.statements.find((s) => ts12.isReturnStatement(s) && s.expression != null) : undefined;
+      const returnStmt = children.length === 0 ? body.statements.find((s) => ts13.isReturnStatement(s) && s.expression != null) : undefined;
       let rowScopeBeforePreamble = null;
       if (returnStmt) {
         const preambleNames = new Set;
@@ -11880,10 +11932,10 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       }
       if (returnStmt && returnStmt.expression) {
         let returnExpr = returnStmt.expression;
-        while (ts12.isParenthesizedExpression(returnExpr)) {
+        while (ts13.isParenthesizedExpression(returnExpr)) {
           returnExpr = returnExpr.expression;
         }
-        if (ts12.isJsxElement(returnExpr) || ts12.isJsxSelfClosingElement(returnExpr) || ts12.isJsxFragment(returnExpr)) {
+        if (ts13.isJsxElement(returnExpr) || ts13.isJsxSelfClosingElement(returnExpr) || ts13.isJsxFragment(returnExpr)) {
           const transformed = transformNode(returnExpr, ctx);
           if (transformed) {
             children = [transformed];
@@ -11965,7 +12017,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         }
       }
     }
-    if (method === "flatMap" && children.length === 0 && !flatMapCallback && !ts12.isBlock(body)) {
+    if (method === "flatMap" && children.length === 0 && !flatMapCallback && !ts13.isBlock(body)) {
       flatMapCallback = buildFlatMapCallback(callback, body, ctx);
     }
     if (flatMapCallback)
@@ -11983,7 +12035,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   }
   if (children.length === 0 && !flatMapCallback) {
     const cb = node.arguments[0];
-    const cbBody = cb && (ts12.isArrowFunction(cb) || ts12.isFunctionExpression(cb)) ? cb.body : undefined;
+    const cbBody = cb && (ts13.isArrowFunction(cb) || ts13.isFunctionExpression(cb)) ? cb.body : undefined;
     if (cbBody && containsJsxInExpression(cbBody) && ctx.analyzer.errors.length === diagCountAtEntry) {
       ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(cbBody, ctx.sourceFile, ctx.filePath), {
         message: `A .${method}() callback that builds JSX in this shape cannot be ` + "compiled — the JSX would leak verbatim into the client bundle. " + "Recognized bodies: a JSX element/fragment, a ternary or " + "&& / || / ?? expression, an array literal (flatMap), or a block " + "body whose return the compiler can lower.",
@@ -11994,7 +12046,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     return null;
   }
-  if (ts12.isArrowFunction(node.arguments[0]) && children.length > 0) {
+  if (ts13.isArrowFunction(node.arguments[0]) && children.length > 0) {
     checkLoopKey(node.arguments[0], ctx, isNested);
   }
   const itemConditional = children.length > 0 ? loopBodyItemConditional(children) : null;
@@ -12048,6 +12100,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children, new Set(preamble.declaredNames), ctx) : undefined;
   if (preamble && !isStaticArray) {
     markPreambleAttrSlots(children, new Set(preamble.declaredNames), ctx);
+    if (preamble.reactiveNames && preamble.reactiveNames.length > 0) {
+      markPreambleConditionalReactivity(children, new Set(preamble.reactiveNames), ctx);
+    }
   }
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
@@ -12091,12 +12146,12 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
 function transformArrayLiteralChildren(arrayLiteral, ctx) {
   const children = [];
   for (const element of arrayLiteral.elements) {
-    if (ts12.isSpreadElement(element))
+    if (ts13.isSpreadElement(element))
       continue;
     let inner = element;
-    while (ts12.isParenthesizedExpression(inner))
+    while (ts13.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (ts12.isJsxElement(inner) || ts12.isJsxSelfClosingElement(inner) || ts12.isJsxFragment(inner)) {
+    if (ts13.isJsxElement(inner) || ts13.isJsxSelfClosingElement(inner) || ts13.isJsxFragment(inner)) {
       const transformed = transformNode(inner, ctx);
       if (transformed)
         children.push(transformed);
@@ -12105,7 +12160,7 @@ function transformArrayLiteralChildren(arrayLiteral, ctx) {
   return children;
 }
 function containsJsx(node) {
-  if (ts12.isJsxElement(node) || ts12.isJsxSelfClosingElement(node) || ts12.isJsxFragment(node))
+  if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -12121,7 +12176,7 @@ function buildFlatMapCallback(callback, body, ctx) {
   const leafIrs = [];
   let refusalNode;
   const collectJsx = (n, underTemplate) => {
-    if (ts12.isJsxElement(n) || ts12.isJsxSelfClosingElement(n) || ts12.isJsxFragment(n)) {
+    if (ts13.isJsxElement(n) || ts13.isJsxSelfClosingElement(n) || ts13.isJsxFragment(n)) {
       if (underTemplate)
         refusalNode ??= n;
       leafSpans.push({ start: n.getStart(ctx.sourceFile), end: n.getEnd() });
@@ -12129,7 +12184,7 @@ function buildFlatMapCallback(callback, body, ctx) {
       leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx.sourceFile, ctx.filePath) });
       return;
     }
-    const inTemplate = underTemplate || ts12.isTemplateExpression(n) || ts12.isTaggedTemplateExpression(n);
+    const inTemplate = underTemplate || ts13.isTemplateExpression(n) || ts13.isTaggedTemplateExpression(n);
     n.forEachChild((c) => collectJsx(c, inTemplate));
   };
   collectJsx(body, false);
@@ -12305,6 +12360,33 @@ function markPreambleAttrSlots(nodes, declared, ctx) {
   };
   visit2(nodes);
 }
+function markPreambleConditionalReactivity(nodes, reactiveNames, ctx) {
+  if (reactiveNames.size === 0)
+    return;
+  const visit2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+        case "fragment":
+          visit2(node.children);
+          break;
+        case "conditional": {
+          if (!node.reactive) {
+            const refs = extractFreeIdentifiersFromText(node.condition);
+            if ([...refs].some((r) => reactiveNames.has(r))) {
+              node.reactive = true;
+              if (!node.slotId)
+                node.slotId = generateSlotId(ctx);
+            }
+          }
+          visit2([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+        }
+      }
+    }
+  };
+  visit2(nodes);
+}
 function attrValueText(value) {
   if (value.kind === "expression")
     return value.expr;
@@ -12320,24 +12402,46 @@ function attrValueText(value) {
   return out.join(" ");
 }
 function collectBindingNames2(name, out) {
-  if (ts12.isIdentifier(name)) {
+  if (ts13.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const el of name.elements) {
-    if (ts12.isBindingElement(el))
+    if (ts13.isBindingElement(el))
       collectBindingNames2(el.name, out);
   }
 }
 function collectPreambleDeclaredNames(stmt, out) {
-  if (ts12.isVariableStatement(stmt)) {
+  if (ts13.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
       collectBindingNames2(decl.name, out);
     }
-  } else if (ts12.isFunctionDeclaration(stmt) && stmt.name) {
+  } else if (ts13.isFunctionDeclaration(stmt) && stmt.name) {
     out.add(stmt.name.text);
   }
 }
+function computePreambleReactiveNames(statements, ctx) {
+  const reactiveNames = new Set;
+  for (const stmt of statements) {
+    if (!ts13.isVariableStatement(stmt))
+      continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!decl.initializer)
+        continue;
+      const boundNames = new Set;
+      collectBindingNames2(decl.name, boundNames);
+      const initText = ctx.getJS(decl.initializer);
+      const initFreeRefs = extractFreeIdentifiersFromNode(decl.initializer);
+      const readsEarlierReactive = [...initFreeRefs].some((r) => reactiveNames.has(r));
+      const isReactive = readsEarlierReactive || isReactiveExpression(initText, ctx, decl.initializer);
+      if (isReactive) {
+        for (const n of boundNames)
+          reactiveNames.add(n);
+      }
+    }
+  }
+  return reactiveNames;
+}
 function preambleFromValueStatements(statements, ctx) {
   const segments = [];
   const typedParts = [];
@@ -12352,21 +12456,23 @@ function preambleFromValueStatements(statements, ctx) {
     typedParts.push(raw0.endsWith(";") ? raw0 : raw0 + ";");
     segments.push(tjs !== js ? { kind: "js", text: js, templateText: tjs } : { kind: "js", text: js });
   }
+  const reactiveNames = computePreambleReactiveNames(statements, ctx);
   return {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     builderNames: [],
-    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined
+    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined,
+    reactiveNames: reactiveNames.size > 0 ? [...reactiveNames] : undefined
   };
 }
 function neutralPreambleDeclarations(statements, ctx) {
   const out = [];
   for (const stmt of statements) {
-    if (!ts12.isVariableStatement(stmt))
+    if (!ts13.isVariableStatement(stmt))
       return null;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts12.isIdentifier(decl.name))
+      if (!ts13.isIdentifier(decl.name))
         return null;
       if (!decl.initializer)
         return null;
@@ -12399,11 +12505,11 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
   let refusalNode;
   const recordBuilderTarget = (leaf, stmt) => {
     for (let n = leaf.parent;n && n !== stmt.parent; n = n.parent) {
-      if (ts12.isCallExpression(n) && ts12.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && ts12.isIdentifier(n.expression.expression)) {
+      if (ts13.isCallExpression(n) && ts13.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && ts13.isIdentifier(n.expression.expression)) {
         builders.add(n.expression.expression.text);
         return;
       }
-      if (ts12.isVariableDeclaration(n) && ts12.isIdentifier(n.name)) {
+      if (ts13.isVariableDeclaration(n) && ts13.isIdentifier(n.name)) {
         builders.add(n.name.text);
         return;
       }
@@ -12416,7 +12522,7 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
     const leafSpans = [];
     const leafIrs = [];
     const collect = (n, underTemplate) => {
-      if (ts12.isJsxElement(n) || ts12.isJsxSelfClosingElement(n) || ts12.isJsxFragment(n)) {
+      if (ts13.isJsxElement(n) || ts13.isJsxSelfClosingElement(n) || ts13.isJsxFragment(n)) {
         if (underTemplate)
           refusalNode ??= n;
         recordBuilderTarget(n, stmt);
@@ -12427,7 +12533,7 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
         leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx.sourceFile, ctx.filePath) });
         return;
       }
-      const inTemplate = underTemplate || ts12.isTemplateExpression(n) || ts12.isTaggedTemplateExpression(n);
+      const inTemplate = underTemplate || ts13.isTemplateExpression(n) || ts13.isTaggedTemplateExpression(n);
       n.forEachChild((c) => collect(c, inTemplate));
     };
     collect(stmt, false);
@@ -12531,13 +12637,13 @@ function expandSpreadAttribute(attr, ctx) {
   }];
 }
 function attrFreeIdentifiers(attr) {
-  if (!attr.initializer || !ts12.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !ts13.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return;
   }
   return extractFreeIdentifiersFromNode(attr.initializer.expression);
 }
 function computeReactivityFlags(attr, ctx) {
-  if (!attr.initializer || !ts12.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !ts13.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return {};
   }
   const expr = attr.initializer.expression;
@@ -12563,22 +12669,22 @@ function processAttributes(attributes, ctx) {
   const events = [];
   let ref = null;
   for (const attr of attributes.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       attrs.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr))
+    if (!ts13.isJsxAttribute(attr))
       continue;
     const rawName = attr.name.getText(ctx.sourceFile);
     if (rawName === "ref") {
-      if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         ref = ctx.getJS(attr.initializer.expression);
       }
       continue;
     }
     if (/^on[A-Z]/.test(rawName)) {
-      if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         const eventName = rawName.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         events.push({
@@ -12593,7 +12699,7 @@ function processAttributes(attributes, ctx) {
     const name = toHTMLAttrName(rawName);
     let value = getAttributeValue(attr, ctx);
     let clientOnly;
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value.kind === "expression" && value.templateExpr === undefined) {
         const rewritten = rewriteBarePropRefs2(value.expr, attr.initializer.expression, ctx);
         if (rewritten !== value.expr) {
@@ -12620,55 +12726,55 @@ function getAttributeValue(attr, ctx) {
   if (!attr.initializer) {
     return AttrValueOf.booleanAttr();
   }
-  if (ts12.isStringLiteral(attr.initializer)) {
+  if (ts13.isStringLiteral(attr.initializer)) {
     return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
-  if (ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+  if (ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
-    if (ts12.isIdentifier(expr)) {
+    if (ts13.isIdentifier(expr)) {
       const branchInit = ctx._branchScopeVars?.get(expr.text);
       if (branchInit && !initializerShapeContainsJsx(branchInit)) {
         expr = branchInit;
       }
     }
     expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
-    if (ts12.isAwaitExpression(expr)) {
+    if (ts13.isAwaitExpression(expr)) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
     }
     checkBareSignalOrMemoIdentifier(expr, ctx);
-    if (attr.name.getText(ctx.sourceFile) === "style" && ts12.isObjectLiteralExpression(expr)) {
+    if (attr.name.getText(ctx.sourceFile) === "style" && ts13.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
       if (cssString !== null) {
         return AttrValueOf.literal(cssString);
       }
     }
-    if (ts12.isTemplateExpression(expr)) {
+    if (ts13.isTemplateExpression(expr)) {
       const parts = parseTemplateLiteral(expr, ctx);
       if (parts.some((p) => p.type === "ternary" || p.type === "lookup")) {
         return AttrValueOf.template(parts);
       }
     }
-    if (ts12.isElementAccessExpression(expr) && !ts12.isStringLiteralLike(expr.argumentExpression) && !ts12.isNumericLiteral(expr.argumentExpression)) {
+    if (ts13.isElementAccessExpression(expr) && !ts13.isStringLiteralLike(expr.argumentExpression) && !ts13.isNumericLiteral(expr.argumentExpression)) {
       const parts = tryResolveTemplateSpanFromConst(expr, ctx);
       if (parts) {
         return AttrValueOf.template(parts);
       }
     }
-    if (ts12.isIdentifier(expr)) {
+    if (ts13.isIdentifier(expr)) {
       const resolved = tryResolveIdentifierAsTemplateLiteral(expr, ctx);
       if (resolved) {
         return AttrValueOf.template(resolved);
       }
     }
-    if (ts12.isConditionalExpression(expr)) {
+    if (ts13.isConditionalExpression(expr)) {
       const ternary = parseTernary(expr, ctx);
       if (ternary) {
         return AttrValueOf.template([ternary]);
       }
     }
-    if (ts12.isBinaryExpression(expr) && expr.operatorToken.kind === ts12.SyntaxKind.BarBarToken) {
-      if (ts12.isIdentifier(expr.right) && expr.right.text === "undefined") {
+    if (ts13.isBinaryExpression(expr) && expr.operatorToken.kind === ts13.SyntaxKind.BarBarToken) {
+      if (ts13.isIdentifier(expr.right) && expr.right.text === "undefined") {
         const baseExpr = ctx.getJS(expr.left);
         return AttrValueOf.expression(baseExpr, { presenceOrUndefined: true });
       }
@@ -12681,11 +12787,11 @@ function getAttributeValue(attr, ctx) {
 function tryStaticStyleObjectToCss(expr) {
   const parts = [];
   for (const prop of expr.properties) {
-    if (!ts12.isPropertyAssignment(prop))
+    if (!ts13.isPropertyAssignment(prop))
       return null;
-    if (!ts12.isIdentifier(prop.name) && !ts12.isStringLiteral(prop.name))
+    if (!ts13.isIdentifier(prop.name) && !ts13.isStringLiteral(prop.name))
       return null;
-    if (!ts12.isStringLiteral(prop.initializer))
+    if (!ts13.isStringLiteral(prop.initializer))
       return null;
     const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
@@ -12698,7 +12804,7 @@ function parseTemplateLiteral(expr, ctx) {
     parts.push({ type: "string", value: expr.head.text });
   }
   for (const span of expr.templateSpans) {
-    if (ts12.isConditionalExpression(span.expression)) {
+    if (ts13.isConditionalExpression(span.expression)) {
       const ternary = parseTernary(span.expression, ctx);
       if (ternary) {
         parts.push(ternary);
@@ -12724,7 +12830,7 @@ function parseTemplateLiteral(expr, ctx) {
   return parts;
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     if (ctx.scope.isBound(expr.text))
       return null;
     const constInfo = findLocalConst(expr.text, ctx.analyzer);
@@ -12733,13 +12839,13 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
     const ast = parseConstInitializer(constInfo);
     if (!ast)
       return null;
-    if (ts12.isStringLiteral(ast) || ts12.isNoSubstitutionTemplateLiteral(ast)) {
+    if (ts13.isStringLiteral(ast) || ts13.isNoSubstitutionTemplateLiteral(ast)) {
       return [{ type: "string", value: ast.text }];
     }
     return null;
   }
-  if (ts12.isElementAccessExpression(expr)) {
-    if (!ts12.isIdentifier(expr.expression))
+  if (ts13.isElementAccessExpression(expr)) {
+    if (!ts13.isIdentifier(expr.expression))
       return null;
     if (ctx.scope.isBound(expr.expression.text))
       return null;
@@ -12747,17 +12853,17 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
-    if (!ast || !ts12.isObjectLiteralExpression(ast))
+    if (!ast || !ts13.isObjectLiteralExpression(ast))
       return null;
     const cases = {};
     for (const prop of ast.properties) {
-      if (!ts12.isPropertyAssignment(prop))
+      if (!ts13.isPropertyAssignment(prop))
         return null;
-      const keyName = prop.name && (ts12.isStringLiteral(prop.name) || ts12.isIdentifier(prop.name)) ? prop.name.text : null;
+      const keyName = prop.name && (ts13.isStringLiteral(prop.name) || ts13.isIdentifier(prop.name)) ? prop.name.text : null;
       if (!keyName)
         return null;
       const value = prop.initializer;
-      if (ts12.isStringLiteral(value) || ts12.isNoSubstitutionTemplateLiteral(value)) {
+      if (ts13.isStringLiteral(value) || ts13.isNoSubstitutionTemplateLiteral(value)) {
         cases[keyName] = value.text;
       } else {
         return null;
@@ -12804,17 +12910,17 @@ function hasDynamicTagBinding(name, sourceFile) {
   const visit2 = (node) => {
     if (found)
       return;
-    if (ts12.isVariableDeclaration(node) && ts12.isIdentifier(node.name) && node.name.text === name && node.initializer) {
+    if (ts13.isVariableDeclaration(node) && ts13.isIdentifier(node.name) && node.name.text === name && node.initializer) {
       let init = node.initializer;
-      while (ts12.isAsExpression(init) || ts12.isSatisfiesExpression(init) || ts12.isParenthesizedExpression(init) || ts12.isNonNullExpression(init)) {
+      while (ts13.isAsExpression(init) || ts13.isSatisfiesExpression(init) || ts13.isParenthesizedExpression(init) || ts13.isNonNullExpression(init)) {
         init = init.expression;
       }
-      if (ts12.isPropertyAccessExpression(init) && init.name.text === "tag") {
+      if (ts13.isPropertyAccessExpression(init) && init.name.text === "tag") {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(node, visit2);
+    ts13.forEachChild(node, visit2);
   };
   visit2(sourceFile);
   return found;
@@ -12828,13 +12934,13 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   const ast = parseConstInitializer(constInfo);
   if (!ast)
     return null;
-  if (ts12.isNoSubstitutionTemplateLiteral(ast) || ts12.isStringLiteral(ast)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(ast) || ts13.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
-  if (ts12.isElementAccessExpression(ast) && !ts12.isStringLiteralLike(ast.argumentExpression) && !ts12.isNumericLiteral(ast.argumentExpression)) {
+  if (ts13.isElementAccessExpression(ast) && !ts13.isStringLiteralLike(ast.argumentExpression) && !ts13.isNumericLiteral(ast.argumentExpression)) {
     return tryResolveTemplateSpanFromConst(ast, ctx);
   }
-  if (!ts12.isTemplateExpression(ast))
+  if (!ts13.isTemplateExpression(ast))
     return null;
   let resolvedAny = false;
   const parts = [];
@@ -12872,14 +12978,14 @@ function parseConstInitializerImpl(c) {
   if (!c.value)
     return null;
   const wrapped = `const __bf_resolve__ = (${c.value})`;
-  const sf = ts12.createSourceFile("__bf_resolve.ts", wrapped, ts12.ScriptTarget.Latest, true, ts12.ScriptKind.TS);
+  const sf = ts13.createSourceFile("__bf_resolve.ts", wrapped, ts13.ScriptTarget.Latest, true, ts13.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt))
+  if (!stmt || !ts13.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
     return null;
-  return ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  return ts13.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
 }
 function astText(node) {
   return node.getText(node.getSourceFile());
@@ -12899,9 +13005,9 @@ function parseFunctionInfoAsExprImpl(fn) {
   const params = fn.typedParams !== undefined ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
   const body = fn.typedBody ?? fn.body;
   const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body}`;
-  const sf = ts12.createSourceFile("__bf_resolve_fn.ts", wrapped, ts12.ScriptTarget.Latest, true, ts12.ScriptKind.TS);
+  const sf = ts13.createSourceFile("__bf_resolve_fn.ts", wrapped, ts13.ScriptTarget.Latest, true, ts13.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt))
+  if (!stmt || !ts13.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
@@ -12909,9 +13015,9 @@ function parseFunctionInfoAsExprImpl(fn) {
   return decl.initializer;
 }
 function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
-  if (!ts12.isTaggedTemplateExpression(expr))
+  if (!ts13.isTaggedTemplateExpression(expr))
     return expr;
-  if (!ts12.isIdentifier(expr.tag))
+  if (!ts13.isIdentifier(expr.tag))
     return expr;
   const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx);
   if (!resolvedTag)
@@ -12928,23 +13034,23 @@ function resolveInterleaveTagIdentifier(name, ctx) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
 function isInterleaveTagFunction(fn) {
-  if (!ts12.isArrowFunction(fn) && !ts12.isFunctionExpression(fn))
+  if (!ts13.isArrowFunction(fn) && !ts13.isFunctionExpression(fn))
     return false;
   if (fn.parameters.length !== 2)
     return false;
   const [partsParam, argsParam] = fn.parameters;
-  if (!ts12.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
+  if (!ts13.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
     return false;
-  if (!ts12.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
+  if (!ts13.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
     return false;
   const parsed = tsNodeToParsedExpr(fn);
   if (parsed.kind !== "arrow")
@@ -13001,7 +13107,7 @@ function isInterleaveSpanExpr(expr, i, argsName) {
 function buildUntaggedTemplateLiteral(node, ctx) {
   const template = node.template;
   let text;
-  if (ts12.isNoSubstitutionTemplateLiteral(template)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(template)) {
     text = "`" + (template.rawText ?? template.text) + "`";
   } else {
     let body = template.head.rawText ?? template.head.text;
@@ -13013,15 +13119,15 @@ function buildUntaggedTemplateLiteral(node, ctx) {
     text = "`" + body + "`";
   }
   const wrapped = `const __bf_resolve_tagged__ = (${text})`;
-  const sf = ts12.createSourceFile("__bf_resolve_tagged.tsx", wrapped, ts12.ScriptTarget.Latest, true, ts12.ScriptKind.TSX);
+  const sf = ts13.createSourceFile("__bf_resolve_tagged.tsx", wrapped, ts13.ScriptTarget.Latest, true, ts13.ScriptKind.TSX);
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt))
+  if (!stmt || !ts13.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
     return null;
-  const result = ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
-  if (!ts12.isTemplateExpression(result) && !ts12.isNoSubstitutionTemplateLiteral(result))
+  const result = ts13.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!ts13.isTemplateExpression(result) && !ts13.isNoSubstitutionTemplateLiteral(result))
     return null;
   return result;
 }
@@ -13041,10 +13147,10 @@ function parseTernary(expr, ctx) {
   return null;
 }
 function getStringValue(node) {
-  if (ts12.isStringLiteral(node)) {
+  if (ts13.isStringLiteral(node)) {
     return node.text;
   }
-  if (ts12.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
   return null;
@@ -13052,19 +13158,19 @@ function getStringValue(node) {
 function processComponentProps(attributes, ctx) {
   const props = [];
   for (const attr of attributes.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       props.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr))
+    if (!ts13.isJsxAttribute(attr))
       continue;
     const name = attr.name.getText(ctx.sourceFile);
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       let jsxExpr = attr.initializer.expression;
-      while (ts12.isParenthesizedExpression(jsxExpr)) {
+      while (ts13.isParenthesizedExpression(jsxExpr)) {
         jsxExpr = jsxExpr.expression;
       }
-      if (ts12.isJsxElement(jsxExpr) || ts12.isJsxSelfClosingElement(jsxExpr) || ts12.isJsxFragment(jsxExpr)) {
+      if (ts13.isJsxElement(jsxExpr) || ts13.isJsxSelfClosingElement(jsxExpr) || ts13.isJsxFragment(jsxExpr)) {
         const prevInsideComponentChildren = ctx.insideComponentChildren;
         ctx.insideComponentChildren = true;
         const irNode = transformNode(jsxExpr, ctx);
@@ -13091,7 +13197,7 @@ function processComponentProps(attributes, ctx) {
       value = AttrValueOf.booleanShorthand();
     }
     let clientOnly;
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value.kind === "expression" && value.templateExpr === undefined) {
         const rewritten = rewriteBarePropRefs2(value.expr, attr.initializer.expression, ctx);
         if (rewritten !== value.expr) {
@@ -13115,7 +13221,7 @@ function processComponentProps(attributes, ctx) {
   return props;
 }
 function checkBareSignalOrMemoIdentifier(expr, ctx) {
-  if (!ts12.isIdentifier(expr))
+  if (!ts13.isIdentifier(expr))
     return;
   const name = expr.text;
   for (const signal of ctx.analyzer.signals) {
@@ -13146,12 +13252,12 @@ function checkBareSignalOrMemoIdentifier(expr, ctx) {
 function isArrayExprDirectPropRef(arrayExpr, ctx) {
   const propNames = new Set(ctx.patterns.props.map((p) => p.name));
   const propsObjName = ctx.analyzer.propsObjectName;
-  if (ts12.isIdentifier(arrayExpr)) {
+  if (ts13.isIdentifier(arrayExpr)) {
     return propNames.has(arrayExpr.text);
   }
-  if (ts12.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+  if (ts13.isPropertyAccessExpression(arrayExpr) && propsObjName) {
     const obj = arrayExpr.expression;
-    if (ts12.isIdentifier(obj) && obj.text === propsObjName) {
+    if (ts13.isIdentifier(obj) && obj.text === propsObjName) {
       return true;
     }
   }
@@ -13173,7 +13279,7 @@ function referencesLoopParam(expr, ctx) {
   if (boundNames.size === 0)
     return false;
   for (const p of boundNames) {
-    if (new RegExp(`\\b${p}\\b`).test(expr))
+    if (identifierPattern(p).test(expr))
       return true;
   }
   return false;
@@ -13255,7 +13361,7 @@ function hasReactiveAttributes(attrs, ctx) {
     const scopeValueNames = ctx.scope.valueBoundNames();
     if (scopeValueNames.size > 0) {
       for (const p of scopeValueNames) {
-        if (new RegExp(`\\b${p}\\b`).test(valueToCheck))
+        if (identifierPattern(p).test(valueToCheck))
           return true;
       }
     }
@@ -13346,7 +13452,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
         jsxBranchLocalNames.add(n);
     }
     for (const decl of condReturn.scopeVariables) {
-      if (ts12.isIdentifier(decl.name) && decl.initializer) {
+      if (ts13.isIdentifier(decl.name) && decl.initializer) {
         branchScopeVars.set(decl.name.text, decl.initializer);
         if (initializerShapeContainsJsx(decl.initializer)) {
           jsxBranchLocalNames.add(decl.name.text);
@@ -13413,7 +13519,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
     }
     const scopeVariables = [];
     for (const decl of condReturn.scopeVariables) {
-      if (ts12.isIdentifier(decl.name) && decl.initializer) {
+      if (ts13.isIdentifier(decl.name) && decl.initializer) {
         const init = ctx.getJS(decl.initializer);
         const typedInit = decl.initializer.getText(ctx.sourceFile);
         scopeVariables.push({
@@ -13461,18 +13567,22 @@ function buildIfStatementChain(analyzer, ctx, opts) {
 }
 
 // ../jsx/src/ir-to-client-js/prop-handling.ts
-function expandDynamicPropValue(value, ctx) {
+function expandDynamicPropValue(value, ctx, scope) {
   const trimmedValue = value.trim();
+  if (scope?.isBound(trimmedValue))
+    return value;
   const constant = ctx.localConstants.find((c) => c.name === trimmedValue);
   if (constant && constant.value) {
     return constant.value;
   }
   return value;
 }
-function expandConstantForReactivity(expr, ctx, originalFreeIds) {
+function expandConstantForReactivity(expr, ctx, originalFreeIds, scope) {
   if (ctx.propsObjectName)
     return { expr, freeIds: originalFreeIds };
   const trimmedValue = expr.trim();
+  if (scope?.isBound(trimmedValue))
+    return { expr, freeIds: originalFreeIds };
   const constant = ctx.localConstants.find((c) => c.name === trimmedValue);
   if (constant && constant.value) {
     return { expr: constant.value, freeIds: constant.freeIdentifiers };
@@ -13508,6 +13618,16 @@ function getControlledPropName(signal, propsParams, propsObjectName = null) {
 }
 
 // ../jsx/src/ir-to-client-js/reactivity.ts
+function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex) {
+  if (!loopParam)
+    return;
+  return BindingScope.EMPTY.enterLoopRow({
+    param: loopParam,
+    paramBindings: loopParamBindings,
+    index: loopIndex,
+    preamble: preambleNames && preambleNames.size > 0 ? { declaredNames: [...preambleNames] } : undefined
+  });
+}
 function decideWrapFromAstFlags(node) {
   if (node.origin && isReactiveOrigin(node.origin)) {
     return { wrap: true, reason: "proven-reactive" };
@@ -13536,12 +13656,12 @@ function decideWrapForChildProp(expandedValue, ctx, prop) {
 }
 function needsEffectWrapper(expr, ctx, freeIdentifiers2) {
   for (const signal of ctx.signals) {
-    if (new RegExp(`\\b${signal.getter}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(signal.getter).test(expr)) {
       return true;
     }
   }
   for (const memo of ctx.memos) {
-    if (new RegExp(`\\b${memo.name}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(memo.name).test(expr)) {
       return true;
     }
   }
@@ -13731,8 +13851,9 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
+function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
   const texts = [];
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
   walkIR(node, false, {
     ...stopAt("loop", "async", "ifStatement"),
     expression: ({ node: n, scope: insideConditional }) => {
@@ -13741,7 +13862,7 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings,
       if (n.preambleRegion)
         return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
-      const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds);
+      const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds, scope);
       const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
       if (!reactive)
         return;
@@ -13765,8 +13886,9 @@ function anyNameIn(names, set) {
       return true;
   return false;
 }
-function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames) {
+function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
   const attrs = [];
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
   traverseElements(node, (el) => {
     if (el.slotId) {
       for (const attr of el.attrs) {
@@ -13779,7 +13901,7 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings,
         const valueStr = attrValueToString(attr.value);
         if (!valueStr)
           continue;
-        const expanded = expandConstantForReactivity(valueStr, ctx, attr.freeIdentifiers);
+        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;
         if (!attr.clientOnly && !reactive)
@@ -14084,13 +14206,13 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
         const emitDepth = fixedDepth ?? scope.depth + 1;
         const loopParamsForTemplate = outerLoopParam ? [outerLoopParam, { param: n.param, bindings: n.paramBindings }] : undefined;
         const template = n.children.map((c) => irToPlaceholderTemplate(c, undefined, emitDepth, loopParamsForTemplate)).join("");
-        const refsOuter = outerLoopParam ? new RegExp(`\\b${outerLoopParam}\\b`).test(n.array) : false;
+        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));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, false, innerPreambleNames));
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings, false, innerPreambleNames, n.index));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, false, innerPreambleNames, n.index));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
         }
@@ -14117,7 +14239,7 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
             bindings.events.push(...collectLoopChildEventsWithNesting(child));
           }
           if (ctx) {
-            bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings));
+            bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings, innerPreambleNames, n.index));
           }
         }
         result.push({
@@ -14313,7 +14435,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         return;
       const projectionInner = l.method === "flatMap" && l.children.length === 1 && l.children[0].type === "loop" ? l.children[0] : undefined;
       const childHandlers = [];
-      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l));
+      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l), l.index);
       if (!projectionInner) {
         for (const child of l.children) {
           childHandlers.push(...collectEventHandlersFromIR(child));
@@ -14568,7 +14690,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, undefined, 0, branchLoopParamSpec)).join("");
       }
-      const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n)) : emptyLoopChildBindings();
+      const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n), n.index) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
         array: n.array,
@@ -14654,19 +14776,20 @@ function preambleNamesOf(loop) {
   const declared = loop.preamble?.declaredNames;
   return declared && declared.length > 0 ? new Set(declared) : undefined;
 }
-function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames) {
+function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
   const bindings = emptyLoopChildBindings();
   for (const child of children) {
     bindings.events.push(...collectLoopChildEventsWithNesting(child));
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true, preambleNames));
-    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings, true));
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true, preambleNames, loopIndex));
+    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings, true, preambleNames, loopIndex));
     bindings.refs.push(...collectLoopChildRefs(child));
-    bindings.conditionals.push(...collectLoopChildConditionals(child, ctx, siblingOffsets, loopParam, loopParamBindings));
+    bindings.conditionals.push(...collectLoopChildConditionals(child, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex));
   }
   return bindings;
 }
-function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings) {
+function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
   const conditionals = [];
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
   const refsAnyBindingViaFreeIds = (freeIds) => {
     if (loopParamBindings && loopParamBindings.length > 0) {
       for (const b of loopParamBindings) {
@@ -14686,8 +14809,9 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
       const refsLoopParamInSource = refsAnyBindingViaFreeIds(sourceFreeIds);
       if (!n.reactive && !refsLoopParamInSource)
         return;
-      const expanded = expandConstantForReactivity(n.condition, ctx, sourceFreeIds);
-      if (classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === "none")
+      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")
         return;
       const loopParamsForCond = loopParam ? [{ param: loopParam, bindings: loopParamBindings }] : undefined;
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, undefined, 0, loopParamsForCond, "__slots");
@@ -14697,23 +14821,24 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
         condition: expanded.expr,
         whenTrueHtml,
         whenFalseHtml,
-        whenTrue: summarizeLoopChildBranch(n.whenTrue, ctx, siblingOffsets, loopParam, loopParamBindings),
-        whenFalse: summarizeLoopChildBranch(n.whenFalse, ctx, siblingOffsets, loopParam, loopParamBindings),
-        ...expanded.freeIds !== undefined && { conditionFreeIdentifiers: expanded.freeIds }
+        whenTrue: summarizeLoopChildBranch(n.whenTrue, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
+        whenFalse: summarizeLoopChildBranch(n.whenFalse, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
+        ...expanded.freeIds !== undefined && { conditionFreeIdentifiers: expanded.freeIds },
+        ...readsPreamble && { readsPreamble: true }
       });
     }
   });
   return conditionals;
 }
-function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopParamBindings) {
+function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
   const inner = collectInnerLoops([node], siblingOffsets, loopParam, ctx, branchInnerLoopOptions);
   return {
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : undefined,
-    conditionals: collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings),
+    conditionals: collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
     events: collectConditionalBranchEvents(node),
-    reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, true),
-    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, true)
+    reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, true, preambleNames, loopIndex),
+    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, true, preambleNames, loopIndex)
   };
 }
 
@@ -15075,7 +15200,7 @@ function graphDeclarationReferences(graph, kind, name) {
 }
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function collectPropAccesses(source, propNames, out) {
   if (propNames.size === 0)
     return;
@@ -15089,7 +15214,7 @@ function collectPropAccesses(source, propNames, out) {
   if (!anyMentioned)
     return;
   for (const expr of normaliseExpressionParts(source)) {
-    const sourceFile = ts13.createSourceFile("p.ts", expr, ts13.ScriptTarget.Latest, false, ts13.ScriptKind.TS);
+    const sourceFile = ts14.createSourceFile("p.ts", expr, ts14.ScriptTarget.Latest, false, ts14.ScriptKind.TS);
     visit2(sourceFile, propNames, out);
   }
 }
@@ -15099,15 +15224,15 @@ function normaliseExpressionParts(source) {
   return extractTemplateExpressions(source);
 }
 function visit2(node, propNames, out) {
-  if (ts13.isPropertyAccessExpression(node)) {
+  if (ts14.isPropertyAccessExpression(node)) {
     recordIfPropAccess(node.expression, "property", propNames, out);
-  } else if (ts13.isElementAccessExpression(node)) {
+  } else if (ts14.isElementAccessExpression(node)) {
     recordIfPropAccess(node.expression, "index", propNames, out);
   }
-  ts13.forEachChild(node, (child) => visit2(child, propNames, out));
+  ts14.forEachChild(node, (child) => visit2(child, propNames, out));
 }
 function recordIfPropAccess(receiver, kind, propNames, out) {
-  if (!ts13.isIdentifier(receiver))
+  if (!ts14.isIdentifier(receiver))
     return;
   const name = receiver.text;
   if (!propNames.has(name))
@@ -15160,56 +15285,56 @@ function propHasPropertyAccess(u) {
 }
 
 // ../jsx/src/value-references.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function isValueReferenceIdentifier(id) {
   const parent = id.parent;
   if (!parent)
     return false;
-  if (ts14.isPropertyAccessExpression(parent) && parent.name === id)
+  if (ts15.isPropertyAccessExpression(parent) && parent.name === id)
     return false;
-  if (ts14.isPropertyAssignment(parent) && parent.name === id)
+  if (ts15.isPropertyAssignment(parent) && parent.name === id)
     return false;
-  if ((ts14.isMethodDeclaration(parent) || ts14.isGetAccessorDeclaration(parent) || ts14.isSetAccessorDeclaration(parent)) && parent.name === id) {
+  if ((ts15.isMethodDeclaration(parent) || ts15.isGetAccessorDeclaration(parent) || ts15.isSetAccessorDeclaration(parent)) && parent.name === id) {
     return false;
   }
-  if (ts14.isPropertyDeclaration(parent) && parent.name === id)
+  if (ts15.isPropertyDeclaration(parent) && parent.name === id)
     return false;
-  if (ts14.isMetaProperty(parent) && parent.name === id)
+  if (ts15.isMetaProperty(parent) && parent.name === id)
     return false;
-  if (ts14.isVariableDeclaration(parent) && parent.name === id)
+  if (ts15.isVariableDeclaration(parent) && parent.name === id)
     return false;
-  if (ts14.isFunctionDeclaration(parent) && parent.name === id)
+  if (ts15.isFunctionDeclaration(parent) && parent.name === id)
     return false;
-  if (ts14.isFunctionExpression(parent) && parent.name === id)
+  if (ts15.isFunctionExpression(parent) && parent.name === id)
     return false;
-  if (ts14.isClassDeclaration(parent) && parent.name === id)
+  if (ts15.isClassDeclaration(parent) && parent.name === id)
     return false;
-  if (ts14.isClassExpression(parent) && parent.name === id)
+  if (ts15.isClassExpression(parent) && parent.name === id)
     return false;
-  if (ts14.isParameter(parent) && parent.name === id)
+  if (ts15.isParameter(parent) && parent.name === id)
     return false;
-  if (ts14.isBindingElement(parent) && (parent.name === id || parent.propertyName === id))
+  if (ts15.isBindingElement(parent) && (parent.name === id || parent.propertyName === id))
     return false;
-  if (ts14.isLabeledStatement(parent) && parent.label === id)
+  if (ts15.isLabeledStatement(parent) && parent.label === id)
     return false;
-  if (ts14.isBreakOrContinueStatement(parent) && parent.label === id)
+  if (ts15.isBreakOrContinueStatement(parent) && parent.label === id)
     return false;
-  if (ts14.isImportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
+  if (ts15.isImportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
     return false;
-  if (ts14.isExportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
+  if (ts15.isExportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
     return false;
-  if (ts14.isImportClause(parent) && parent.name === id)
+  if (ts15.isImportClause(parent) && parent.name === id)
     return false;
-  if (ts14.isNamespaceImport(parent) && parent.name === id)
+  if (ts15.isNamespaceImport(parent) && parent.name === id)
     return false;
-  if (ts14.isQualifiedName(parent) && parent.right === id)
+  if (ts15.isQualifiedName(parent) && parent.right === id)
     return false;
   return true;
 }
 function collectValueReferencedNames(code) {
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile("generated.js", code, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.JS);
+    sourceFile = ts15.createSourceFile("generated.js", code, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.JS);
   } catch {
     return null;
   }
@@ -15218,10 +15343,10 @@ function collectValueReferencedNames(code) {
     return null;
   const names = new Set;
   function visit3(node) {
-    if (ts14.isIdentifier(node) && isValueReferenceIdentifier(node)) {
+    if (ts15.isIdentifier(node) && isValueReferenceIdentifier(node)) {
       names.add(node.text);
     }
-    ts14.forEachChild(node, visit3);
+    ts15.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   return names;
@@ -15285,7 +15410,7 @@ var MODULE_CONSTANTS_PLACEHOLDER = "/* __MODULE_LEVEL_CONSTANTS__ */";
 function detectUsedImports(code) {
   const used = new Set;
   for (const name of RUNTIME_IMPORT_CANDIDATES) {
-    if (new RegExp(`\\b${name}\\s*\\(`).test(code)) {
+    if (identifierCallPattern(name).test(code)) {
       used.add(name);
     }
   }
@@ -15389,7 +15514,7 @@ function collectComponentNames(node) {
 }
 
 // ../jsx/src/relocate.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -15417,19 +15542,19 @@ function classify(name, env) {
 function collectFreeRefs(node) {
   const refs = new Map;
   function visit3(n, parent) {
-    if (ts15.isIdentifier(n)) {
-      if (parent && ts15.isPropertyAccessExpression(parent) && parent.name === n)
+    if (ts16.isIdentifier(n)) {
+      if (parent && ts16.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts15.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts16.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts15.isShorthandPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts16.isShorthandPropertyAssignment(parent) && parent.name === n)
         return;
       const list = refs.get(n.text) ?? [];
       list.push(n);
       refs.set(n.text, list);
       return;
     }
-    ts15.forEachChild(n, (child) => visit3(child, n));
+    ts16.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return refs;
@@ -15533,11 +15658,11 @@ function isInlinableInTemplate(value, env) {
   return { ok: true, rewrittenValue: r.text, decisions: r.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts15.isParenthesizedExpression(callee))
+  if (ts16.isParenthesizedExpression(callee))
     return getCalleeIdentifierPath(callee.expression);
-  if (ts15.isIdentifier(callee))
+  if (ts16.isIdentifier(callee))
     return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null)
       return null;
@@ -15546,11 +15671,11 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts15.isParenthesizedExpression(callee))
+  if (ts16.isParenthesizedExpression(callee))
     return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts15.isIdentifier(callee))
+  if (ts16.isIdentifier(callee))
     return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -15598,12 +15723,12 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts15.createSourceFile("__inline_check__.ts", `(${text});`, ts15.ScriptTarget.Latest, false, ts15.ScriptKind.TS);
+    const sf = ts16.createSourceFile("__inline_check__.ts", `(${text});`, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.TS);
     const stmt = sf.statements[0];
-    if (!stmt || !ts15.isExpressionStatement(stmt))
+    if (!stmt || !ts16.isExpressionStatement(stmt))
       return null;
     const inner = stmt.expression;
-    return ts15.isParenthesizedExpression(inner) ? inner.expression : inner;
+    return ts16.isParenthesizedExpression(inner) ? inner.expression : inner;
   } catch {
     return null;
   }
@@ -15620,8 +15745,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts15.isCallExpression(n) || ts15.isNewExpression(n)) {
-      const accepted = ts15.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
+    if (ts16.isCallExpression(n) || ts16.isNewExpression(n)) {
+      const accepted = ts16.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
       if (!accepted) {
         const args = n.arguments;
         if (args) {
@@ -15634,7 +15759,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15644,13 +15769,13 @@ function hasZeroArgCall(node, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts15.isCallExpression(n) && n.arguments.length === 0) {
+    if (ts16.isCallExpression(n) && n.arguments.length === 0) {
       if (!isCallAcceptedByAdapter(n, env)) {
         found = true;
         return;
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15660,25 +15785,25 @@ function containsAnyIdentifier(node, names) {
   function visit3(n) {
     if (found)
       return;
-    if (ts15.isPropertyAccessExpression(n)) {
+    if (ts16.isPropertyAccessExpression(n)) {
       visit3(n.expression);
       return;
     }
-    if (ts15.isPropertyAssignment(n)) {
+    if (ts16.isPropertyAssignment(n)) {
       visit3(n.initializer);
       return;
     }
-    if (ts15.isShorthandPropertyAssignment(n)) {
-      if (ts15.isIdentifier(n.name) && names.has(n.name.text)) {
+    if (ts16.isShorthandPropertyAssignment(n)) {
+      if (ts16.isIdentifier(n.name) && names.has(n.name.text)) {
         found = true;
       }
       return;
     }
-    if (ts15.isIdentifier(n) && names.has(n.text)) {
+    if (ts16.isIdentifier(n) && names.has(n.text)) {
       found = true;
       return;
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15686,7 +15811,7 @@ function containsAnyIdentifier(node, names) {
 function scanRefsByName(text, bindings) {
   const result = new Map;
   for (const name of bindings.keys()) {
-    const re = new RegExp(`\\b${name}\\b`);
+    const re = identifierPattern(name);
     if (re.test(text))
       result.set(name, []);
   }
@@ -16957,23 +17082,23 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 }
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function propExtractionName(stmt) {
-  if (!ts16.isVariableStatement(stmt))
+  if (!ts17.isVariableStatement(stmt))
     return null;
   const decls = stmt.declarationList.declarations;
   if (decls.length !== 1)
     return null;
   const decl = decls[0];
-  if (!ts16.isIdentifier(decl.name) || !decl.initializer)
+  if (!ts17.isIdentifier(decl.name) || !decl.initializer)
     return null;
   let core = decl.initializer;
-  if (ts16.isBinaryExpression(core) && core.operatorToken.kind === ts16.SyntaxKind.QuestionQuestionToken) {
+  if (ts17.isBinaryExpression(core) && core.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken) {
     core = core.left;
   }
-  if (!ts16.isPropertyAccessExpression(core))
+  if (!ts17.isPropertyAccessExpression(core))
     return null;
-  if (!ts16.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
+  if (!ts17.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
     return null;
   if (core.name.text !== decl.name.text)
     return null;
@@ -16986,10 +17111,10 @@ function pruneUnusedPropExtractions(code) {
       console.warn("[barefootjs] pruneUnusedPropExtractions: generated code did not parse; skipping prune");
       return code;
     }
-    const sourceFile = ts16.createSourceFile("generated.js", code, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.JS);
+    const sourceFile = ts17.createSourceFile("generated.js", code, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.JS);
     const spans = [];
     for (const stmt of sourceFile.statements) {
-      if (!ts16.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body)
+      if (!ts17.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body)
         continue;
       for (const inner of stmt.body.statements) {
         const name = propExtractionName(inner);
@@ -17951,7 +18076,8 @@ function buildReactiveEffectsPlan(args) {
         whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
         whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
         whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, profileComponentName),
-        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, profileComponentName)
+        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, profileComponentName),
+        ...cond.readsPreamble && { readsPreamble: true }
       });
     }
   }
@@ -18354,7 +18480,7 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
 function buildKeyedOrIndexLookup(args) {
   const hasBindings = (args.paramBindings?.length ?? 0) > 0;
   if (args.key !== null) {
-    const keyWithItem = hasBindings ? substituteLoopBindings(args.key, args.paramBindings, "item") : args.key.replace(new RegExp(`\\b${args.param}\\b`, "g"), "item");
+    const keyWithItem = hasBindings ? substituteLoopBindings(args.key, args.paramBindings, "item") : args.key.replace(identifierPattern(args.param, "g"), "item");
     return {
       kind: "keyed",
       arrayExpr: args.array,
@@ -18432,7 +18558,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -18452,12 +18578,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   if (text.trim().length === 0)
     return NO_PREAMBLE;
   const declaredNames = new Set;
-  const sf = ts17.createSourceFile("__lazy_preamble__.ts", text, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TS);
+  const sf = ts18.createSourceFile("__lazy_preamble__.ts", text, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
   for (const stmt of sf.statements) {
-    if (!ts17.isVariableStatement(stmt)) {
-      return NO2(`map-callback preamble has a non-declaration statement (${ts17.SyntaxKind[stmt.kind]})`);
+    if (!ts18.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts18.SyntaxKind[stmt.kind]})`);
     }
-    const isConst = (stmt.declarationList.flags & ts17.NodeFlags.Const) !== 0;
+    const isConst = (stmt.declarationList.flags & ts18.NodeFlags.Const) !== 0;
     if (!isConst)
       return NO2("map-callback preamble declares a mutable binding (let/var)");
     for (const decl of stmt.declarationList.declarations) {
@@ -18486,12 +18612,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   return { lazySafe: true, facts: { declaredNames, freeNames } };
 }
 function collectBindingNames3(name, out) {
-  if (ts17.isIdentifier(name)) {
+  if (ts18.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const element of name.elements) {
-    if (ts17.isOmittedExpression(element))
+    if (ts18.isOmittedExpression(element))
       continue;
     collectBindingNames3(element.name, out);
   }
@@ -18501,56 +18627,56 @@ function findImpureNode(root, primableNames) {
   const visit3 = (node) => {
     if (found)
       return;
-    if (ts17.isCallExpression(node)) {
+    if (ts18.isCallExpression(node)) {
       const callee = node.expression;
-      const isSignalRead = ts17.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
+      const isSignalRead = ts18.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
       if (!isSignalRead) {
         found = `call to ${callee.getText(callee.getSourceFile())}`;
         return;
       }
     }
-    if (ts17.isNewExpression(node)) {
+    if (ts18.isNewExpression(node)) {
       found = "new expression";
       return;
     }
-    if (ts17.isTaggedTemplateExpression(node)) {
+    if (ts18.isTaggedTemplateExpression(node)) {
       found = "tagged template";
       return;
     }
-    if (ts17.isAwaitExpression(node)) {
+    if (ts18.isAwaitExpression(node)) {
       found = "await";
       return;
     }
-    if (ts17.isYieldExpression(node)) {
+    if (ts18.isYieldExpression(node)) {
       found = "yield";
       return;
     }
-    if (ts17.isPrefixUnaryExpression(node) || ts17.isPostfixUnaryExpression(node)) {
+    if (ts18.isPrefixUnaryExpression(node) || ts18.isPostfixUnaryExpression(node)) {
       const op = node.operator;
-      if (op === ts17.SyntaxKind.PlusPlusToken || op === ts17.SyntaxKind.MinusMinusToken) {
+      if (op === ts18.SyntaxKind.PlusPlusToken || op === ts18.SyntaxKind.MinusMinusToken) {
         found = "increment/decrement";
         return;
       }
     }
-    if (ts17.isDeleteExpression(node)) {
+    if (ts18.isDeleteExpression(node)) {
       found = "delete";
       return;
     }
-    if (ts17.isFunctionExpression(node) || ts17.isArrowFunction(node) || ts17.isClassExpression(node)) {
+    if (ts18.isFunctionExpression(node) || ts18.isArrowFunction(node) || ts18.isClassExpression(node)) {
       found = "function or class expression";
       return;
     }
-    if (ts17.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts18.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
       found = "assignment";
       return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   };
   visit3(root);
   return found;
 }
-function isAssignmentOperator(kind) {
-  return kind >= ts17.SyntaxKind.FirstAssignment && kind <= ts17.SyntaxKind.LastAssignment;
+function isAssignmentOperator2(kind) {
+  return kind >= ts18.SyntaxKind.FirstAssignment && kind <= ts18.SyntaxKind.LastAssignment;
 }
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -19080,7 +19206,7 @@ function buildArmBody(branch, options) {
 }
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -19184,20 +19310,20 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts18.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
+    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt))
+  if (!stmt || !ts19.isExpressionStatement(stmt))
     return expr;
-  const root = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts18.isCallExpression(n) && n.arguments.length === 2 && ts18.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts19.isCallExpression(n) && n.arguments.length === 2 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -19233,20 +19359,20 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts18.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
+    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt))
+  if (!stmt || !ts19.isExpressionStatement(stmt))
     return expr;
-  const root = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts18.isCallExpression(n) && n.arguments.length === 0 && ts18.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts19.isCallExpression(n) && n.arguments.length === 0 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -19561,7 +19687,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
     emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, outerTexts, elementIndexBySlot, textClaimPathExprs, preambleRegions, mapPreambleWrapped);
   }
   for (const cond of conditionals) {
-    emitOuterConditional(lines, indent, elVar, cond, pc);
+    emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped);
   }
 }
 function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped) {
@@ -19663,9 +19789,10 @@ function emitOuterTexts(lines, indent, elVar, texts, bindingBfId, textClaimPathE
     lines.push(`${indent}createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${bindingBfId(text.slotId)})`);
   }
 }
-function emitOuterConditional(lines, indent, elVar, cond, pc) {
+function emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  lines.push(`${indent}insert(${elVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
+  const conditionGetter = cond.readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${cond.wrappedCondition}) }` : `() => ${cond.wrappedCondition}`;
+  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);
@@ -20560,7 +20687,7 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
   }
   for (const nested of ev.nestedLoops) {
     const rawKey = nested.key ?? "";
-    const innerKeyExpr = nested.paramBindings && nested.paramBindings.length > 0 ? substituteLoopBindings(rawKey, nested.paramBindings, "item") : rawKey.replace(new RegExp(`\\b${nested.param}\\b`, "g"), "item");
+    const innerKeyExpr = nested.paramBindings && nested.paramBindings.length > 0 ? substituteLoopBindings(rawKey, nested.paramBindings, "item") : rawKey.replace(identifierPattern(nested.param, "g"), "item");
     const outerRef = hasBindings ? "__bfLoopItem" : param;
     ls.push(`      const ${nested.param} = ${outerRef} && ${nested.array}.find(item => String(${innerKeyExpr}) === innerKey${nested.depth})`);
   }
@@ -21249,20 +21376,20 @@ var PHASES = [
 ];
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM)
     return code;
-  if (!new RegExp(`\\b${srcPropsName}\\b`).test(code))
+  if (!identifierPattern(srcPropsName).test(code))
     return code;
-  const sourceFile = ts19.createSourceFile("init-body.ts", code, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
+  const sourceFile = ts20.createSourceFile("init-body.ts", code, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts19.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts20.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts19.forEachChild(node, visit3);
+    ts20.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -21278,17 +21405,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts19.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts20.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts19.isPropertyAssignment(parent) && parent.name === node)
+  if (ts20.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts19.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts20.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts19.isPropertySignature(parent) && parent.name === node)
+  if (ts20.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts19.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts20.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts19.isBindingElement(parent) && parent.name === node)
+  if (ts20.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -21939,7 +22066,7 @@ function walkIR2(node, visitor) {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -21961,8 +22088,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts20.createSourceFile(filePath, source, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts20.isExpressionStatement(stmt) && ts20.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const sourceFile = ts21.createSourceFile(filePath, source, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
+  const hasUseClient = sourceFile.statements.some((stmt) => ts21.isExpressionStatement(stmt) && ts21.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -21984,22 +22111,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts20.isJsxAttribute(node) && node.initializer && ts20.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts21.isJsxAttribute(node) && node.initializer && ts21.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts20.isPropertyAssignment(node) && node.initializer) {
+    if (ts21.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts20.isParenthesizedExpression(expr))
+    while (ts21.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts20.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts21.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -22036,7 +22163,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts20.forEachChild(sourceFile, visit3);
+  ts21.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -22059,11 +22186,11 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ` + `${captures.sort().join(", ")}. ` + `Extract the callback into a top-level '\\'use client\\'' component (e.g. ` + `\`function MyNode(n) { return <div/> }\` then \`renderNode={MyNode}\`) ` + `or pass captured values via component props.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts20.isBlock(arrow.body)) {
+  if (ts21.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts20.isParenthesizedExpression(body))
+  while (ts21.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -22072,24 +22199,24 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts20.isReturnStatement(n) && n.expression) {
+    if (ts21.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts20.isParenthesizedExpression(e))
+      while (ts21.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts20.isArrowFunction(n) || ts20.isFunctionDeclaration(n) || ts20.isFunctionExpression(n))
+    if (ts21.isArrowFunction(n) || ts21.isFunctionDeclaration(n) || ts21.isFunctionExpression(n))
       return;
-    ts20.forEachChild(n, visit3);
+    ts21.forEachChild(n, visit3);
   }
-  ts20.forEachChild(block, visit3);
+  ts21.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts20.isJsxElement(expr) || ts20.isJsxSelfClosingElement(expr) || ts20.isJsxFragment(expr);
+  return ts21.isJsxElement(expr) || ts21.isJsxSelfClosingElement(expr) || ts21.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
@@ -22099,13 +22226,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames4(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts20.isIdentifier(name)) {
+  if (ts21.isIdentifier(name)) {
     push(name.text);
-  } else if (ts20.isObjectBindingPattern(name)) {
+  } else if (ts21.isObjectBindingPattern(name)) {
     name.elements.forEach((el) => collectBindingNames4(el.name, out));
-  } else if (ts20.isArrayBindingPattern(name)) {
+  } else if (ts21.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts20.isOmittedExpression(el))
+      if (!ts21.isOmittedExpression(el))
         collectBindingNames4(el.name, out);
     });
   }
@@ -22132,48 +22259,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts20.isIdentifier(node)) {
+    if (ts21.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts20.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts21.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts20.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts21.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts20.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts21.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts20.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts21.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts20.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isEnumMember(parent) && parent.name === node)
+      if (parent && ts21.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts20.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts21.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts20.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts21.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts20.isParameter(parent) && parent.name === node)
+      if (parent && ts21.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts20.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts21.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts20.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts21.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts20.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts21.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts20.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts21.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -22182,43 +22309,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts20.isVariableDeclaration(node)) {
+    if (ts21.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts20.isFunctionDeclaration(node)) {
+    if (ts21.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts20.isClassDeclaration(node)) {
+    if (ts21.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       return;
     }
-    if (ts20.isArrowFunction(node) || ts20.isFunctionExpression(node)) {
+    if (ts21.isArrowFunction(node) || ts21.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts20.isCatchClause(node)) {
+    if (ts21.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts20.isBlock(node)) {
+    if (ts21.isBlock(node)) {
       const before = bound.length;
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -22241,29 +22368,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts20.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts21.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts20.isClassDeclaration(stmt) && stmt.name)
+    else if (ts21.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts20.isVariableStatement(stmt)) {
+    else if (ts21.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
         collectBindingNames4(decl.name, names);
-    } else if (ts20.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts21.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts20.isNamespaceImport(ic.namedBindings))
+        if (ts21.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts20.isTypeAliasDeclaration(stmt))
+    } else if (ts21.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts20.isInterfaceDeclaration(stmt))
+    else if (ts21.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts20.isEnumDeclaration(stmt))
+    else if (ts21.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -22271,7 +22398,7 @@ function collectModuleScopeNames(sourceFile) {
 function buildSyntheticDeclaration(name, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts20.isBlock(arrow.body)) {
+  if (ts21.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -22281,7 +22408,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // ../jsx/src/ssr-defaults.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -22358,11 +22485,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts21.isPropertyAccessExpression(n) && ts21.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts21.isIdentifier(n.name)) {
+    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts22.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts21.forEachChild(n, visit3);
+    ts22.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -22383,23 +22510,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts21.isVariableStatement(stmt)) {
+    if (ts22.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts21.isIdentifier(d.name) || !d.initializer)
+        if (!ts22.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts21.isReturnStatement(stmt)) {
+    } else if (ts22.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts21.isIfStatement(stmt)) {
+    } else if (ts22.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx);
       if (cond === UNRESOLVED)
         return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
-        const taken = evalStatementsForReturn(ts21.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts22.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -22410,45 +22537,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts21.createSourceFile("__ssr_default__.ts", `(${expr})`, ts21.ScriptTarget.Latest, false, ts21.ScriptKind.TS);
+  const sf = ts22.createSourceFile("__ssr_default__.ts", `(${expr})`, ts22.ScriptTarget.Latest, false, ts22.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt))
+  if (!stmt || !ts22.isExpressionStatement(stmt))
     return null;
-  const inner = ts21.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts22.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts21.isParenthesizedExpression(node))
+  if (ts22.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts21.isAsExpression(node))
+  if (ts22.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts21.isSatisfiesExpression(node))
+  if (ts22.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts21.isTypeAssertionExpression(node))
+  if (ts22.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts21.isNonNullExpression(node))
+  if (ts22.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts21.isArrowFunction(node)) {
+  if (ts22.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts21.isBlock(node.body))
+    if (!ts22.isBlock(node.body))
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
     const result = evalStatementsForReturn(node.body.statements, localCtx);
     return result === NO_RETURN ? UNRESOLVED : result;
   }
-  if (ts21.isNumericLiteral(node))
+  if (ts22.isNumericLiteral(node))
     return Number(node.text);
-  if (ts21.isStringLiteralLike(node))
+  if (ts22.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts21.SyntaxKind.TrueKeyword)
+  if (node.kind === ts22.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts21.SyntaxKind.FalseKeyword)
+  if (node.kind === ts22.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts21.SyntaxKind.NullKeyword)
+  if (node.kind === ts22.SyntaxKind.NullKeyword)
     return null;
-  if (ts21.isIdentifier(node)) {
+  if (ts22.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -22457,29 +22584,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts21.isPrefixUnaryExpression(node)) {
+  if (ts22.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts21.SyntaxKind.MinusToken:
+      case ts22.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts21.SyntaxKind.PlusToken:
+      case ts22.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts21.SyntaxKind.ExclamationToken:
+      case ts22.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts21.isObjectLiteralExpression(node)) {
+  if (ts22.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts21.isPropertyAssignment(prop))
+      if (!ts22.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts21.isIdentifier(prop.name) || ts21.isStringLiteralLike(prop.name)) {
+      if (ts22.isIdentifier(prop.name) || ts22.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts21.isNumericLiteral(prop.name)) {
+      } else if (ts22.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -22491,10 +22618,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts21.isArrayLiteralExpression(node)) {
+  if (ts22.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts21.isOmittedExpression(elem))
+      if (ts22.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -22503,7 +22630,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts21.isElementAccessExpression(node)) {
+  if (ts22.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -22517,17 +22644,17 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts21.isPropertyAccessExpression(node)) {
+  if (ts22.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
     return UNRESOLVED;
   }
-  if (ts21.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts21.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts22.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts22.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts21.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep = ",";
@@ -22543,27 +22670,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts21.isConditionalExpression(node)) {
+  if (ts22.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts21.isBinaryExpression(node)) {
+  if (ts22.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts21.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts22.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts21.SyntaxKind.BarBarToken) {
+    if (op === ts22.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts21.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts22.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -22576,30 +22703,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts21.SyntaxKind.PlusToken:
+      case ts22.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r === "string")
           return `${l}${r}`;
         if (typeof l === "number" && typeof r === "number")
           return l + r;
         return UNRESOLVED;
-      case ts21.SyntaxKind.MinusToken:
+      case ts22.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts21.SyntaxKind.AsteriskToken:
+      case ts22.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts21.SyntaxKind.SlashToken:
+      case ts22.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts21.SyntaxKind.PercentToken:
+      case ts22.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts21.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts21.SyntaxKind.EqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts21.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts21.SyntaxKind.ExclamationEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts21.isTemplateExpression(node)) {
+  if (ts22.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -22611,41 +22738,41 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts21.isNoSubstitutionTemplateLiteral(node))
+  if (ts22.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // ../jsx/src/augment-inherited-props.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function parseStaticStringConst(source) {
-  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
+  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt))
+  if (!stmt || !ts23.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init))
+  while (init && ts23.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts22.isStringLiteral(init) || ts22.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts23.isStringLiteral(init) || ts23.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
+  const sf = ts23.createSourceFile("__const.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt))
+  if (!stmt || !ts23.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init))
+  while (init && ts23.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts22.isTemplateExpression(init))
+  if (!init || !ts23.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts22.isIdentifier(span.expression))
+    if (!ts23.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -22673,28 +22800,28 @@ function collectModuleStringConsts(constants) {
   return map;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts22.createSourceFile("__join.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
+  const sf = ts23.createSourceFile("__join.ts", `const __x = (${source});`, ts23.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt))
+  if (!stmt || !ts23.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts22.isParenthesizedExpression(node))
+  while (node && ts23.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts22.isCallExpression(node))
+  if (!node || !ts23.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts22.isPropertyAccessExpression(callee))
+  if (!ts23.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts22.isParenthesizedExpression(recv))
+  while (ts23.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts22.isArrayLiteralExpression(recv))
+  if (!ts23.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts22.isStringLiteral(el) || ts22.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts23.isStringLiteral(el) || ts23.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -22703,7 +22830,7 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
+    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
       sep = arg.text;
     else
       return null;
@@ -23045,13 +23172,13 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   if (entries.some((e) => e.componentIR.metadata.isClientComponent)) {
     const topLevelNames = new Set;
     {
-      const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
+      const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
       for (const stmt of sf.statements) {
-        if (ts23.isFunctionDeclaration(stmt) && stmt.name)
+        if (ts24.isFunctionDeclaration(stmt) && stmt.name)
           topLevelNames.add(stmt.name.text);
-        else if (ts23.isVariableStatement(stmt)) {
+        else if (ts24.isVariableStatement(stmt)) {
           for (const d of stmt.declarationList.declarations) {
-            if (ts23.isIdentifier(d.name))
+            if (ts24.isIdentifier(d.name))
               topLevelNames.add(d.name.text);
           }
         }
@@ -23110,7 +23237,7 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   const moduleStatementSeen = new Set;
   const moduleStatementsOrdered = [];
   const collectModuleStatements = (block) => {
-    const sf = ts23.createSourceFile("__bf_module_decls.tsx", block, ts23.ScriptTarget.Latest, false, ts23.ScriptKind.TSX);
+    const sf = ts24.createSourceFile("__bf_module_decls.tsx", block, ts24.ScriptTarget.Latest, false, ts24.ScriptKind.TSX);
     for (const stmt of sf.statements) {
       const text = stmt.getText(sf);
       if (moduleStatementSeen.has(text))
@@ -23347,6 +23474,12 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   }
   return { files, errors };
 }
+function componentTypeParametersText(componentNode, sourceFile) {
+  const typeParameters = componentNode?.typeParameters;
+  if (!typeParameters || typeParameters.length === 0)
+    return null;
+  return `<${typeParameters.map((p) => p.getText(sourceFile)).join(", ")}>`;
+}
 function buildMetadata(ctx) {
   const metadata = {
     componentName: ctx.componentName || "Unknown",
@@ -23355,6 +23488,7 @@ function buildMetadata(ctx) {
     isClientComponent: ctx.hasUseClientDirective,
     typeDefinitions: ctx.typeDefinitions,
     propsType: ctx.propsType,
+    typeParameters: componentTypeParametersText(ctx.componentNode, ctx.sourceFile),
     propsParams: ctx.propsParams,
     propsObjectName: ctx.propsObjectName,
     restPropsName: ctx.restPropsName,
@@ -23545,7 +23679,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // ../jsx/src/shared-program.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 import path3 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0)
@@ -23567,10 +23701,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts24.ScriptTarget.Latest,
-    module: ts24.ModuleKind.ESNext,
-    moduleResolution: ts24.ModuleResolutionKind.Bundler,
-    jsx: ts24.JsxEmit.ReactJSX,
+    target: ts25.ScriptTarget.Latest,
+    module: ts25.ModuleKind.ESNext,
+    moduleResolution: ts25.ModuleResolutionKind.Bundler,
+    jsx: ts25.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -23580,7 +23714,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path3.resolve(f));
-  return ts24.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts25.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
@@ -23634,7 +23768,7 @@ class JsxAdapter extends BaseAdapter {
       ...localFunctions.map((f) => ({ name: f.name, body: f.body })),
       ...localConstants.map((c) => ({ name: c.name, body: c.value }))
     ];
-    const reachable = findReachableNames(primaryRefText, declarations);
+    const reachable = closeOverWritersOfMutableBindings(primaryRefText, declarations, new Set(ir.metadata.localConstants.filter((c) => (c.declarationKind ?? "const") !== "const").map((c) => c.name)));
     const reachableBodies = [...reachable].map((name) => {
       const func = localFunctions.find((f) => f.name === name);
       if (func)
@@ -23664,9 +23798,10 @@ class JsxAdapter extends BaseAdapter {
         lines.push(`  const ${signal.getter} = () => ${initialValue}`);
       }
       if (signal.setter) {
-        const setterUsed = new RegExp(`\\b${signal.setter}\\b`).test(setterRefText);
+        const setterUsed = identifierPattern(signal.setter).test(setterRefText);
         if (setterUsed) {
-          lines.push(`  const ${signal.setter} = (..._args: any[]) => {}`);
+          const setterType = preserveTypes && signal.type.kind !== "unknown" ? `(valueOrFn: ${signal.type.raw} | ((prev: ${signal.type.raw}) => ${signal.type.raw})) => void` : null;
+          lines.push(setterType ? `  const ${signal.setter}: ${setterType} = () => {}` : `  const ${signal.setter} = (..._args: any[]) => {}`);
         }
       }
     }
@@ -23862,6 +23997,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // ../jsx/src/adapters/template-imports.ts
+import ts26 from "typescript";
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -24000,7 +24136,8 @@ export default ${this.componentName}` : "";
     const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
     const lines = [];
     const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
-    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    const typeParameters = ir.metadata.typeParameters ?? "";
+    lines.push(`${exportPrefix}function ${name}${typeParameters}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
     if (hasClientInteractivity) {
       lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
     } else {
@@ -24251,11 +24388,11 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 // ../jsx/src/debug.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 // ../jsx/src/profiler.ts
-import ts27 from "typescript";
+import ts29 from "typescript";
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();