@barefootjs/jsx 0.31.3 → 0.31.5

package/dist/index.js

@@ -177,7 +177,7 @@ function findTopLevelTemplateLiterals(code) {
 }
 
 // src/compiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 
 // src/analyzer.ts
 import ts9 from "typescript";
@@ -2332,6 +2332,24 @@ function templatePartsToJsExpr(parts, opts) {
   return result;
 }
 
+// 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));
+}
+
 // src/ir-to-client-js/utils.ts
 import {
   BF_KEY as DATA_KEY,
@@ -2458,9 +2476,6 @@ function inferDefaultValue(type) {
     return "{}";
   return "undefined";
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function freeIdsFromRefs(refs) {
   const out = new Set;
   if (!refs)
@@ -2588,16 +2603,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) {
@@ -2868,7 +2883,7 @@ function stopAt(...kinds) {
 
 // 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 };
   }
@@ -2876,7 +2891,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;
@@ -2884,7 +2899,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 };
   }
@@ -2902,7 +2917,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})` });
@@ -3090,6 +3105,83 @@ function derivesScopeFromSlot(comp) {
   return comp.slotId != null && comp.loopItemRoot !== true;
 }
 
+// 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);
+  }
+}
+
 // src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -4315,7 +4407,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;
     }
@@ -4457,15 +4549,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)))
@@ -4474,7 +4559,7 @@ function generateCsrTemplateWithOpts(node, opts) {
         ...opts,
         loopDepth: loopDepth + 1,
         inHoistedChildren: false,
-        loopBoundNames: boundHere,
+        scope: childScope,
         csrEnv: childEnv
       });
       let childTemplate = node.children.map(recurseInLoopBody).join("");
@@ -9145,7 +9230,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
 }
 
 // src/jsx-to-ir.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -9251,6 +9336,7 @@ function pickAttrMetaFromIR(src) {
 }
 
 // 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) {
@@ -9330,7 +9416,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);
     }
@@ -9339,7 +9425,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);
       }
@@ -9347,6 +9433,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;
+}
 function extractFunctionParams(value) {
   const arrowMatch = value.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
   if (arrowMatch) {
@@ -9384,7 +9513,7 @@ function stripClientBuiltinImports(imports) {
 }
 
 // src/reactivity-checker.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var REACTIVE_BRAND = "__reactive";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
@@ -9402,7 +9531,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)) {
@@ -9426,7 +9555,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)) {
@@ -9438,7 +9567,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)) {
@@ -9451,7 +9580,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);
@@ -9480,7 +9609,7 @@ function containsReactiveExpression(node, checker) {
 }
 
 // src/free-refs.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 var _bindingMapCache = new WeakMap;
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
@@ -9518,8 +9647,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);
@@ -9548,20 +9677,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;
@@ -9570,7 +9699,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)) {
@@ -9588,7 +9717,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    ts11.forEachChild(n, visit2);
+    ts12.forEachChild(n, visit2);
   };
   visit2(node);
   return out;
@@ -9598,14 +9727,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) {
@@ -9617,7 +9746,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;
       }
     }
@@ -10022,85 +10151,6 @@ var toLocaleDatePlugin = {
 
 // src/jsx-to-ir.ts
 import { toHTMLAttrName, decodeEntities } from "@barefootjs/shared";
-
-// 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);
-  }
-}
-
-// src/jsx-to-ir.ts
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -10125,13 +10175,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;
@@ -10158,11 +10208,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;
@@ -10172,11 +10222,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;
@@ -10213,10 +10263,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)
@@ -10241,10 +10291,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)
@@ -10298,10 +10348,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) {
@@ -10312,7 +10362,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
         }
       }
     }
-    ts12.forEachChild(n, (child) => visit2(child, n));
+    ts13.forEachChild(n, (child) => visit2(child, n));
   }
   visit2(node);
   return acc;
@@ -10363,17 +10413,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) {
@@ -10388,21 +10438,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);
         }
       }
@@ -10414,11 +10464,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);
@@ -10451,7 +10501,7 @@ function makeBindingEnv(ctx) {
     localFunctions: a.localFunctions,
     imports: a.imports,
     ambientGlobals: a.ambientGlobals,
-    loopParams: boundNames,
+    loopValueBoundNames: boundNames,
     checker: a.checker
   };
   ctx._bindingEnv = env;
@@ -10575,7 +10625,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);
@@ -10631,22 +10681,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;
@@ -11003,7 +11053,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;
@@ -11011,7 +11061,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;
@@ -11055,7 +11105,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);
@@ -11070,10 +11120,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, " ");
@@ -11099,7 +11149,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);
@@ -11145,7 +11195,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;
@@ -11180,7 +11230,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;
   };
@@ -11222,7 +11272,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;
   };
@@ -11378,38 +11428,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",
@@ -11455,36 +11505,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);
@@ -11492,7 +11542,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);
@@ -11504,39 +11554,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",
@@ -11547,16 +11597,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);
@@ -11593,7 +11643,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")
@@ -11603,9 +11653,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;
@@ -11617,9 +11667,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")
@@ -11633,9 +11683,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;
@@ -11645,11 +11695,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;
@@ -11674,7 +11724,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 {
@@ -11684,7 +11734,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"
@@ -11711,11 +11761,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;
 }
@@ -11726,11 +11776,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;
 }
@@ -11786,13 +11836,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 */."
@@ -11812,7 +11862,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) {
@@ -11838,7 +11888,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;
@@ -11847,7 +11897,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;
@@ -11860,17 +11910,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,
@@ -11881,7 +11931,7 @@ function extractLoopParamBindings(pattern) {
         }
         const path = `${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, segments: nextSegments });
         } else {
           walk(el.name, path, nextSegments);
@@ -11897,7 +11947,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,
@@ -11909,17 +11959,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;
@@ -11929,14 +11979,14 @@ function extractLoopParamBindings(pattern) {
       collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path = 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, segments: nextSegments });
       } else {
         walk(el.name, path, nextSegments);
       }
     }
   };
-  if (ts12.isArrayBindingPattern(pattern) || ts12.isObjectBindingPattern(pattern)) {
+  if (ts13.isArrayBindingPattern(pattern) || ts13.isObjectBindingPattern(pattern)) {
     walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
@@ -11946,7 +11996,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;
     }
   }
@@ -11991,7 +12041,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);
@@ -12003,13 +12053,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;
 }
@@ -12018,26 +12068,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";
   }
@@ -12063,81 +12113,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;
   };
@@ -12150,19 +12200,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;
@@ -12171,11 +12221,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;
@@ -12355,7 +12405,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);
@@ -12363,9 +12413,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 {
@@ -12396,10 +12446,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))
@@ -12409,33 +12459,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);
@@ -12453,7 +12503,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;
@@ -12474,10 +12524,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];
@@ -12559,7 +12609,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)
@@ -12577,7 +12627,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.",
@@ -12588,7 +12638,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;
@@ -12642,6 +12692,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 {
@@ -12685,12 +12738,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);
@@ -12699,7 +12752,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) => {
@@ -12715,7 +12768,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() });
@@ -12723,7 +12776,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);
@@ -12899,6 +12952,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;
@@ -12914,24 +12994,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 = [];
@@ -12946,21 +13048,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;
@@ -12993,11 +13097,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;
       }
@@ -13010,7 +13114,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);
@@ -13021,7 +13125,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);
@@ -13125,13 +13229,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;
@@ -13157,22 +13261,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({
@@ -13187,7 +13291,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) {
@@ -13214,55 +13318,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 });
       }
@@ -13275,11 +13379,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}`);
@@ -13292,7 +13396,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);
@@ -13318,7 +13422,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);
@@ -13327,13 +13431,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;
@@ -13341,17 +13445,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;
@@ -13398,17 +13502,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;
@@ -13422,13 +13526,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 = [];
@@ -13466,14 +13570,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());
@@ -13493,9 +13597,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)
@@ -13503,9 +13607,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)
@@ -13522,23 +13626,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")
@@ -13595,7 +13699,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;
@@ -13607,15 +13711,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;
 }
@@ -13635,10 +13739,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;
@@ -13646,19 +13750,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);
@@ -13685,7 +13789,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) {
@@ -13709,7 +13813,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) {
@@ -13740,12 +13844,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;
     }
   }
@@ -13767,7 +13871,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;
@@ -13849,7 +13953,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;
       }
     }
@@ -13940,7 +14044,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);
@@ -14007,7 +14111,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({
@@ -14055,18 +14159,22 @@ function buildIfStatementChain(analyzer, ctx, opts) {
 }
 
 // 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 };
@@ -14102,6 +14210,16 @@ function getControlledPropName(signal, propsParams, propsObjectName = null) {
 }
 
 // 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" };
@@ -14130,12 +14248,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;
     }
   }
@@ -14325,8 +14443,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 }) => {
@@ -14335,7 +14454,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;
@@ -14359,8 +14478,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) {
@@ -14373,7 +14493,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)
@@ -14678,13 +14798,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));
           }
         }
@@ -14711,7 +14831,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({
@@ -14907,7 +15027,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));
@@ -15162,7 +15282,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,
@@ -15248,19 +15368,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) {
@@ -15280,8 +15401,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");
@@ -15291,23 +15413,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)
   };
 }
 
@@ -15669,7 +15792,7 @@ function graphDeclarationReferences(graph, kind, name) {
 }
 
 // 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;
@@ -15683,7 +15806,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);
   }
 }
@@ -15693,15 +15816,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))
@@ -15754,56 +15877,56 @@ function propHasPropertyAccess(u) {
 }
 
 // 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;
   }
@@ -15812,10 +15935,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;
@@ -15879,7 +16002,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);
     }
   }
@@ -15983,7 +16106,7 @@ function collectComponentNames(node) {
 }
 
 // src/relocate.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // src/lowering-registry.ts
 var plugins = [];
@@ -16029,19 +16152,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;
@@ -16145,11 +16268,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;
@@ -16158,11 +16281,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;
@@ -16210,12 +16333,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;
   }
@@ -16232,8 +16355,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) {
@@ -16246,7 +16369,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16256,13 +16379,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;
@@ -16272,25 +16395,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;
@@ -16298,7 +16421,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, []);
   }
@@ -17593,23 +17716,23 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 }
 
 // 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;
@@ -17622,10 +17745,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);
@@ -18589,7 +18712,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 }
       });
     }
   }
@@ -18992,7 +19116,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,
@@ -19070,7 +19194,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // 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 }
@@ -19090,12 +19214,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) {
@@ -19124,12 +19248,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);
   }
@@ -19139,56 +19263,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;
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -19718,7 +19842,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -19822,20 +19946,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)
@@ -19871,20 +19995,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)
@@ -20199,7 +20323,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) {
@@ -20301,9 +20425,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);
@@ -21198,7 +21323,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})`);
   }
@@ -21887,20 +22012,20 @@ var PHASES = [
 ];
 
 // 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)
@@ -21916,17 +22041,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;
 }
@@ -22578,7 +22703,7 @@ function walkIR2(node, visitor) {
 }
 
 // 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) {
@@ -22600,8 +22725,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 };
   }
@@ -22623,22 +22748,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;
@@ -22675,7 +22800,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 };
   }
@@ -22698,11 +22823,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);
 }
@@ -22711,24 +22836,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;
@@ -22738,13 +22863,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);
     });
   }
@@ -22771,48 +22896,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;
       }
@@ -22821,43 +22946,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;
@@ -22880,29 +23005,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;
@@ -22910,7 +23035,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);
@@ -22920,7 +23045,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function deriveStashFromDefaults(defaults, props) {
   const extra = {};
   for (const [name, d] of Object.entries(defaults)) {
@@ -23016,11 +23141,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);
 }
@@ -23041,23 +23166,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;
       }
@@ -23068,45 +23193,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)
@@ -23115,29 +23240,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;
@@ -23149,10 +23274,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)
@@ -23161,7 +23286,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;
@@ -23175,17 +23300,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 sep2 = ",";
@@ -23201,27 +23326,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;
@@ -23234,30 +23359,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;
@@ -23269,13 +23394,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts21.isNoSubstitutionTemplateLiteral(node))
+  if (ts22.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -23307,47 +23432,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr))
+  if (!expr || !ts23.isCallExpression(expr))
     return null;
-  if (!ts22.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts23.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts22.isIdentifier(arg) ? arg.text : null;
+  return ts23.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr))
+  if (!expr || !ts23.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
+  if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts22.isNumericLiteral(arg))
+  if (ts23.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts22.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts23.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts22.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts23.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr))
+  if (!expr || !ts23.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts22.isObjectLiteralExpression(expr.arguments[0]);
+  return ts23.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts22.createSourceFile("__ctx.ts", `(${source})`, ts22.ScriptTarget.Latest, false);
+  const sf = ts23.createSourceFile("__ctx.ts", `(${source})`, ts23.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isExpressionStatement(stmt))
+  if (!stmt || !ts23.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts22.isParenthesizedExpression(e))
+  while (ts23.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -23372,25 +23497,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts22.createSourceFile("__aug.ts", `(${s})`, ts22.ScriptTarget.Latest, false);
+    const sf = ts23.createSourceFile("__aug.ts", `(${s})`, ts23.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts22.isBinaryExpression(n) && (n.operatorToken.kind === ts22.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts22.SyntaxKind.BarBarToken)) {
+      if (ts23.isBinaryExpression(n) && (n.operatorToken.kind === ts23.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts23.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts22.isParenthesizedExpression(left))
+        while (ts23.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts22.isPropertyAccessExpression(left) && ts22.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts23.isPropertyAccessExpression(left) && ts23.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts22.isParenthesizedExpression(right))
+          while (ts23.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts22.isPrefixUnaryExpression(right))
+          if (ts23.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts22.isNumericLiteral(right) ? "number" : right.kind === ts22.SyntaxKind.TrueKeyword || right.kind === ts22.SyntaxKind.FalseKeyword ? "boolean" : ts22.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts23.isNumericLiteral(right) ? "number" : right.kind === ts23.SyntaxKind.TrueKeyword || right.kind === ts23.SyntaxKind.FalseKeyword ? "boolean" : ts23.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts22.forEachChild(n, visit3);
+      ts23.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -23501,33 +23626,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 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)
@@ -23554,34 +23679,36 @@ function collectModuleStringConsts(constants) {
   }
   return map;
 }
-function lookupStaticRecordLiteral(objectName, key, constants) {
+function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
+  if (isShadowed(objectName))
+    return null;
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
+  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt))
+  if (!ts23.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed))
+  while (ts23.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed))
+  if (!ts23.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop))
+    if (!ts23.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts22.isIdentifier(name) || ts22.isStringLiteral(name) || ts22.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts23.isIdentifier(name) || ts23.isStringLiteral(name) || ts23.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts22.isParenthesizedExpression(v))
+    while (ts23.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts22.isNumericLiteral(v))
+    if (ts23.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -23589,28 +23716,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 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;
@@ -23619,7 +23746,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
+    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -23627,11 +23754,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts22.isElementAccessExpression(val))
+  if (!ts23.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts22.isIdentifier(obj) || !ts22.isIdentifier(arg))
+  if (!ts23.isIdentifier(obj) || !ts23.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -23647,35 +23774,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
+  const sf = ts23.createSourceFile("__rec.ts", `(${constInfo.value})`, ts23.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt))
+  if (!ts23.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed))
+  while (ts23.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed))
+  if (!ts23.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop))
+    if (!ts23.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts22.isIdentifier(prop.name)) {
+    if (ts23.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts22.isStringLiteral(prop.name) || ts22.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts23.isStringLiteral(prop.name) || ts23.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts22.isParenthesizedExpression(v))
+    while (ts23.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts22.isNumericLiteral(v)) {
+    if (ts23.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -24018,13 +24145,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);
           }
         }
@@ -24083,7 +24210,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))
@@ -24320,6 +24447,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",
@@ -24328,6 +24461,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,
@@ -24518,7 +24652,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -24539,10 +24673,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,
@@ -24552,7 +24686,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts24.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts25.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -24607,7 +24741,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)
@@ -24637,9 +24771,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[]) => {}`);
         }
       }
     }
@@ -24835,6 +24970,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // src/adapters/template-imports.ts
+import ts26 from "typescript";
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -24881,6 +25017,44 @@ function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
 function specKey(s) {
   return `${s.isDefault ? "d" : ""}${s.isNamespace ? "n" : ""}:${s.name}:${s.alias ?? ""}`;
 }
+function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
+  if (!sourceText.includes("import"))
+    return sourceText;
+  const sf = ts26.createSourceFile("bf-template-fragment.tsx", sourceText, ts26.ScriptTarget.Latest, false, ts26.ScriptKind.TSX);
+  const edits = [];
+  const visit3 = (node) => {
+    if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts26.isStringLiteralLike(node.arguments[0])) {
+      collect(node.arguments[0]);
+    }
+    if (ts26.isImportTypeNode(node) && ts26.isLiteralTypeNode(node.argument)) {
+      const literal = node.argument.literal;
+      if (ts26.isStringLiteralLike(literal))
+        collect(literal);
+    }
+    ts26.forEachChild(node, visit3);
+  };
+  const collect = (literal) => {
+    const specifier = literal.text;
+    if (!specifier.startsWith("."))
+      return;
+    const next = rewriteRelative(specifier);
+    if (next === specifier)
+      return;
+    edits.push({
+      start: literal.getStart(sf),
+      end: literal.getEnd(),
+      text: `'${next}'`
+    });
+  };
+  ts26.forEachChild(sf, visit3);
+  if (edits.length === 0)
+    return sourceText;
+  let out = sourceText;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  }
+  return out;
+}
 
 // src/adapters/test-adapter.ts
 class TestAdapter extends JsxAdapter {
@@ -24973,7 +25147,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 {
@@ -25667,7 +25842,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -25724,10 +25899,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts25.createSourceFile("combine.js", content, ts25.ScriptTarget.Latest, false, ts25.ScriptKind.JS);
+  const sourceFile = ts27.createSourceFile("combine.js", content, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts25.isImportDeclaration(stmt))
+    if (!ts27.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -25737,8 +25912,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts25.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts25.isNamedImports(bindings)) {
+    const specifier = ts27.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts27.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -25905,7 +26080,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -25984,7 +26159,7 @@ function buildGraphFromIR(ir) {
     return propsObjectName ? exprReadsPropMember(expr, propsObjectName) : false;
   };
   const domBindings = [];
-  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, undefined, new Set, exprReadsProp);
+  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, undefined, BindingScope.EMPTY, exprReadsProp);
   const signalConsumers = new Map;
   for (const s of meta.signals)
     signalConsumers.set(s.getter, []);
@@ -27010,15 +27185,22 @@ function inferWrapReasonForAttrLike(hasStringReactive, hasPropsRef, flags) {
   const decision = decideWrapFromAstFlags(flags);
   return decision.wrap ? decision.reason : undefined;
 }
-function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, loopParams = new Set, readsProp = () => false) {
-  const exprReadsLoopParam = (n) => loopParams.size > 0 && (n.origin?.freeRefs?.some((r) => loopParams.has(r.name)) ?? false);
-  const attrReadsLoopParam = (free) => loopParams.size > 0 && free !== undefined && [...loopParams].some((p) => free.has(p));
+function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, scope = BindingScope.EMPTY, readsProp = () => false) {
+  const boundNames = scope.valueBoundNames();
+  const setSomeIn = (names, other) => {
+    for (const n of names)
+      if (other.has(n))
+        return true;
+    return false;
+  };
+  const exprReadsLoopParam = (n) => boundNames.size > 0 && (n.origin?.freeRefs?.some((r) => boundNames.has(r.name)) ?? false);
+  const attrReadsLoopParam = (free) => boundNames.size > 0 && free !== undefined && setSomeIn(boundNames, free);
   switch (node.type) {
     case "element": {
       for (const attr of node.attrs) {
         if (attr.value.kind !== "expression" && attr.value.kind !== "template" && attr.value.kind !== "spread")
           continue;
-        if (attr.name === "key" && loopParams.size > 0)
+        if (attr.name === "key" && boundNames.size > 0)
           continue;
         const expr = attrValueToString2(attr.value);
         if (!expr)
@@ -27055,7 +27237,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
         });
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag, scope, readsProp);
       }
       break;
     }
@@ -27082,7 +27264,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
     }
     case "conditional": {
       const decision = decideWrapFromAstFlags(node);
-      const loopReactive = loopParams.size > 0 && (node.origin?.freeRefs?.some((r) => loopParams.has(r.name)) ?? false);
+      const loopReactive = boundNames.size > 0 && (node.origin?.freeRefs?.some((r) => boundNames.has(r.name)) ?? false);
       if ((decision.wrap || loopReactive) && node.slotId) {
         const deps = extractReactiveDeps(node.condition, signalGetters, memoNames);
         bindings.push({
@@ -27098,14 +27280,14 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
           jsxPreview: `{${truncateExpr(node.condition)} ? ... : ...}`
         });
       }
-      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
-      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
+      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       break;
     }
     case "loop": {
       if (node.slotId) {
         const deps = extractReactiveDeps(node.array, signalGetters, memoNames);
-        const loopReactive = loopParams.size > 0 && node.arrayFreeIdentifiers !== undefined && [...loopParams].some((p) => node.arrayFreeIdentifiers.has(p));
+        const loopReactive = boundNames.size > 0 && node.arrayFreeIdentifiers !== undefined && setSomeIn(boundNames, node.arrayFreeIdentifiers);
         const isReactive = deps.length > 0 || node.callsReactiveGetters === true || loopReactive;
         const isFallback = !isReactive && node.hasFunctionCalls === true;
         if (isReactive || isFallback) {
@@ -27124,13 +27306,9 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
           });
         }
       }
-      const childLoopParams = new Set(loopParams);
-      for (const p of extractLoopParamNames(node.param, node))
-        childLoopParams.add(p);
-      if (node.index)
-        childLoopParams.add(node.index);
+      const childScope = scope.enterLoopRow(node);
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, childLoopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, childScope, readsProp);
       }
       break;
     }
@@ -27163,21 +27341,21 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
         }
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
     case "fragment":
     case "provider": {
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
     case "if-statement": {
-      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       if (node.alternate) {
-        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
@@ -27190,7 +27368,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts26.createSourceFile("__attr.tsx", `(${expr})`, ts26.ScriptTarget.Latest, true, ts26.ScriptKind.TSX);
+    sf = ts28.createSourceFile("__attr.tsx", `(${expr})`, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -27198,11 +27376,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts26.isPropertyAccessExpression(n) && ts26.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts28.isPropertyAccessExpression(n) && ts28.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts26.forEachChild(n, visit3);
+    ts28.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -27232,12 +27410,12 @@ function attrValueToString2(value) {
 function extractReactiveDeps(expr, signalGetters, memoNames) {
   const deps = [];
   for (const getter of signalGetters) {
-    if (new RegExp(`\\b${getter}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(getter).test(expr)) {
       deps.push(getter);
     }
   }
   for (const memo of memoNames) {
-    if (new RegExp(`\\b${memo}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(memo).test(expr)) {
       deps.push(memo);
     }
   }
@@ -27250,7 +27428,7 @@ function extractSetterRefs(expr, signalGetters) {
     refs.push(match[1]);
   }
   for (const getter of signalGetters) {
-    if (new RegExp(`\\b${getter}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(getter).test(expr)) {
       refs.push(getter);
     }
   }
@@ -27272,7 +27450,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts27 from "typescript";
+import ts29 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -27542,15 +27720,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts27.createSourceFile(filePath, source, ts27.ScriptTarget.Latest, true, ts27.ScriptKind.TSX);
+  const sf = ts29.createSourceFile(filePath, source, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts27.isCallExpression(node) && ts27.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts27.forEachChild(node, visit3);
+    ts29.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -27858,13 +28036,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts27.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts27.ScriptTarget.Latest, true);
+    sf = ts29.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts29.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts27.isCallExpression(node) && ts27.isIdentifier(node.expression)) {
+    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -27873,7 +28051,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts27.forEachChild(node, visit3);
+    ts29.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -28519,6 +28697,7 @@ export {
   serializeParsedExpr,
   searchParamsLocalNames,
   rewriteImportsForTemplate,
+  rewriteDynamicImportsInSource,
   resolveStaticLoopSource,
   resolveSetters,
   resolveDangerousInnerHtml,