@barefootjs/cli 0.31.3 → 0.31.5

package/dist/index.js

@@ -2384,6 +2384,30 @@ var init_template_parts = __esm({
   }
 });
 
+// ../jsx/src/identifier-pattern.ts
+function withUnicodeFlag(flags) {
+  return flags.includes("u") ? flags : `${flags}u`;
+}
+function escapeIdentifierForRegex(name2) {
+  return name2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function identifierPattern(name2, flags = "") {
+  const esc = escapeIdentifierForRegex(name2);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}${ID_BOUNDARY_AFTER}`, withUnicodeFlag(flags));
+}
+function identifierCallPattern(name2, flags = "") {
+  const esc = escapeIdentifierForRegex(name2);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}\\s*\\(`, withUnicodeFlag(flags));
+}
+var ID_BOUNDARY_BEFORE, ID_BOUNDARY_AFTER;
+var init_identifier_pattern = __esm({
+  "../jsx/src/identifier-pattern.ts"() {
+    "use strict";
+    ID_BOUNDARY_BEFORE = "(?<![\\p{ID_Continue}$])";
+    ID_BOUNDARY_AFTER = "(?![\\p{ID_Continue}$])";
+  }
+});
+
 // ../jsx/src/scanner/js-scanner.ts
 import ts2 from "typescript";
 function* iterateJsTokens(text, start2 = 0, end2 = text.length) {
@@ -2914,9 +2938,6 @@ function inferDefaultValue(type2) {
   if (type2.kind === "object") return "{}";
   return "undefined";
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function freeIdsFromRefs(refs) {
   const out = /* @__PURE__ */ new Set();
   if (!refs) return out;
@@ -3031,15 +3052,15 @@ 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 = /* @__PURE__ */ 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,
@@ -3094,6 +3115,7 @@ var init_utils = __esm({
     "use strict";
     init_loop_chain();
     init_template_parts();
+    init_identifier_pattern();
     init_js_scanner();
     init_src();
     PROPS_PARAM = "_p";
@@ -3341,7 +3363,7 @@ var init_walker = __esm({
 
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 import ts4 from "typescript";
-function csrSubstitute(value2, env) {
+function csrSubstitute(value2, env, enclosingScope) {
   if (!value2 || value2.trim().length === 0) {
     return { rewritten: value2, freeIdentifiers: /* @__PURE__ */ new Set() };
   }
@@ -3349,14 +3371,14 @@ function csrSubstitute(value2, env) {
   let current = value2;
   let lastFreeIdentifiers = /* @__PURE__ */ 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;
     current = step.rewritten;
   }
   return { rewritten: current, freeIdentifiers: lastFreeIdentifiers };
 }
-function csrSubstituteOnce(value2, env) {
+function csrSubstituteOnce(value2, env, enclosingScope) {
   if (!value2 || value2.trim().length === 0) {
     return { rewritten: value2, freeIdentifiers: /* @__PURE__ */ new Set() };
   }
@@ -3380,7 +3402,7 @@ function csrSubstituteOnce(value2, env) {
     for (let i = boundStack.length - 1; i >= 0; i--) {
       if (boundStack[i].has(name2)) return true;
     }
-    return false;
+    return enclosingScope?.isBound(name2) ?? false;
   };
   const recordSubstitution = (start2, end2, sub2) => {
     splices.push({ start: start2 - OFFSET, end: end2 - OFFSET, text: `(${sub2.replacement})` });
@@ -3584,6 +3606,176 @@ var init_child_scope = __esm({
   }
 });
 
+// ../jsx/src/scope/binding-scope.ts
+var BindingScope;
+var init_binding_scope = __esm({
+  "../jsx/src/scope/binding-scope.ts"() {
+    "use strict";
+    BindingScope = class _BindingScope {
+      constructor(frames2) {
+        this.frames = frames2;
+      }
+      static EMPTY = new _BindingScope([]);
+      /**
+       * Child scope with a new `'loop-row'` frame for one loop's per-item
+       * bindings. Parent (`this`) is not mutated; the returned scope is a
+       * NEW object with `frames = [newFrame, ...this.frames]`.
+       *
+       * Binding semantics mirror `jsx-to-ir.ts`'s `ctx.loopParams` add site
+       * EXACTLY (verified against lines ~4320-4345 and the matching delete
+       * site ~4695-4710 of `packages/jsx/src/jsx-to-ir.ts`):
+       *
+       *   - When `loop.paramBindings` is non-empty (a destructured callback
+       *     param, e.g. `.map(({ id, name }) => ...)`), each `paramBindings[i].name`
+       *     is bound with source `'destructure'` and the raw `param` text
+       *     (which for a destructured callback holds the ORIGINAL pattern
+       *     source, e.g. `"{ id, name }"`, not a usable identifier) is NOT
+       *     bound. This matches `jsx-to-ir.ts`:
+       *       `if (paramBindings) { for (const b of paramBindings) ctx.loopParams.add(b.name) }`
+       *     — the `else` branch (`ctx.loopParams.add(param)`) is skipped
+       *     entirely when `paramBindings` is present.
+       *   - Otherwise (a plain identifier param, e.g. `.map(item => ...)`),
+       *     `param` itself is bound with source `'item'`.
+       *   - `index` (the second callback param, e.g. `.map((item, i) => ...)`)
+       *     is bound with source `'index'` when non-null/non-undefined.
+       *   - Every name in `preamble.declaredNames` (a `.map()` callback's
+       *     pre-return `const`/`let`/`function` locals, #2447) is bound with
+       *     source `'preamble'`.
+       *
+       *   NOTE on a sibling mechanism this method does NOT mirror:
+       *   `adapters/loop-bound-names.ts`'s `collectLoopBoundNames` adds BOTH
+       *   `node.param` AND every `paramBindings[i].name` unconditionally
+       *   (never skipping `param` in the destructured case) — a deliberately
+       *   coarser, over-inclusive collection used only to subtract names from
+       *   a flat string-typing Set (safe to over-exclude there). This method
+       *   follows the precise `jsx-to-ir.ts` `ctx.loopParams` semantics, since
+       *   that is the mechanism actually doing scope-shadowed name RESOLUTION
+       *   (the behavior `BindingScope` replaces), not coarse exclusion.
+       */
+      enterLoopRow(loop) {
+        const bindings = /* @__PURE__ */ 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 name2 of loop.preamble?.declaredNames ?? []) bindings.set(name2, { source: "preamble" });
+        const frame = { kind: "loop-row", bindings };
+        return new _BindingScope([frame, ...this.frames]);
+      }
+      /**
+       * Child scope with a new `'callback'` frame binding `params` (a filter
+       * predicate's `x`, a sort comparator's `(a, b)`, or a nested arrow's
+       * parameter list) with source `'param'`. Parent is not mutated.
+       */
+      enterCallback(params) {
+        const bindings = /* @__PURE__ */ new Map();
+        for (const name2 of params) bindings.set(name2, { source: "param" });
+        const frame = { kind: "callback", bindings };
+        return new _BindingScope([frame, ...this.frames]);
+      }
+      /** Innermost-first membership check across every frame in the stack. */
+      isBound(name2) {
+        for (const frame of this.frames) {
+          if (frame.bindings.has(name2)) return true;
+        }
+        return false;
+      }
+      /**
+       * Resolves `name` against the frame stack innermost-first. `depth 0`
+       * means the innermost (most recently entered) frame; `null` when `name`
+       * is not bound in any frame.
+       */
+      lookup(name2) {
+        for (let depth = 0; depth < this.frames.length; depth++) {
+          const frame = this.frames[depth];
+          const binding = frame.bindings.get(name2);
+          if (binding) return { depth, frame, binding };
+        }
+        return null;
+      }
+      /**
+       * Union of every frame's bound names (every `ScopeBindingSource`), for
+       * migration interop with legacy `Set<string>`-shaped consumers (e.g.
+       * `collectLoopBoundNames`'s return type) as later stages migrate them
+       * onto `BindingScope`.
+       *
+       * This is the SHADOW-GUARD query — see {@link valueBoundNames} for the
+       * other consumer class and why the two must not be conflated.
+       */
+      boundNames() {
+        if (this.boundNamesCache) return this.boundNamesCache;
+        const names = /* @__PURE__ */ new Set();
+        for (const frame of this.frames) {
+          for (const name2 of frame.bindings.keys()) names.add(name2);
+        }
+        this.boundNamesCache = names;
+        return names;
+      }
+      // Both name queries are hot (shadow guards, slot/reactivity classifiers,
+      // binding-env memo keying) and the scope is immutable, so each computes
+      // once per instance. Callers receive the cached set as ReadonlySet —
+      // never mutate it.
+      boundNamesCache;
+      valueBoundNamesCache;
+      /**
+       * Union of names bound via `'item'`/`'index'`/`'destructure'` sources
+       * only — the loop row's own per-item identity — excluding `'preamble'`
+       * (a `.map()` callback's pre-return `const`/`let`/`function` locals,
+       * #2447) and `'param'` (an `enterCallback` frame's filter/sort/nested-
+       * arrow parameters).
+       *
+       * `BindingScope` has exactly two consumer classes, and conflating them
+       * is the #2482 Stage 1a Commit 2 regression this split exists to
+       * prevent (a `ctx.scope`-wide preamble merge flipped `tag-cloud` and
+       * `preamble-cells` conformance fixtures before this method existed):
+       *
+       *   - SHADOW GUARDS (`tryResolveTemplateSpanFromConst`,
+       *     `tryResolveIdentifierAsTemplateLiteral`, `rewriteBarePropRefs`
+       *     in `jsx-to-ir.ts`) ask "is this name resolved to SOMETHING in
+       *     this scope, so an outer const/prop of the same name must not be
+       *     substituted here at this transform position" — every source
+       *     qualifies, including a preamble local shadowing a module const.
+       *     These call `isBound` / `boundNames()`.
+       *   - REACTIVITY / SLOT-ID CLASSIFIERS (`referencesLoopParam`,
+       *     `hasReactiveAttributes`, and the `BindingEnvironment.loopValueBoundNames`
+       *     feed built from `makeBindingEnv`, all in `jsx-to-ir.ts`) ask
+       *     "does this expression read a value that changes per row and so
+       *     needs its own patchable slot" — a preamble local already gets
+       *     ITS OWN dedicated slot/region-patch machinery
+       *     (`preambleRegions` / `markPreambleAttrSlots`, #2447), so folding
+       *     it into this classification double-counts it. Worse: widening a
+       *     text child's `reactive` flag this way is read by
+       *     `hasDynamicContent` to decide whether the loop ROW's own root
+       *     element needs a slot — an unrelated, narrower decision that must
+       *     not move just because a preamble local is now scope-visible.
+       *     These call `valueBoundNames()`.
+       */
+      valueBoundNames() {
+        if (this.valueBoundNamesCache) return this.valueBoundNamesCache;
+        const names = /* @__PURE__ */ new Set();
+        for (const frame of this.frames) {
+          for (const [name2, binding] of frame.bindings) {
+            if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+              names.add(name2);
+            }
+          }
+        }
+        this.valueBoundNamesCache = names;
+        return names;
+      }
+      /**
+       * Drop-in for `resolveStaticLoopSource`'s `opts.isNameShadowed`
+       * (`packages/jsx/src/static-literal.ts:112-128`).
+       */
+      asShadowPredicate() {
+        return (name2) => this.isBound(name2);
+      }
+    };
+  }
+});
+
 // ../jsx/src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -4705,7 +4897,7 @@ function generateCsrTemplateWithOpts(node, opts) {
   const transformExpr = (expr, templateExpr) => {
     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;
     }
@@ -4838,13 +5030,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(([name2]) => !boundHere.has(name2)))
@@ -4853,7 +5040,7 @@ function generateCsrTemplateWithOpts(node, opts) {
         ...opts,
         loopDepth: loopDepth + 1,
         inHoistedChildren: false,
-        loopBoundNames: boundHere,
+        scope: childScope,
         csrEnv: childEnv
       });
       let childTemplate = node.children.map(recurseInLoopBody).join("");
@@ -4923,6 +5110,7 @@ var init_html_template = __esm({
     init_src();
     init_loop_chain();
     init_child_scope();
+    init_binding_scope();
     VOID_ELEMENTS = /* @__PURE__ */ new Set([
       "area",
       "base",
@@ -9216,6 +9404,7 @@ var init_types = __esm({
 });
 
 // ../jsx/src/module-exports.ts
+import ts10 from "typescript";
 function generateModuleExports(ir, extraInlineExported = /* @__PURE__ */ new Set(), rewriteRelativeImport, options2) {
   const lines = [];
   for (const constant of options2?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -9286,7 +9475,7 @@ function findReachableNames(primaryRefs, declarations) {
   const reachable = /* @__PURE__ */ new Set();
   const queue = [];
   for (const name2 of allNames) {
-    if (new RegExp(`\\b${name2}\\b`).test(primaryRefs)) {
+    if (identifierPattern(name2).test(primaryRefs)) {
       reachable.add(name2);
       queue.push(name2);
     }
@@ -9295,7 +9484,7 @@ function findReachableNames(primaryRefs, declarations) {
     const current = queue.shift();
     const body2 = bodyMap.get(current) || "";
     for (const name2 of allNames) {
-      if (!reachable.has(name2) && new RegExp(`\\b${name2}\\b`).test(body2)) {
+      if (!reachable.has(name2) && identifierPattern(name2).test(body2)) {
         reachable.add(name2);
         queue.push(name2);
       }
@@ -9303,6 +9492,52 @@ function findReachableNames(primaryRefs, declarations) {
   }
   return reachable;
 }
+function findAssignedNames(bodyText, candidates) {
+  const assigned = /* @__PURE__ */ new Set();
+  if (candidates.size === 0) return assigned;
+  const sf = ts10.createSourceFile(
+    "bf-assignment-scan.tsx",
+    bodyText,
+    ts10.ScriptTarget.Latest,
+    /* setParentNodes */
+    false,
+    ts10.ScriptKind.TSX
+  );
+  const record = (target2) => {
+    if (ts10.isIdentifier(target2) && candidates.has(target2.text)) {
+      assigned.add(target2.text);
+    }
+  };
+  const visit3 = (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, visit3);
+  };
+  ts10.forEachChild(sf, visit3);
+  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((name2) => mutableNames.has(name2))
+    );
+    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 += "\n" + added.join("\n");
+    reachable = findReachableNames(seedText, declarations);
+  }
+  return reachable;
+}
+function isAssignmentOperator(kind2) {
+  return kind2 >= ts10.SyntaxKind.FirstAssignment && kind2 <= ts10.SyntaxKind.LastAssignment;
+}
 function extractFunctionParams(value2) {
   const arrowMatch = value2.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
   if (arrowMatch) {
@@ -9321,6 +9556,7 @@ function extractFunctionParams(value2) {
 var init_module_exports = __esm({
   "../jsx/src/module-exports.ts"() {
     "use strict";
+    init_identifier_pattern();
   }
 });
 
@@ -9354,7 +9590,7 @@ var init_builtins = __esm({
 });
 
 // ../jsx/src/reactivity-checker.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
   return checker.getTypeAtLocation(node);
@@ -9370,7 +9606,7 @@ function safeGetText(node) {
   }
 }
 function analyze(node, checker) {
-  if (ts10.isPropertyAccessExpression(node)) {
+  if (ts11.isPropertyAccessExpression(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -9395,7 +9631,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (ts10.isIdentifier(node)) {
+  if (ts11.isIdentifier(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -9408,7 +9644,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (ts10.isCallExpression(node)) {
+  if (ts11.isCallExpression(node)) {
     try {
       const calleeType = queryType(checker, node.expression);
       if (isReactiveType(calleeType)) {
@@ -9422,7 +9658,7 @@ function analyze(node, checker) {
   }
   let foundChild;
   let foundChildText = "";
-  ts10.forEachChild(node, (child) => {
+  ts11.forEachChild(node, (child) => {
     if (foundChild?.isReactive) return;
     const result2 = analyze(child, checker);
     if (result2.isReactive) {
@@ -9459,7 +9695,7 @@ var init_reactivity_checker = __esm({
 });
 
 // ../jsx/src/free-refs.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
   if (cached) return cached;
@@ -9493,8 +9729,8 @@ function buildBindingMap(env) {
   for (const m of env.memos) {
     map.set(m.name, "memo-getter");
   }
-  if (env.loopParams) {
-    for (const name2 of env.loopParams) map.set(name2, "render-item");
+  if (env.loopValueBoundNames) {
+    for (const name2 of env.loopValueBoundNames) map.set(name2, "render-item");
   }
   _bindingMapCache.set(env, map);
   return map;
@@ -9523,17 +9759,17 @@ function defaultBindingScope(kind2) {
 function collectIdentifiers2(node) {
   const out = [];
   const visit3 = (n, parent2) => {
-    if (ts11.isIdentifier(n)) {
-      if (parent2 && ts11.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts11.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && (ts11.isJsxOpeningElement(parent2) || ts11.isJsxClosingElement(parent2) || ts11.isJsxSelfClosingElement(parent2)) && parent2.tagName === n) {
+    if (ts12.isIdentifier(n)) {
+      if (parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts12.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && (ts12.isJsxOpeningElement(parent2) || ts12.isJsxClosingElement(parent2) || ts12.isJsxSelfClosingElement(parent2)) && parent2.tagName === n) {
         return;
       }
-      if (parent2 && ts11.isJsxAttribute(parent2) && parent2.name === n) return;
+      if (parent2 && ts12.isJsxAttribute(parent2) && parent2.name === n) return;
       out.push(n);
       return;
     }
-    ts11.forEachChild(n, (child) => visit3(child, n));
+    ts12.forEachChild(n, (child) => visit3(child, n));
   };
   visit3(node);
   return out;
@@ -9542,7 +9778,7 @@ function collectReactiveBrandRefs(node, checker) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const visit3 = (n) => {
-    if (ts11.isPropertyAccessExpression(n)) {
+    if (ts12.isPropertyAccessExpression(n)) {
       try {
         const type2 = checker.getTypeAtLocation(n);
         if (isReactiveType(type2)) {
@@ -9560,7 +9796,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    ts11.forEachChild(n, visit3);
+    ts12.forEachChild(n, visit3);
   };
   visit3(node);
   return out;
@@ -9568,17 +9804,17 @@ function collectReactiveBrandRefs(node, checker) {
 function resolveConstantInitializerRefs(c, env, visited) {
   if (c.value === void 0) return [];
   if (c.containsArrow) return [];
-  const sf = ts11.createSourceFile(
+  const sf = ts12.createSourceFile(
     "__const_init.ts",
     `const __probe = (${c.value});`,
-    ts11.ScriptTarget.Latest,
+    ts12.ScriptTarget.Latest,
     true
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts11.isVariableStatement(stmt)) return [];
+  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) {
@@ -9590,7 +9826,7 @@ function resolveFreeRefsInternal(node, env, visited) {
     const name2 = ident.text;
     if (env.propsObjectName === name2) {
       const parent2 = ident.parent;
-      if (parent2 && ts11.isPropertyAccessExpression(parent2) && parent2.expression === ident && parent2.name.text === "children") {
+      if (parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.expression === ident && parent2.name.text === "children") {
         continue;
       }
     }
@@ -9984,178 +10220,8 @@ var init_to_locale_date_lowering = __esm({
   }
 });
 
-// ../jsx/src/scope/binding-scope.ts
-var BindingScope;
-var init_binding_scope = __esm({
-  "../jsx/src/scope/binding-scope.ts"() {
-    "use strict";
-    BindingScope = class _BindingScope {
-      constructor(frames2) {
-        this.frames = frames2;
-      }
-      static EMPTY = new _BindingScope([]);
-      /**
-       * Child scope with a new `'loop-row'` frame for one loop's per-item
-       * bindings. Parent (`this`) is not mutated; the returned scope is a
-       * NEW object with `frames = [newFrame, ...this.frames]`.
-       *
-       * Binding semantics mirror `jsx-to-ir.ts`'s `ctx.loopParams` add site
-       * EXACTLY (verified against lines ~4320-4345 and the matching delete
-       * site ~4695-4710 of `packages/jsx/src/jsx-to-ir.ts`):
-       *
-       *   - When `loop.paramBindings` is non-empty (a destructured callback
-       *     param, e.g. `.map(({ id, name }) => ...)`), each `paramBindings[i].name`
-       *     is bound with source `'destructure'` and the raw `param` text
-       *     (which for a destructured callback holds the ORIGINAL pattern
-       *     source, e.g. `"{ id, name }"`, not a usable identifier) is NOT
-       *     bound. This matches `jsx-to-ir.ts`:
-       *       `if (paramBindings) { for (const b of paramBindings) ctx.loopParams.add(b.name) }`
-       *     — the `else` branch (`ctx.loopParams.add(param)`) is skipped
-       *     entirely when `paramBindings` is present.
-       *   - Otherwise (a plain identifier param, e.g. `.map(item => ...)`),
-       *     `param` itself is bound with source `'item'`.
-       *   - `index` (the second callback param, e.g. `.map((item, i) => ...)`)
-       *     is bound with source `'index'` when non-null/non-undefined.
-       *   - Every name in `preamble.declaredNames` (a `.map()` callback's
-       *     pre-return `const`/`let`/`function` locals, #2447) is bound with
-       *     source `'preamble'`.
-       *
-       *   NOTE on a sibling mechanism this method does NOT mirror:
-       *   `adapters/loop-bound-names.ts`'s `collectLoopBoundNames` adds BOTH
-       *   `node.param` AND every `paramBindings[i].name` unconditionally
-       *   (never skipping `param` in the destructured case) — a deliberately
-       *   coarser, over-inclusive collection used only to subtract names from
-       *   a flat string-typing Set (safe to over-exclude there). This method
-       *   follows the precise `jsx-to-ir.ts` `ctx.loopParams` semantics, since
-       *   that is the mechanism actually doing scope-shadowed name RESOLUTION
-       *   (the behavior `BindingScope` replaces), not coarse exclusion.
-       */
-      enterLoopRow(loop) {
-        const bindings = /* @__PURE__ */ 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 name2 of loop.preamble?.declaredNames ?? []) bindings.set(name2, { source: "preamble" });
-        const frame = { kind: "loop-row", bindings };
-        return new _BindingScope([frame, ...this.frames]);
-      }
-      /**
-       * Child scope with a new `'callback'` frame binding `params` (a filter
-       * predicate's `x`, a sort comparator's `(a, b)`, or a nested arrow's
-       * parameter list) with source `'param'`. Parent is not mutated.
-       */
-      enterCallback(params) {
-        const bindings = /* @__PURE__ */ new Map();
-        for (const name2 of params) bindings.set(name2, { source: "param" });
-        const frame = { kind: "callback", bindings };
-        return new _BindingScope([frame, ...this.frames]);
-      }
-      /** Innermost-first membership check across every frame in the stack. */
-      isBound(name2) {
-        for (const frame of this.frames) {
-          if (frame.bindings.has(name2)) return true;
-        }
-        return false;
-      }
-      /**
-       * Resolves `name` against the frame stack innermost-first. `depth 0`
-       * means the innermost (most recently entered) frame; `null` when `name`
-       * is not bound in any frame.
-       */
-      lookup(name2) {
-        for (let depth = 0; depth < this.frames.length; depth++) {
-          const frame = this.frames[depth];
-          const binding = frame.bindings.get(name2);
-          if (binding) return { depth, frame, binding };
-        }
-        return null;
-      }
-      /**
-       * Union of every frame's bound names (every `ScopeBindingSource`), for
-       * migration interop with legacy `Set<string>`-shaped consumers (e.g.
-       * `collectLoopBoundNames`'s return type) as later stages migrate them
-       * onto `BindingScope`.
-       *
-       * This is the SHADOW-GUARD query — see {@link valueBoundNames} for the
-       * other consumer class and why the two must not be conflated.
-       */
-      boundNames() {
-        if (this.boundNamesCache) return this.boundNamesCache;
-        const names = /* @__PURE__ */ new Set();
-        for (const frame of this.frames) {
-          for (const name2 of frame.bindings.keys()) names.add(name2);
-        }
-        this.boundNamesCache = names;
-        return names;
-      }
-      // Both name queries are hot (shadow guards, slot/reactivity classifiers,
-      // binding-env memo keying) and the scope is immutable, so each computes
-      // once per instance. Callers receive the cached set as ReadonlySet —
-      // never mutate it.
-      boundNamesCache;
-      valueBoundNamesCache;
-      /**
-       * Union of names bound via `'item'`/`'index'`/`'destructure'` sources
-       * only — the loop row's own per-item identity — excluding `'preamble'`
-       * (a `.map()` callback's pre-return `const`/`let`/`function` locals,
-       * #2447) and `'param'` (an `enterCallback` frame's filter/sort/nested-
-       * arrow parameters).
-       *
-       * `BindingScope` has exactly two consumer classes, and conflating them
-       * is the #2482 Stage 1a Commit 2 regression this split exists to
-       * prevent (a `ctx.scope`-wide preamble merge flipped `tag-cloud` and
-       * `preamble-cells` conformance fixtures before this method existed):
-       *
-       *   - SHADOW GUARDS (`tryResolveTemplateSpanFromConst`,
-       *     `tryResolveIdentifierAsTemplateLiteral`, `rewriteBarePropRefs`
-       *     in `jsx-to-ir.ts`) ask "is this name resolved to SOMETHING in
-       *     this scope, so an outer const/prop of the same name must not be
-       *     substituted here at this transform position" — every source
-       *     qualifies, including a preamble local shadowing a module const.
-       *     These call `isBound` / `boundNames()`.
-       *   - REACTIVITY / SLOT-ID CLASSIFIERS (`referencesLoopParam`,
-       *     `hasReactiveAttributes`, and the `BindingEnvironment.loopParams`
-       *     feed built from `makeBindingEnv`, all in `jsx-to-ir.ts`) ask
-       *     "does this expression read a value that changes per row and so
-       *     needs its own patchable slot" — a preamble local already gets
-       *     ITS OWN dedicated slot/region-patch machinery
-       *     (`preambleRegions` / `markPreambleAttrSlots`, #2447), so folding
-       *     it into this classification double-counts it. Worse: widening a
-       *     text child's `reactive` flag this way is read by
-       *     `hasDynamicContent` to decide whether the loop ROW's own root
-       *     element needs a slot — an unrelated, narrower decision that must
-       *     not move just because a preamble local is now scope-visible.
-       *     These call `valueBoundNames()`.
-       */
-      valueBoundNames() {
-        if (this.valueBoundNamesCache) return this.valueBoundNamesCache;
-        const names = /* @__PURE__ */ new Set();
-        for (const frame of this.frames) {
-          for (const [name2, binding] of frame.bindings) {
-            if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
-              names.add(name2);
-            }
-          }
-        }
-        this.valueBoundNamesCache = names;
-        return names;
-      }
-      /**
-       * Drop-in for `resolveStaticLoopSource`'s `opts.isNameShadowed`
-       * (`packages/jsx/src/static-literal.ts:112-128`).
-       */
-      asShadowPredicate() {
-        return (name2) => this.isBound(name2);
-      }
-    };
-  }
-});
-
 // ../jsx/src/jsx-to-ir.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function hasLeadingClientDirective(expr, sourceFile) {
   const trivia = sourceFile.text.slice(expr.pos, expr.getStart(sourceFile));
   BLOCK_COMMENT_RE2.lastIndex = 0;
@@ -10176,13 +10242,13 @@ function exprCallsReactiveGetters(expr, ctx2) {
   let found = false;
   function visit3(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, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10205,11 +10271,11 @@ function exprReferencesModuleClientSignal(expr, ctx2) {
   let found = false;
   function visit3(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, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10218,11 +10284,11 @@ function exprHasFunctionCalls(expr) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts12.isCallExpression(n)) {
+    if (ts13.isCallExpression(n)) {
       found = true;
       return;
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10258,10 +10324,10 @@ function lowerDateCalls(text, expr, ctx2) {
   if (!matcher) return text;
   const candidates = [];
   function visit3(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, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   if (candidates.length === 0) return text;
@@ -10283,10 +10349,10 @@ function lowerToLocaleDateCalls(text, expr, ctx2) {
   if (!matcher) return text;
   const candidates = [];
   function visit3(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, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   if (candidates.length === 0) return text;
@@ -10339,10 +10405,10 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx2) {
   if (!propDepsMap || !branchVars || propDepsMap.size === 0) return void 0;
   let acc;
   function visit3(n, parent2) {
-    if (ts12.isIdentifier(n) && propDepsMap.has(n.text)) {
-      const isObjectKey = parent2 && ts12.isPropertyAssignment(parent2) && parent2.name === n;
-      const isShorthand = parent2 && ts12.isShorthandPropertyAssignment(parent2) && parent2.name === n;
-      const isAccessName = parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.name === n;
+    if (ts13.isIdentifier(n) && propDepsMap.has(n.text)) {
+      const isObjectKey = parent2 && ts13.isPropertyAssignment(parent2) && parent2.name === n;
+      const isShorthand = parent2 && ts13.isShorthandPropertyAssignment(parent2) && parent2.name === n;
+      const isAccessName = parent2 && ts13.isPropertyAccessExpression(parent2) && parent2.name === n;
       if (!isObjectKey && !isShorthand && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
@@ -10351,7 +10417,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx2) {
         }
       }
     }
-    ts12.forEachChild(n, (child) => visit3(child, n));
+    ts13.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return acc;
@@ -10398,17 +10464,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) {
@@ -10423,17 +10489,17 @@ function createTransformContext(analyzer) {
 function buildComponentNamespaces(ctx2) {
   const result2 = /* @__PURE__ */ new Map();
   for (const stmt of ctx2.sourceFile.statements) {
-    if (!ts12.isVariableStatement(stmt)) continue;
+    if (!ts13.isVariableStatement(stmt)) continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts12.isIdentifier(decl.name)) continue;
+      if (!decl.initializer || !ts13.isIdentifier(decl.name)) continue;
       let init = decl.initializer;
-      while (ts12.isParenthesizedExpression(init)) init = init.expression;
-      if (!ts12.isObjectLiteralExpression(init)) continue;
+      while (ts13.isParenthesizedExpression(init)) init = init.expression;
+      if (!ts13.isObjectLiteralExpression(init)) continue;
       const members = /* @__PURE__ */ 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);
         }
       }
@@ -10445,9 +10511,9 @@ function buildComponentNamespaces(ctx2) {
   return result2;
 }
 function resolveMemberExpressionTag(tagNode, ctx2) {
-  if (!ts12.isPropertyAccessExpression(tagNode)) return null;
-  if (!ts12.isIdentifier(tagNode.expression)) return null;
-  if (!ts12.isIdentifier(tagNode.name)) return null;
+  if (!ts13.isPropertyAccessExpression(tagNode)) return null;
+  if (!ts13.isIdentifier(tagNode.expression)) return null;
+  if (!ts13.isIdentifier(tagNode.name)) return null;
   if (!ctx2._componentNamespaces) {
     ctx2._componentNamespaces = buildComponentNamespaces(ctx2);
   }
@@ -10482,7 +10548,7 @@ function makeBindingEnv(ctx2) {
     // mutated (cached on the immutable `BindingScope`) — a stable
     // snapshot even if `ctx.scope` is later reassigned by an enclosing
     // visitor frame, which swaps the instance rather than mutating it.
-    loopParams: boundNames,
+    loopValueBoundNames: boundNames,
     checker: a.checker
   };
   ctx2._bindingEnv = env;
@@ -10588,7 +10654,7 @@ function buildIRRoot(analyzer) {
   if (!analyzer.jsxReturn) return null;
   const ctx2 = 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, ctx2);
     if (ir2 && needsScopeWrapper(ir2)) {
       return wrapInScopeElement(ir2);
@@ -10641,22 +10707,22 @@ function wrapInScopeElement(node) {
   };
 }
 function transformNode(node, ctx2) {
-  if (ts12.isJsxElement(node)) {
+  if (ts13.isJsxElement(node)) {
     return transformJsxElement(node, ctx2);
   }
-  if (ts12.isJsxSelfClosingElement(node)) {
+  if (ts13.isJsxSelfClosingElement(node)) {
     return transformSelfClosingElement(node, ctx2);
   }
-  if (ts12.isJsxFragment(node)) {
+  if (ts13.isJsxFragment(node)) {
     return transformFragment(node, ctx2);
   }
-  if (ts12.isJsxText(node)) {
+  if (ts13.isJsxText(node)) {
     return transformText(node, ctx2);
   }
-  if (ts12.isJsxExpression(node)) {
+  if (ts13.isJsxExpression(node)) {
     return transformExpression(node, ctx2);
   }
-  if (ts12.isConditionalExpression(node)) {
+  if (ts13.isConditionalExpression(node)) {
     return transformConditional(node, ctx2);
   }
   return null;
@@ -11035,14 +11101,14 @@ function transformSelfClosingComponent(node, ctx2, name2) {
 }
 function isTransparentFragment(node, ctx2) {
   const children2 = node.children.filter((child2) => {
-    if (ts12.isJsxText(child2)) {
+    if (ts13.isJsxText(child2)) {
       return child2.text.trim() !== "";
     }
     return true;
   });
   if (children2.length !== 1) return false;
   const child = children2[0];
-  if (!ts12.isJsxExpression(child)) return false;
+  if (!ts13.isJsxExpression(child)) return false;
   if (!child.expression) return false;
   const exprText = child.expression.getText(ctx2.sourceFile);
   if (exprText === "children") return true;
@@ -11081,7 +11147,7 @@ function transformChildren(children2, ctx2) {
   const result2 = [];
   for (let i = 0; i < children2.length; i++) {
     const child = children2[i];
-    if (ts12.isJsxExpression(child) && !child.expression) {
+    if (ts13.isJsxExpression(child) && !child.expression) {
       continue;
     }
     const transformed = transformNode(child, ctx2);
@@ -11096,10 +11162,10 @@ function transformChildren(children2, ctx2) {
 }
 function isRenderNothingLiteral(expr, ctx2) {
   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(ctx2));
+  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(ctx2));
 }
 function transformText(node, ctx2) {
   const text = node.text.replace(/\s+/g, " ");
@@ -11129,7 +11195,7 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
     return null;
   }
   checkBareSignalOrMemoIdentifier(expr, ctx2);
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     const jsxNode = ctx2.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
       return transformNode(jsxNode, ctx2);
@@ -11180,7 +11246,7 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
   };
   const reactive = isReactiveExpression(exprText, ctx2, expr) || isReactiveOrigin(origin);
   const scopeValueNames = ctx2.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, ctx2);
   const hasCalls = exprHasFunctionCalls(expr);
   const needsSlot = reactive || isClientOnly || refsLoopParam || callsReactive || hasCalls;
@@ -11215,7 +11281,7 @@ function transformJsxFunctionCall(callExpr, jsxFunc, ctx2, _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;
   };
@@ -11257,7 +11323,7 @@ function transformMultiReturnJsxFunctionCall(callExpr, info, ctx2) {
   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;
   };
@@ -11417,35 +11483,35 @@ function transformLogicalAnd(node, ctx2) {
   };
 }
 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, ctx2) {
   let found = false;
   const visit3 = (n) => {
     if (found) return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression)) {
       const name2 = n.expression.text;
       if (ctx2.analyzer.jsxFunctions.has(name2) || ctx2.analyzer.jsxMultiReturnFunctions.has(name2)) {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   };
   visit3(node);
   return found;
 }
 function containsAwaitExpression(node) {
-  if (ts12.isAwaitExpression(node)) return true;
-  if (ts12.isFunctionDeclaration(node) || ts12.isFunctionExpression(node) || ts12.isArrowFunction(node)) return false;
-  return ts12.forEachChild(node, containsAwaitExpression) ?? false;
+  if (ts13.isAwaitExpression(node)) return true;
+  if (ts13.isFunctionDeclaration(node) || ts13.isFunctionExpression(node) || ts13.isArrowFunction(node)) return false;
+  return ts13.forEachChild(node, containsAwaitExpression) ?? false;
 }
 function transformNullishCoalescing(node, ctx2) {
   const leftText = ctx2.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",
@@ -11492,46 +11558,46 @@ function transformNullishCoalescing(node, ctx2) {
 function assertNever2(expr) {
   const kind2 = expr?.kind;
   throw new Error(
-    `transformJsxExpression: unhandled ts.SyntaxKind ${kind2 !== void 0 ? ts12.SyntaxKind[kind2] : "unknown"} (kind=${kind2}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`
+    `transformJsxExpression: unhandled ts.SyntaxKind ${kind2 !== void 0 ? ts13.SyntaxKind[kind2] : "unknown"} (kind=${kind2}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`
   );
 }
 function transformJsxExpression(expr, ctx2, isClientOnly = false) {
   const node = expr;
   switch (node.kind) {
     // --- Transparent: unwrap and recurse ---
-    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, ctx2, isClientOnly);
     // --- JSX-structural: delegate to shape transformer ---
-    case ts12.SyntaxKind.JsxElement:
+    case ts13.SyntaxKind.JsxElement:
       return transformJsxElement(node, ctx2);
-    case ts12.SyntaxKind.JsxFragment:
+    case ts13.SyntaxKind.JsxFragment:
       return transformFragment(node, ctx2);
-    case ts12.SyntaxKind.JsxSelfClosingElement:
+    case ts13.SyntaxKind.JsxSelfClosingElement:
       return transformSelfClosingElement(node, ctx2);
-    case ts12.SyntaxKind.ConditionalExpression:
+    case ts13.SyntaxKind.ConditionalExpression:
       return transformConditional(node, ctx2);
-    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, ctx2);
       }
-      if ((node.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts12.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx2))) {
+      if ((node.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts13.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx2))) {
         return transformNullishCoalescing(node, ctx2);
       }
       return null;
     }
-    case ts12.SyntaxKind.CallExpression: {
+    case ts13.SyntaxKind.CallExpression: {
       const mapMethod = getMapLikeMethod(node);
       if (mapMethod) {
         const mapResult = transformMapCall(node, ctx2, isClientOnly, mapMethod);
         if (mapResult) return mapResult;
       }
       const callee = node.expression;
-      if (ts12.isIdentifier(callee)) {
+      if (ts13.isIdentifier(callee)) {
         const jsxFunc = ctx2.analyzer.jsxFunctions.get(callee.text);
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx2, isClientOnly);
@@ -11544,40 +11610,40 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
       return null;
     }
     // --- Scalar leaf: caller emits IRExpression ---
-    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;
     // --- Forbidden in render position ---
-    case ts12.SyntaxKind.AwaitExpression:
+    case ts13.SyntaxKind.AwaitExpression:
       ctx2.analyzer.errors.push(
         createError(
           ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
@@ -11593,20 +11659,20 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
         loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath),
         origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
       };
-    case ts12.SyntaxKind.YieldExpression:
+    case ts13.SyntaxKind.YieldExpression:
       return null;
     // --- Unreachable at render position ---
     // Parser prevents these in well-formed sources; listed for exhaustiveness
     // so an upstream TypeScript change that repurposes one of these kinds
     // surfaces as a compile error here instead of silently drifting.
-    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);
@@ -11642,15 +11708,15 @@ function transformConditionalBranch(node, ctx2) {
   };
 }
 function getMapLikeMethod(node) {
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   const name2 = node.expression.name.text;
   if (name2 === "map") return "map";
   if (name2 === "flatMap") return "flatMap";
   return null;
 }
 function isFilterCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   if (node.expression.name.text !== "filter") return null;
   if (node.arguments.length !== 1) return null;
   return {
@@ -11659,8 +11725,8 @@ function isFilterCall(node) {
   };
 }
 function isSortCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   const methodName = node.expression.name.text;
   if (methodName !== "sort" && methodName !== "toSorted") return null;
   if (node.arguments.length !== 1) return null;
@@ -11671,17 +11737,17 @@ function isSortCall(node) {
   };
 }
 function isIteratorShapeCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   if (node.arguments.length !== 0) return null;
   const name2 = node.expression.name.text;
   if (name2 !== "entries" && name2 !== "keys" && name2 !== "values") return null;
   return { array: node.expression.expression, shape: name2 };
 }
 function isObjectIteratorCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
-  if (!ts12.isIdentifier(node.expression.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isIdentifier(node.expression.expression)) return null;
   if (node.expression.expression.text !== "Object") return null;
   if (node.arguments.length !== 1) return null;
   const name2 = node.expression.name.text;
@@ -11702,7 +11768,7 @@ function extractSortComparator(callback, _method, ctx2) {
 (reverse the operands for descending order).`
   });
   let resolvedNode = callback;
-  if (ts12.isIdentifier(callback)) {
+  if (ts13.isIdentifier(callback)) {
     const resolved = resolveSortComparatorIdentifier(callback.text, ctx2);
     if (!resolved) {
       return {
@@ -11712,7 +11778,7 @@ function extractSortComparator(callback, _method, ctx2) {
     }
     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"
@@ -11736,11 +11802,11 @@ function resolveSortComparatorIdentifier(name2, ctx2) {
   if (constInfo && fnInfo) 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;
 }
@@ -11750,11 +11816,11 @@ function resolveCallbackMethodFunctionReferenceIdentifier(name2, analyzer) {
   if (constInfo && fnInfo) 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;
 }
@@ -11809,11 +11875,11 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
   return visit3(expr, bound);
 }
 function extractFilterPredicate(callback, ctx2) {
-  if (!ts12.isArrowFunction(callback)) return { result: null };
+  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 */."
@@ -11833,7 +11899,7 @@ function extractFilterPredicate(callback, ctx2) {
     return { result: null };
   }
   const param = firstParam.name.getText(ctx2.sourceFile);
-  if (ts12.isBlock(callback.body)) {
+  if (ts13.isBlock(callback.body)) {
     const raw2 = ctx2.getJS(callback.body);
     const statements = parseBlockBody(callback.body, ctx2.sourceFile, (n) => ctx2.getJS(n));
     if (!statements) {
@@ -11859,14 +11925,14 @@ function extractFilterPredicate(callback, ctx2) {
   return { result: { param, predicate, raw } };
 }
 function extractLoopParamBindings(pattern) {
-  if (ts12.isIdentifier(pattern)) return null;
+  if (ts13.isIdentifier(pattern)) return null;
   const bindings = [];
   let unsupported = false;
   const isIdent = (key) => {
     if (key.length === 0) 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;
     }
@@ -11877,19 +11943,19 @@ function extractLoopParamBindings(pattern) {
   };
   const walk = (p, prefix2, segments) => {
     if (unsupported) return;
-    if (ts12.isArrayBindingPattern(p)) {
+    if (ts13.isArrayBindingPattern(p)) {
       const elements3 = p.elements;
       for (let index = 0; index < elements3.length; index++) {
         if (unsupported) return;
         const el = elements3[index];
-        if (ts12.isOmittedExpression(el)) continue;
+        if (ts13.isOmittedExpression(el)) continue;
         if (el.dotDotDotToken) {
           internalInvariant(
             index === elements3.length - 1,
             "extractLoopParamBindings: array rest token in non-final position (parser should reject)"
           );
           internalInvariant(
-            ts12.isIdentifier(el.name),
+            ts13.isIdentifier(el.name),
             "extractLoopParamBindings: array rest target is not an identifier (parser should reject)"
           );
           bindings.push({
@@ -11902,7 +11968,7 @@ function extractLoopParamBindings(pattern) {
         }
         const path25 = `${prefix2}[${index}]`;
         const nextSegments = [...segments, { kind: "index", index }];
-        if (ts12.isIdentifier(el.name)) {
+        if (ts13.isIdentifier(el.name)) {
           bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
         } else {
           walk(el.name, path25, nextSegments);
@@ -11921,7 +11987,7 @@ function extractLoopParamBindings(pattern) {
           "extractLoopParamBindings: object rest token in non-final position (parser should reject)"
         );
         internalInvariant(
-          ts12.isIdentifier(el.name),
+          ts13.isIdentifier(el.name),
           "extractLoopParamBindings: object rest target is not an identifier (parser should reject)"
         );
         bindings.push({
@@ -11935,14 +12001,14 @@ function extractLoopParamBindings(pattern) {
       let keyText2 = null;
       if (el.propertyName) {
         const pn = el.propertyName;
-        if (ts12.isIdentifier(pn)) keyText2 = pn.text;
-        else if (ts12.isStringLiteral(pn)) keyText2 = pn.text;
-        else if (ts12.isNumericLiteral(pn)) keyText2 = pn.text;
+        if (ts13.isIdentifier(pn)) keyText2 = pn.text;
+        else if (ts13.isStringLiteral(pn)) keyText2 = pn.text;
+        else if (ts13.isNumericLiteral(pn)) keyText2 = pn.text;
         else {
           unsupported = true;
           return;
         }
-      } else if (ts12.isIdentifier(el.name)) {
+      } else if (ts13.isIdentifier(el.name)) {
         keyText2 = el.name.text;
       } else {
         unsupported = true;
@@ -11952,14 +12018,14 @@ function extractLoopParamBindings(pattern) {
       collectedKeys.push({ key: keyText2, isIdent: keyIsIdent });
       const path25 = appendDotAccess(prefix2, keyText2);
       const nextSegments = [...segments, { kind: "field", key: keyText2, isIdent: keyIsIdent }];
-      if (ts12.isIdentifier(el.name)) {
+      if (ts13.isIdentifier(el.name)) {
         bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
       } else {
         walk(el.name, path25, nextSegments);
       }
     }
   };
-  if (ts12.isArrayBindingPattern(pattern) || ts12.isObjectBindingPattern(pattern)) {
+  if (ts13.isArrayBindingPattern(pattern) || ts13.isObjectBindingPattern(pattern)) {
     walk(pattern, "", []);
     if (unsupported) return { unsupported: true };
     return bindings;
@@ -11968,7 +12034,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;
     }
   }
@@ -12009,7 +12075,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);
@@ -12021,33 +12087,33 @@ function conditionalHasExplicitNullishBranch(cond) {
 }
 function branchHasExplicitNullish(branch) {
   let b = branch;
-  while (ts12.isParenthesizedExpression(b)) b = b.expression;
-  if (b.kind === ts12.SyntaxKind.NullKeyword) return true;
-  if (ts12.isIdentifier(b) && b.text === "undefined") return true;
-  if (ts12.isConditionalExpression(b)) return conditionalHasExplicitNullishBranch(b);
+  while (ts13.isParenthesizedExpression(b)) b = b.expression;
+  if (b.kind === ts13.SyntaxKind.NullKeyword) return true;
+  if (ts13.isIdentifier(b) && b.text === "undefined") return true;
+  if (ts13.isConditionalExpression(b)) return conditionalHasExplicitNullishBranch(b);
   return false;
 }
 function classifyKeyProblem(keyAttr, checker) {
   if (!keyAttr) 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) return null;
-  if (ts12.isIdentifier(expr) && expr.text === "undefined") return null;
-  if (ts12.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr)) return null;
+  if (expr.kind === ts13.SyntaxKind.NullKeyword) return null;
+  if (ts13.isIdentifier(expr) && expr.text === "undefined") return null;
+  if (ts13.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr)) return null;
   if (checker) {
     const type2 = checker.getTypeAtLocation(expr);
     const isNullable = type2.isUnion() ? type2.types.some(
-      (t) => (t.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0
-    ) : (type2.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0;
+      (t) => (t.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0
+    ) : (type2.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0;
     if (isNullable) return "nullable-type";
   }
   return null;
@@ -12076,70 +12142,70 @@ function checkLoopKey(callback, ctx2, isNested) {
     );
   }
   let body2 = callback.body;
-  if (ts12.isBlock(body2)) {
+  if (ts13.isBlock(body2)) {
     const ret = body2.statements.find(
-      (s) => ts12.isReturnStatement(s) && s.expression != null
+      (s) => ts13.isReturnStatement(s) && s.expression != null
     );
     if (!ret?.expression) return;
     body2 = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts13.isParenthesizedExpression(body2)) body2 = body2.expression;
   function checkJsxOperand(node) {
     let n = node;
-    while (ts12.isParenthesizedExpression(n)) n = n.expression;
-    if (ts12.isJsxElement(n)) checkOpening(n.openingElement);
-    else if (ts12.isJsxSelfClosingElement(n)) checkOpening(n);
+    while (ts13.isParenthesizedExpression(n)) n = n.expression;
+    if (ts13.isJsxElement(n)) checkOpening(n.openingElement);
+    else if (ts13.isJsxSelfClosingElement(n)) checkOpening(n);
   }
-  if (ts12.isConditionalExpression(body2)) {
+  if (ts13.isConditionalExpression(body2)) {
     checkJsxOperand(body2.whenTrue);
     checkJsxOperand(body2.whenFalse);
     return;
   }
-  if (ts12.isBinaryExpression(body2) && (body2.operatorToken.kind === ts12.SyntaxKind.AmpersandAmpersandToken || body2.operatorToken.kind === ts12.SyntaxKind.BarBarToken || body2.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken)) {
+  if (ts13.isBinaryExpression(body2) && (body2.operatorToken.kind === ts13.SyntaxKind.AmpersandAmpersandToken || body2.operatorToken.kind === ts13.SyntaxKind.BarBarToken || body2.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken)) {
     checkJsxOperand(body2.left);
     checkJsxOperand(body2.right);
     return;
   }
-  if (ts12.isJsxElement(body2)) {
+  if (ts13.isJsxElement(body2)) {
     checkOpening(body2.openingElement);
     return;
   }
-  if (ts12.isJsxSelfClosingElement(body2)) {
+  if (ts13.isJsxSelfClosingElement(body2)) {
     checkOpening(body2);
     return;
   }
 }
 function flatMapProjectionCall(body2) {
   let expr;
-  if (ts12.isBlock(body2)) {
+  if (ts13.isBlock(body2)) {
     const real = body2.statements;
-    if (real.length !== 1 || !ts12.isReturnStatement(real[0]) || !real[0].expression) return null;
+    if (real.length !== 1 || !ts13.isReturnStatement(real[0]) || !real[0].expression) return null;
     expr = real[0].expression;
   } else {
     expr = body2;
   }
-  while (ts12.isParenthesizedExpression(expr)) expr = expr.expression;
-  if (!ts12.isCallExpression(expr)) return null;
+  while (ts13.isParenthesizedExpression(expr)) expr = expr.expression;
+  if (!ts13.isCallExpression(expr)) return null;
   if (!getMapLikeMethod(expr)) return null;
   const cb = expr.arguments[0];
-  if (!cb || !ts12.isArrowFunction(cb) && !ts12.isFunctionExpression(cb)) return null;
+  if (!cb || !ts13.isArrowFunction(cb) && !ts13.isFunctionExpression(cb)) return null;
   for (const p of cb.parameters) {
-    if (!ts12.isIdentifier(p.name)) return null;
+    if (!ts13.isIdentifier(p.name)) return null;
   }
   let innerBody = cb.body;
-  if (ts12.isBlock(innerBody)) {
+  if (ts13.isBlock(innerBody)) {
     const ret = innerBody.statements.find(
-      (s) => ts12.isReturnStatement(s) && s.expression != null
+      (s) => ts13.isReturnStatement(s) && s.expression != null
     );
     if (innerBody.statements.length !== 1 || !ret?.expression) return null;
     innerBody = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(innerBody)) innerBody = innerBody.expression;
+  while (ts13.isParenthesizedExpression(innerBody)) innerBody = innerBody.expression;
   const isElementish = (n) => {
     let m = n;
-    while (ts12.isParenthesizedExpression(m)) m = m.expression;
-    if (ts12.isJsxElement(m) || ts12.isJsxSelfClosingElement(m)) return leafIsWirelessElement(m);
-    if (ts12.isConditionalExpression(m)) return isElementish(m.whenTrue) && isElementish(m.whenFalse);
+    while (ts13.isParenthesizedExpression(m)) m = m.expression;
+    if (ts13.isJsxElement(m) || ts13.isJsxSelfClosingElement(m)) return leafIsWirelessElement(m);
+    if (ts13.isConditionalExpression(m)) return isElementish(m.whenTrue) && isElementish(m.whenFalse);
     return false;
   };
   if (!isElementish(innerBody)) return null;
@@ -12149,19 +12215,19 @@ function leafIsWirelessElement(el) {
   let ok = true;
   const visit3 = (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 name2 = attr.name.getText();
           if (/^on[A-Z]/.test(name2)) {
             ok = false;
@@ -12170,11 +12236,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, visit3);
+    ts13.forEachChild(n, visit3);
   };
   visit3(el);
   return ok;
@@ -12378,7 +12444,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   let children2 = [];
   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(ctx2.sourceFile);
@@ -12386,11 +12452,11 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         paramType = firstParam.type.getText(ctx2.sourceFile);
       }
       const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
-      if (isEntriesShape && ts12.isArrayBindingPattern(firstParam.name)) {
+      if (isEntriesShape && ts13.isArrayBindingPattern(firstParam.name)) {
         const elements2 = firstParam.name.elements.filter(
-          (el) => !ts12.isOmittedExpression(el)
+          (el) => !ts13.isOmittedExpression(el)
         );
-        if (elements2.length === 2 && ts12.isBindingElement(elements2[0]) && ts12.isIdentifier(elements2[0].name) && ts12.isBindingElement(elements2[1]) && ts12.isIdentifier(elements2[1].name)) {
+        if (elements2.length === 2 && ts13.isBindingElement(elements2[0]) && ts13.isIdentifier(elements2[0].name) && ts13.isBindingElement(elements2[1]) && ts13.isIdentifier(elements2[1].name)) {
           index = elements2[0].name.text;
           param = elements2[1].name.text;
         } else {
@@ -12431,9 +12497,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     ctx2.scope = ctx2.scope.enterLoopRow({ param, index, paramBindings });
     ctx2.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
-      if (!ts12.isBinaryExpression(expr)) return;
+      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, ctx2)) return;
@@ -12441,33 +12507,33 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       if (transformed) children2 = [transformed];
     };
     const body2 = callback.body;
-    if (ts12.isJsxElement(body2) || ts12.isJsxSelfClosingElement(body2) || ts12.isJsxFragment(body2)) {
+    if (ts13.isJsxElement(body2) || ts13.isJsxSelfClosingElement(body2) || ts13.isJsxFragment(body2)) {
       const transformed = transformNode(body2, ctx2);
       if (transformed) {
         children2 = [transformed];
       }
-    } else if (ts12.isConditionalExpression(body2)) {
+    } else if (ts13.isConditionalExpression(body2)) {
       children2 = [transformConditional(body2, ctx2)];
-    } else if (ts12.isParenthesizedExpression(body2)) {
+    } else if (ts13.isParenthesizedExpression(body2)) {
       let inner = body2.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, ctx2);
         if (transformed) {
           children2 = [transformed];
         }
-      } else if (ts12.isConditionalExpression(inner)) {
+      } else if (ts13.isConditionalExpression(inner)) {
         children2 = [transformConditional(inner, ctx2)];
-      } else if (method2 === "flatMap" && ts12.isArrayLiteralExpression(inner)) {
+      } else if (method2 === "flatMap" && ts13.isArrayLiteralExpression(inner)) {
         children2 = transformArrayLiteralChildren(inner, ctx2);
       } else {
         tryTransformRenderableBody(inner);
       }
-    } else if (method2 === "flatMap" && ts12.isArrayLiteralExpression(body2)) {
+    } else if (method2 === "flatMap" && ts13.isArrayLiteralExpression(body2)) {
       children2 = transformArrayLiteralChildren(body2, ctx2);
-    } else if (ts12.isBlock(body2)) {
+    } else if (ts13.isBlock(body2)) {
       const multiReturn = method2 !== "flatMap" ? extractMultiReturnJsxBranches(body2, true) : null;
       if (multiReturn && multiReturn.branches.length > 0) {
         const loc = getSourceLocation(body2, ctx2.sourceFile, ctx2.filePath);
@@ -12488,7 +12554,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         }
       }
       const returnStmt = children2.length === 0 ? body2.statements.find(
-        (s) => ts12.isReturnStatement(s) && s.expression != null
+        (s) => ts13.isReturnStatement(s) && s.expression != null
       ) : void 0;
       let rowScopeBeforePreamble = null;
       if (returnStmt) {
@@ -12509,10 +12575,10 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "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, ctx2);
           if (transformed) {
             children2 = [transformed];
@@ -12616,7 +12682,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         }
       }
     }
-    if (method2 === "flatMap" && children2.length === 0 && !flatMapCallback && !ts12.isBlock(body2)) {
+    if (method2 === "flatMap" && children2.length === 0 && !flatMapCallback && !ts13.isBlock(body2)) {
       flatMapCallback = buildFlatMapCallback(callback, body2, ctx2);
     }
     if (flatMapCallback) preamble = void 0;
@@ -12639,7 +12705,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   }
   if (children2.length === 0 && !flatMapCallback) {
     const cb = node.arguments[0];
-    const cbBody = cb && (ts12.isArrowFunction(cb) || ts12.isFunctionExpression(cb)) ? cb.body : void 0;
+    const cbBody = cb && (ts13.isArrowFunction(cb) || ts13.isFunctionExpression(cb)) ? cb.body : void 0;
     if (cbBody && containsJsxInExpression(cbBody) && ctx2.analyzer.errors.length === diagCountAtEntry) {
       ctx2.analyzer.errors.push(
         createError(
@@ -12656,7 +12722,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     }
     return null;
   }
-  if (ts12.isArrowFunction(node.arguments[0]) && children2.length > 0) {
+  if (ts13.isArrowFunction(node.arguments[0]) && children2.length > 0) {
     checkLoopKey(node.arguments[0], ctx2, isNested);
   }
   const itemConditional = children2.length > 0 ? loopBodyItemConditional(children2) : null;
@@ -12714,6 +12780,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children2, new Set(preamble.declaredNames), ctx2) : void 0;
   if (preamble && !isStaticArray) {
     markPreambleAttrSlots(children2, new Set(preamble.declaredNames), ctx2);
+    if (preamble.reactiveNames && preamble.reactiveNames.length > 0) {
+      markPreambleConditionalReactivity(children2, new Set(preamble.reactiveNames), ctx2);
+    }
   }
   const nestedComponents = collectNestedComponents(children2).filter((c) => c.name !== childComponent?.name);
   return {
@@ -12764,10 +12833,10 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
 function transformArrayLiteralChildren(arrayLiteral, ctx2) {
   const children2 = [];
   for (const element of arrayLiteral.elements) {
-    if (ts12.isSpreadElement(element)) continue;
+    if (ts13.isSpreadElement(element)) continue;
     let inner = element;
-    while (ts12.isParenthesizedExpression(inner)) inner = inner.expression;
-    if (ts12.isJsxElement(inner) || ts12.isJsxSelfClosingElement(inner) || ts12.isJsxFragment(inner)) {
+    while (ts13.isParenthesizedExpression(inner)) inner = inner.expression;
+    if (ts13.isJsxElement(inner) || ts13.isJsxSelfClosingElement(inner) || ts13.isJsxFragment(inner)) {
       const transformed = transformNode(inner, ctx2);
       if (transformed) children2.push(transformed);
     }
@@ -12775,7 +12844,7 @@ function transformArrayLiteralChildren(arrayLiteral, ctx2) {
   return children2;
 }
 function containsJsx(node) {
-  if (ts12.isJsxElement(node) || ts12.isJsxSelfClosingElement(node) || ts12.isJsxFragment(node)) return true;
+  if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node)) return true;
   let found = false;
   node.forEachChild((child) => {
     if (!found) found = containsJsx(child);
@@ -12788,14 +12857,14 @@ function buildFlatMapCallback(callback, body2, ctx2) {
   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(ctx2.sourceFile), end: n.getEnd() });
       const ir = transformNode(n, ctx2);
       leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx2.sourceFile, ctx2.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(body2, false);
@@ -12980,6 +13049,31 @@ function markPreambleAttrSlots(nodes, declared, ctx2) {
   };
   visit3(nodes);
 }
+function markPreambleConditionalReactivity(nodes, reactiveNames, ctx2) {
+  if (reactiveNames.size === 0) return;
+  const visit3 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+        case "fragment":
+          visit3(node.children);
+          break;
+        case "conditional": {
+          if (!node.reactive) {
+            const refs = extractFreeIdentifiersFromText(node.condition);
+            if ([...refs].some((r2) => reactiveNames.has(r2))) {
+              node.reactive = true;
+              if (!node.slotId) node.slotId = generateSlotId(ctx2);
+            }
+          }
+          visit3([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+        }
+      }
+    }
+  };
+  visit3(nodes);
+}
 function attrValueText(value2) {
   if (value2.kind === "expression") return value2.expr;
   if (value2.kind !== "template") return "";
@@ -12991,23 +13085,42 @@ function attrValueText(value2) {
   return out.join(" ");
 }
 function collectBindingNames2(name2, out) {
-  if (ts12.isIdentifier(name2)) {
+  if (ts13.isIdentifier(name2)) {
     out.add(name2.text);
     return;
   }
   for (const el of name2.elements) {
-    if (ts12.isBindingElement(el)) collectBindingNames2(el.name, out);
+    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, ctx2) {
+  const reactiveNames = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
+      collectBindingNames2(decl.name, boundNames);
+      const initText = ctx2.getJS(decl.initializer);
+      const initFreeRefs = extractFreeIdentifiersFromNode(decl.initializer);
+      const readsEarlierReactive = [...initFreeRefs].some((r2) => reactiveNames.has(r2));
+      const isReactive = readsEarlierReactive || isReactiveExpression(initText, ctx2, decl.initializer);
+      if (isReactive) {
+        for (const n of boundNames) reactiveNames.add(n);
+      }
+    }
+  }
+  return reactiveNames;
+}
 function preambleFromValueStatements(statements, ctx2) {
   const segments = [];
   const typedParts = [];
@@ -13022,21 +13135,23 @@ function preambleFromValueStatements(statements, ctx2) {
     typedParts.push(raw0.endsWith(";") ? raw0 : raw0 + ";");
     segments.push(tjs !== js ? { kind: "js", text: js, templateText: tjs } : { kind: "js", text: js });
   }
+  const reactiveNames = computePreambleReactiveNames(statements, ctx2);
   return {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     // Value-only preambles accumulate no JSX, so no child needs the array join.
     builderNames: [],
-    declarations: neutralPreambleDeclarations(statements, ctx2) ?? void 0
+    declarations: neutralPreambleDeclarations(statements, ctx2) ?? void 0,
+    reactiveNames: reactiveNames.size > 0 ? [...reactiveNames] : void 0
   };
 }
 function neutralPreambleDeclarations(statements, ctx2) {
   const out = [];
   for (const stmt of statements) {
-    if (!ts12.isVariableStatement(stmt)) return null;
+    if (!ts13.isVariableStatement(stmt)) return null;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts12.isIdentifier(decl.name)) return null;
+      if (!ts13.isIdentifier(decl.name)) return null;
       if (!decl.initializer) return null;
       const valueParsed = tsNodeToParsedExpr(decl.initializer);
       if (!isSupported(valueParsed).supported) return null;
@@ -13066,11 +13181,11 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
   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;
       }
@@ -13082,7 +13197,7 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
     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);
         leafSpans.push({ start: n.getStart(ctx2.sourceFile), end: n.getEnd() });
@@ -13091,7 +13206,7 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
         leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx2.sourceFile, ctx2.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);
@@ -13195,13 +13310,13 @@ function expandSpreadAttribute(attr, ctx2) {
   }];
 }
 function attrFreeIdentifiers(attr) {
-  if (!attr.initializer || !ts12.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !ts13.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return void 0;
   }
   return extractFreeIdentifiersFromNode(attr.initializer.expression);
 }
 function computeReactivityFlags(attr, ctx2) {
-  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;
@@ -13232,21 +13347,21 @@ function processAttributes(attributes2, ctx2) {
   const events = [];
   let ref = null;
   for (const attr of attributes2.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       attrs.push(...expandSpreadAttribute(attr, ctx2));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr)) continue;
+    if (!ts13.isJsxAttribute(attr)) continue;
     const rawName = attr.name.getText(ctx2.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, ctx2);
         ref = ctx2.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, ctx2);
         events.push({
@@ -13261,7 +13376,7 @@ function processAttributes(attributes2, ctx2) {
     const name2 = toHTMLAttrName(rawName);
     let value2 = getAttributeValue(attr, ctx2);
     let clientOnly;
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value2.kind === "expression" && value2.templateExpr === void 0) {
         const rewritten = rewriteBarePropRefs2(value2.expr, attr.initializer.expression, ctx2);
         if (rewritten !== value2.expr) {
@@ -13288,19 +13403,19 @@ function getAttributeValue(attr, ctx2) {
   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 = ctx2._branchScopeVars?.get(expr.text);
       if (branchInit && !initializerShapeContainsJsx(branchInit)) {
         expr = branchInit;
       }
     }
     expr = tryDesugarInterleaveTaggedTemplate(expr, ctx2);
-    if (ts12.isAwaitExpression(expr)) {
+    if (ts13.isAwaitExpression(expr)) {
       ctx2.analyzer.errors.push(
         createError(
           ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
@@ -13310,38 +13425,38 @@ function getAttributeValue(attr, ctx2) {
       return AttrValueOf.expression("undefined");
     }
     checkBareSignalOrMemoIdentifier(expr, ctx2);
-    if (attr.name.getText(ctx2.sourceFile) === "style" && ts12.isObjectLiteralExpression(expr)) {
+    if (attr.name.getText(ctx2.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, ctx2);
       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, ctx2);
       if (parts) {
         return AttrValueOf.template(parts);
       }
     }
-    if (ts12.isIdentifier(expr)) {
+    if (ts13.isIdentifier(expr)) {
       const resolved = tryResolveIdentifierAsTemplateLiteral(expr, ctx2);
       if (resolved) {
         return AttrValueOf.template(resolved);
       }
     }
-    if (ts12.isConditionalExpression(expr)) {
+    if (ts13.isConditionalExpression(expr)) {
       const ternary = parseTernary(expr, ctx2);
       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 = ctx2.getJS(expr.left);
         return AttrValueOf.expression(baseExpr, { presenceOrUndefined: true });
       }
@@ -13354,9 +13469,9 @@ function getAttributeValue(attr, ctx2) {
 function tryStaticStyleObjectToCss(expr) {
   const parts = [];
   for (const prop of expr.properties) {
-    if (!ts12.isPropertyAssignment(prop)) return null;
-    if (!ts12.isIdentifier(prop.name) && !ts12.isStringLiteral(prop.name)) return null;
-    if (!ts12.isStringLiteral(prop.initializer)) return null;
+    if (!ts13.isPropertyAssignment(prop)) return null;
+    if (!ts13.isIdentifier(prop.name) && !ts13.isStringLiteral(prop.name)) return null;
+    if (!ts13.isStringLiteral(prop.initializer)) return null;
     const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
   }
@@ -13368,7 +13483,7 @@ function parseTemplateLiteral(expr, ctx2) {
     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, ctx2);
       if (ternary) {
         parts.push(ternary);
@@ -13394,31 +13509,31 @@ function parseTemplateLiteral(expr, ctx2) {
   return parts;
 }
 function tryResolveTemplateSpanFromConst(expr, ctx2) {
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     if (ctx2.scope.isBound(expr.text)) return null;
     const constInfo = findLocalConst(expr.text, ctx2.analyzer);
     if (!constInfo) return null;
     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)) return null;
+  if (ts13.isElementAccessExpression(expr)) {
+    if (!ts13.isIdentifier(expr.expression)) return null;
     if (ctx2.scope.isBound(expr.expression.text)) return null;
     const constInfo = findLocalConst(expr.expression.text, ctx2.analyzer);
     if (!constInfo) return null;
     const ast = parseConstInitializer(constInfo);
-    if (!ast || !ts12.isObjectLiteralExpression(ast)) return null;
+    if (!ast || !ts13.isObjectLiteralExpression(ast)) return null;
     const cases = {};
     for (const prop of ast.properties) {
-      if (!ts12.isPropertyAssignment(prop)) return null;
-      const keyName = prop.name && (ts12.isStringLiteral(prop.name) || ts12.isIdentifier(prop.name)) ? prop.name.text : null;
+      if (!ts13.isPropertyAssignment(prop)) return null;
+      const keyName = prop.name && (ts13.isStringLiteral(prop.name) || ts13.isIdentifier(prop.name)) ? prop.name.text : null;
       if (!keyName) return null;
       const value2 = prop.initializer;
-      if (ts12.isStringLiteral(value2) || ts12.isNoSubstitutionTemplateLiteral(value2)) {
+      if (ts13.isStringLiteral(value2) || ts13.isNoSubstitutionTemplateLiteral(value2)) {
         cases[keyName] = value2.text;
       } else {
         return null;
@@ -13457,17 +13572,17 @@ function hasDynamicTagBinding(name2, sourceFile) {
   let found = false;
   const visit3 = (node) => {
     if (found) return;
-    if (ts12.isVariableDeclaration(node) && ts12.isIdentifier(node.name) && node.name.text === name2 && node.initializer) {
+    if (ts13.isVariableDeclaration(node) && ts13.isIdentifier(node.name) && node.name.text === name2 && 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, visit3);
+    ts13.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   return found;
@@ -13478,13 +13593,13 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx2) {
   if (!constInfo) return null;
   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, ctx2);
   }
-  if (!ts12.isTemplateExpression(ast)) return null;
+  if (!ts13.isTemplateExpression(ast)) return null;
   let resolvedAny = false;
   const parts = [];
   if (ast.head.text) parts.push({ type: "string", value: ast.head.text });
@@ -13516,19 +13631,19 @@ function parseConstInitializer(c) {
 function parseConstInitializerImpl(c) {
   if (!c.value) return null;
   const wrapped = `const __bf_resolve__ = (${c.value})`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve.ts",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TS
+    ts13.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  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());
@@ -13545,23 +13660,23 @@ function parseFunctionInfoAsExprImpl(fn) {
   const params = fn.typedParams !== void 0 ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
   const body2 = fn.typedBody ?? fn.body;
   const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body2}`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve_fn.ts",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TS
+    ts13.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts13.isVariableStatement(stmt)) return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer) return null;
   return decl.initializer;
 }
 function tryDesugarInterleaveTaggedTemplate(expr, ctx2) {
-  if (!ts12.isTaggedTemplateExpression(expr)) return expr;
-  if (!ts12.isIdentifier(expr.tag)) return expr;
+  if (!ts13.isTaggedTemplateExpression(expr)) return expr;
+  if (!ts13.isIdentifier(expr.tag)) return expr;
   const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx2);
   if (!resolvedTag) return expr;
   if (!isInterleaveTagFunction(resolvedTag)) return expr;
@@ -13574,20 +13689,20 @@ function resolveInterleaveTagIdentifier(name2, ctx2) {
   if (constInfo && fnInfo) 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)) return false;
+  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) return false;
-  if (!ts12.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken) return false;
+  if (!ts13.isIdentifier(partsParam.name) || partsParam.dotDotDotToken) return false;
+  if (!ts13.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken) return false;
   const parsed = tsNodeToParsedExpr(fn);
   if (parsed.kind !== "arrow") return false;
   return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
@@ -13629,7 +13744,7 @@ function isInterleaveSpanExpr(expr, i, argsName) {
 function buildUntaggedTemplateLiteral(node, ctx2) {
   const template = node.template;
   let text;
-  if (ts12.isNoSubstitutionTemplateLiteral(template)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(template)) {
     text = "`" + (template.rawText ?? template.text) + "`";
   } else {
     let body2 = template.head.rawText ?? template.head.text;
@@ -13641,20 +13756,20 @@ function buildUntaggedTemplateLiteral(node, ctx2) {
     text = "`" + body2 + "`";
   }
   const wrapped = `const __bf_resolve_tagged__ = (${text})`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve_tagged.tsx",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TSX
+    ts13.ScriptKind.TSX
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts13.isVariableStatement(stmt)) return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer) return null;
-  const result2 = ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
-  if (!ts12.isTemplateExpression(result2) && !ts12.isNoSubstitutionTemplateLiteral(result2)) return null;
+  const result2 = ts13.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!ts13.isTemplateExpression(result2) && !ts13.isNoSubstitutionTemplateLiteral(result2)) return null;
   return result2;
 }
 function parseTernary(expr, ctx2) {
@@ -13673,10 +13788,10 @@ function parseTernary(expr, ctx2) {
   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;
@@ -13684,18 +13799,18 @@ function getStringValue(node) {
 function processComponentProps(attributes2, ctx2) {
   const props = [];
   for (const attr of attributes2.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       props.push(...expandSpreadAttribute(attr, ctx2));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr)) continue;
+    if (!ts13.isJsxAttribute(attr)) continue;
     const name2 = attr.name.getText(ctx2.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 = ctx2.insideComponentChildren;
         ctx2.insideComponentChildren = true;
         const irNode = transformNode(jsxExpr, ctx2);
@@ -13722,7 +13837,7 @@ function processComponentProps(attributes2, ctx2) {
       value2 = 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 (value2.kind === "expression" && value2.templateExpr === void 0) {
         const rewritten = rewriteBarePropRefs2(value2.expr, attr.initializer.expression, ctx2);
         if (rewritten !== value2.expr) {
@@ -13746,7 +13861,7 @@ function processComponentProps(attributes2, ctx2) {
   return props;
 }
 function checkBareSignalOrMemoIdentifier(expr, ctx2) {
-  if (!ts12.isIdentifier(expr)) return;
+  if (!ts13.isIdentifier(expr)) return;
   const name2 = expr.text;
   for (const signal2 of ctx2.analyzer.signals) {
     if (signal2.getter === name2) {
@@ -13788,12 +13903,12 @@ function checkBareSignalOrMemoIdentifier(expr, ctx2) {
 function isArrayExprDirectPropRef(arrayExpr, ctx2) {
   const propNames = new Set(ctx2.patterns.props.map((p) => p.name));
   const propsObjName = ctx2.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;
     }
   }
@@ -13812,7 +13927,7 @@ function referencesLoopParam(expr, ctx2) {
   const boundNames = ctx2.scope.valueBoundNames();
   if (boundNames.size === 0) return false;
   for (const p of boundNames) {
-    if (new RegExp(`\\b${p}\\b`).test(expr)) return true;
+    if (identifierPattern(p).test(expr)) return true;
   }
   return false;
 }
@@ -13880,7 +13995,7 @@ function hasReactiveAttributes(attrs, ctx2) {
     const scopeValueNames = ctx2.scope.valueBoundNames();
     if (scopeValueNames.size > 0) {
       for (const p of scopeValueNames) {
-        if (new RegExp(`\\b${p}\\b`).test(valueToCheck)) return true;
+        if (identifierPattern(p).test(valueToCheck)) return true;
       }
     }
   }
@@ -13965,7 +14080,7 @@ function buildIfStatementChain(analyzer, ctx2, opts) {
       for (const n of prevJsxBranchLocalNames) 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);
@@ -14029,7 +14144,7 @@ function buildIfStatementChain(analyzer, ctx2, 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 = ctx2.getJS(decl.initializer);
         const typedInit = decl.initializer.getText(ctx2.sourceFile);
         scopeVariables.push({
@@ -14104,6 +14219,7 @@ var init_jsx_to_ir = __esm({
     init_template_parts();
     init_src();
     init_binding_scope();
+    init_identifier_pattern();
     CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
     BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
     EMPTY_BOUND = /* @__PURE__ */ new Set();
@@ -14113,17 +14229,19 @@ var init_jsx_to_ir = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/prop-handling.ts
-function expandDynamicPropValue(value2, ctx2) {
+function expandDynamicPropValue(value2, ctx2, scope) {
   const trimmedValue = value2.trim();
+  if (scope?.isBound(trimmedValue)) return value2;
   const constant = ctx2.localConstants.find((c) => c.name === trimmedValue);
   if (constant && constant.value) {
     return constant.value;
   }
   return value2;
 }
-function expandConstantForReactivity(expr, ctx2, originalFreeIds) {
+function expandConstantForReactivity(expr, ctx2, originalFreeIds, scope) {
   if (ctx2.propsObjectName) return { expr, freeIds: originalFreeIds };
   const trimmedValue = expr.trim();
+  if (scope?.isBound(trimmedValue)) return { expr, freeIds: originalFreeIds };
   const constant = ctx2.localConstants.find((c) => c.name === trimmedValue);
   if (constant && constant.value) {
     return { expr: constant.value, freeIds: constant.freeIdentifiers };
@@ -14164,6 +14282,15 @@ var init_prop_handling = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/reactivity.ts
+function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex) {
+  if (!loopParam) return void 0;
+  return BindingScope.EMPTY.enterLoopRow({
+    param: loopParam,
+    paramBindings: loopParamBindings,
+    index: loopIndex,
+    preamble: preambleNames && preambleNames.size > 0 ? { declaredNames: [...preambleNames] } : void 0
+  });
+}
 function decideWrapFromAstFlags(node) {
   if (node.origin && isReactiveOrigin(node.origin)) {
     return { wrap: true, reason: "proven-reactive" };
@@ -14185,12 +14312,12 @@ function decideWrapForChildProp(expandedValue, ctx2, prop) {
 }
 function needsEffectWrapper(expr, ctx2, freeIdentifiers2) {
   for (const signal2 of ctx2.signals) {
-    if (new RegExp(`\\b${signal2.getter}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(signal2.getter).test(expr)) {
       return true;
     }
   }
   for (const memo of ctx2.memos) {
-    if (new RegExp(`\\b${memo.name}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(memo.name).test(expr)) {
       return true;
     }
   }
@@ -14386,8 +14513,9 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
+function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
   const texts = [];
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
   walkIR(node, false, {
     // Skip loop/async/if-statement subtrees — the original walker omitted
     // them; they have their own scopes (inner-loop reconciliation, async
@@ -14397,7 +14525,7 @@ function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings,
       if (!n.slotId) return;
       if (n.preambleRegion) return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
-      const expanded = expandConstantForReactivity(n.expr, ctx2, originFreeIds);
+      const expanded = expandConstantForReactivity(n.expr, ctx2, originFreeIds, scope);
       const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
       if (!reactive) return;
       texts.push({
@@ -14417,8 +14545,9 @@ function anyNameIn(names, set) {
   for (const n of names) if (set.has(n)) return true;
   return false;
 }
-function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames) {
+function collectLoopChildReactiveAttrs(node, ctx2, 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) {
@@ -14427,7 +14556,7 @@ function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings,
         if (attr.name === "key") continue;
         const valueStr = attrValueToString(attr.value);
         if (!valueStr) continue;
-        const expanded = expandConstantForReactivity(valueStr, ctx2, attr.freeIdentifiers);
+        const expanded = expandConstantForReactivity(valueStr, ctx2, attr.freeIdentifiers, scope);
         const readsPreamble = preambleNames !== void 0 && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
         const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive) continue;
@@ -14452,6 +14581,8 @@ var init_reactivity = __esm({
     init_prop_handling();
     init_csr_substitute();
     init_walker();
+    init_binding_scope();
+    init_identifier_pattern();
   }
 });
 
@@ -14724,13 +14855,13 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
         const emitDepth = fixedDepth ?? scope.depth + 1;
         const loopParamsForTemplate = outerLoopParam ? [outerLoopParam, { param: n.param, bindings: n.paramBindings }] : void 0;
         const template = n.children.map((c) => irToPlaceholderTemplate(c, void 0, 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 (ctx2) {
           for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings, false, innerPreambleNames));
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings, false, innerPreambleNames, n.index));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings, false, innerPreambleNames, n.index));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
         }
@@ -14762,7 +14893,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
               ctx2,
               siblingOffsets,
               n.param,
-              n.paramBindings
+              n.paramBindings,
+              innerPreambleNames,
+              n.index
             ));
           }
         }
@@ -14944,7 +15077,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       if (!l.slotId || inCond) return;
       const projectionInner = l.method === "flatMap" && l.children.length === 1 && l.children[0].type === "loop" ? l.children[0] : void 0;
       const childHandlers = [];
-      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx2, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l));
+      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx2, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l), l.index);
       if (!projectionInner) {
         for (const child of l.children) {
           childHandlers.push(...collectEventHandlersFromIR(child));
@@ -15196,7 +15329,7 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, void 0, 0, branchLoopParamSpec)).join("");
       }
-      const branchBindings = ctx2 && !projectionInner ? collectLoopChildBindings(n.children, ctx2, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n)) : emptyLoopChildBindings();
+      const branchBindings = ctx2 && !projectionInner ? collectLoopChildBindings(n.children, ctx2, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n), n.index) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
         array: n.array,
@@ -15282,19 +15415,20 @@ function preambleNamesOf(loop) {
   const declared = loop.preamble?.declaredNames;
   return declared && declared.length > 0 ? new Set(declared) : void 0;
 }
-function collectLoopChildBindings(children2, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames) {
+function collectLoopChildBindings(children2, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
   const bindings = emptyLoopChildBindings();
   for (const child of children2) {
     bindings.events.push(...collectLoopChildEventsWithNesting(child));
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, loopParam, loopParamBindings, true, preambleNames));
-    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, loopParam, loopParamBindings, true));
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, loopParam, loopParamBindings, true, preambleNames, loopIndex));
+    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, loopParam, loopParamBindings, true, preambleNames, loopIndex));
     bindings.refs.push(...collectLoopChildRefs(child));
-    bindings.conditionals.push(...collectLoopChildConditionals(child, ctx2, siblingOffsets, loopParam, loopParamBindings));
+    bindings.conditionals.push(...collectLoopChildConditionals(child, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex));
   }
   return bindings;
 }
-function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loopParamBindings) {
+function collectLoopChildConditionals(node, ctx2, 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) {
@@ -15314,8 +15448,9 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
       const sourceFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const refsLoopParamInSource = refsAnyBindingViaFreeIds(sourceFreeIds);
       if (!n.reactive && !refsLoopParamInSource) return;
-      const expanded = expandConstantForReactivity(n.condition, ctx2, sourceFreeIds);
-      if (classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind === "none") return;
+      const expanded = expandConstantForReactivity(n.condition, ctx2, sourceFreeIds, scope);
+      const readsPreamble = preambleNames !== void 0 && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
+      if (!readsPreamble && classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind === "none") return;
       const loopParamsForCond = loopParam ? [{ param: loopParam, bindings: loopParamBindings }] : void 0;
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, void 0, 0, loopParamsForCond, "__slots");
       const whenFalseHtml = irToHtmlTemplate(n.whenFalse, void 0, 0, loopParamsForCond, "__slots");
@@ -15324,27 +15459,28 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
         condition: expanded.expr,
         whenTrueHtml,
         whenFalseHtml,
-        whenTrue: summarizeLoopChildBranch(n.whenTrue, ctx2, siblingOffsets, loopParam, loopParamBindings),
-        whenFalse: summarizeLoopChildBranch(n.whenFalse, ctx2, siblingOffsets, loopParam, loopParamBindings),
-        ...expanded.freeIds !== void 0 && { conditionFreeIdentifiers: expanded.freeIds }
+        whenTrue: summarizeLoopChildBranch(n.whenTrue, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
+        whenFalse: summarizeLoopChildBranch(n.whenFalse, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
+        ...expanded.freeIds !== void 0 && { conditionFreeIdentifiers: expanded.freeIds },
+        ...readsPreamble && { readsPreamble: true }
       });
     }
   });
   return conditionals;
 }
-function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopParamBindings) {
+function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
   const inner = collectInnerLoops([node], siblingOffsets, loopParam, ctx2, branchInnerLoopOptions);
   return {
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : void 0,
-    conditionals: collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loopParamBindings),
+    conditionals: collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
     events: collectConditionalBranchEvents(node),
     // Loop-param-aware — reuses the flat loop-item collectors scoped to just
     // this branch's subtree. Both already stop descending into any further
     // nested reactive conditional (own insert()/arm), so calling them here
     // on the branch root yields exactly this branch's direct bindings
     // without re-collecting what a nested arm already owns (#2347).
-    reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, true),
+    reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, true, preambleNames, loopIndex),
     // Skip ONLY when the branch's entire content is a single bare
     // `expression` (no wrapping element) that MAY yield a live DOM node —
     // i.e. it contains a call anywhere (`node.hasFunctionCalls`, computed
@@ -15392,7 +15528,7 @@ function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopPar
     // makes `irToHtmlTemplate` emit its `<!--bf:sN-->…<!--/-->` marker (the
     // same call builds both the SSR and the CSR/hydration template, so the
     // two can't disagree on shape).
-    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true)
+    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true, preambleNames, loopIndex)
   };
 }
 var EMPTY_RENDER_EXPRS, branchInnerLoopOptions;
@@ -15405,8 +15541,10 @@ var init_collect_elements = __esm({
     init_html_template();
     init_template_parse();
     init_prop_handling();
+    init_csr_substitute();
     init_walker();
     init_loop_chain();
+    init_identifier_pattern();
     EMPTY_RENDER_EXPRS = /* @__PURE__ */ new Set(["null", "undefined", "false", "''", '""', "``"]);
     branchInnerLoopOptions = {
       collectItemBindings: true,
@@ -15761,7 +15899,7 @@ var init_build_references = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function collectPropAccesses(source, propNames, out) {
   if (propNames.size === 0) return;
   let anyMentioned = false;
@@ -15773,13 +15911,13 @@ function collectPropAccesses(source, propNames, out) {
   }
   if (!anyMentioned) return;
   for (const expr of normaliseExpressionParts(source)) {
-    const sourceFile = ts13.createSourceFile(
+    const sourceFile = ts14.createSourceFile(
       "p.ts",
       expr,
-      ts13.ScriptTarget.Latest,
+      ts14.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts13.ScriptKind.TS
+      ts14.ScriptKind.TS
     );
     visit2(sourceFile, propNames, out);
   }
@@ -15789,15 +15927,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, kind2, propNames, out) {
-  if (!ts13.isIdentifier(receiver)) return;
+  if (!ts14.isIdentifier(receiver)) return;
   const name2 = receiver.text;
   if (!propNames.has(name2)) return;
   let kinds = out.get(name2);
@@ -15858,43 +15996,43 @@ var init_compute_prop_usage = __esm({
 });
 
 // ../jsx/src/value-references.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function isValueReferenceIdentifier(id2) {
   const parent2 = id2.parent;
   if (!parent2) return false;
-  if (ts14.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isPropertyAssignment(parent2) && parent2.name === id2) return false;
-  if ((ts14.isMethodDeclaration(parent2) || ts14.isGetAccessorDeclaration(parent2) || ts14.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
+  if (ts15.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isPropertyAssignment(parent2) && parent2.name === id2) return false;
+  if ((ts15.isMethodDeclaration(parent2) || ts15.isGetAccessorDeclaration(parent2) || ts15.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
     return false;
   }
-  if (ts14.isPropertyDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isMetaProperty(parent2) && parent2.name === id2) return false;
-  if (ts14.isVariableDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isFunctionExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isClassDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isClassExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isParameter(parent2) && parent2.name === id2) return false;
-  if (ts14.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isLabeledStatement(parent2) && parent2.label === id2) return false;
-  if (ts14.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
-  if (ts14.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isImportClause(parent2) && parent2.name === id2) return false;
-  if (ts14.isNamespaceImport(parent2) && parent2.name === id2) return false;
-  if (ts14.isQualifiedName(parent2) && parent2.right === id2) return false;
+  if (ts15.isPropertyDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isMetaProperty(parent2) && parent2.name === id2) return false;
+  if (ts15.isVariableDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isFunctionExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isClassDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isClassExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isParameter(parent2) && parent2.name === id2) return false;
+  if (ts15.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isLabeledStatement(parent2) && parent2.label === id2) return false;
+  if (ts15.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
+  if (ts15.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isImportClause(parent2) && parent2.name === id2) return false;
+  if (ts15.isNamespaceImport(parent2) && parent2.name === id2) return false;
+  if (ts15.isQualifiedName(parent2) && parent2.right === id2) return false;
   return true;
 }
 function collectValueReferencedNames(code) {
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile(
+    sourceFile = ts15.createSourceFile(
       "generated.js",
       code,
-      ts14.ScriptTarget.Latest,
+      ts15.ScriptTarget.Latest,
       /*setParentNodes*/
       true,
-      ts14.ScriptKind.JS
+      ts15.ScriptKind.JS
     );
   } catch {
     return null;
@@ -15903,10 +16041,10 @@ function collectValueReferencedNames(code) {
   if (diagnostics && diagnostics.length > 0) return null;
   const names = /* @__PURE__ */ 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;
@@ -15921,7 +16059,7 @@ var init_value_references = __esm({
 function detectUsedImports(code) {
   const used = /* @__PURE__ */ new Set();
   for (const name2 of RUNTIME_IMPORT_CANDIDATES) {
-    if (new RegExp(`\\b${name2}\\s*\\(`).test(code)) {
+    if (identifierCallPattern(name2).test(code)) {
       used.add(name2);
     }
   }
@@ -16021,6 +16159,7 @@ var init_imports = __esm({
     "use strict";
     init_builtins();
     init_value_references();
+    init_identifier_pattern();
     RUNTIME_IMPORT_CANDIDATES = [
       "createSignal",
       "createMemo",
@@ -16138,23 +16277,23 @@ var init_lowering_registry = __esm({
 });
 
 // ../jsx/src/relocate.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 function classify(name2, env) {
   return env.bindings.get(name2) ?? "global";
 }
 function collectFreeRefs(node) {
   const refs = /* @__PURE__ */ new Map();
   function visit3(n, parent2) {
-    if (ts15.isIdentifier(n)) {
-      if (parent2 && ts15.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts15.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && ts15.isShorthandPropertyAssignment(parent2) && parent2.name === n) return;
+    if (ts16.isIdentifier(n)) {
+      if (parent2 && ts16.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts16.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && ts16.isShorthandPropertyAssignment(parent2) && parent2.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;
@@ -16256,9 +16395,9 @@ function isInlinableInTemplate(value2, env) {
   return { ok: true, rewrittenValue: r2.text, decisions: r2.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts15.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
-  if (ts15.isIdentifier(callee)) return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
+  if (ts16.isIdentifier(callee)) return callee.text;
+  if (ts16.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null) return null;
     return `${left}.${callee.name.text}`;
@@ -16266,9 +16405,9 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts15.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts15.isIdentifier(callee)) return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
+  if (ts16.isIdentifier(callee)) return callee.text;
+  if (ts16.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -16307,17 +16446,17 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts15.createSourceFile(
+    const sf = ts16.createSourceFile(
       "__inline_check__.ts",
       `(${text});`,
-      ts15.ScriptTarget.Latest,
+      ts16.ScriptTarget.Latest,
       false,
-      ts15.ScriptKind.TS
+      ts16.ScriptKind.TS
     );
     const stmt = sf.statements[0];
-    if (!stmt || !ts15.isExpressionStatement(stmt)) return null;
+    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;
   }
@@ -16331,8 +16470,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   let found = false;
   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 args2 = n.arguments;
         if (args2) {
@@ -16345,7 +16484,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16354,13 +16493,13 @@ function hasZeroArgCall(node, env) {
   let found = false;
   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;
@@ -16369,25 +16508,25 @@ function containsAnyIdentifier(node, names) {
   let found = false;
   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;
@@ -16395,7 +16534,7 @@ function containsAnyIdentifier(node, names) {
 function scanRefsByName(text, bindings) {
   const result2 = /* @__PURE__ */ new Map();
   for (const name2 of bindings.keys()) {
-    const re = new RegExp(`\\b${name2}\\b`);
+    const re = identifierPattern(name2);
     if (re.test(text)) result2.set(name2, []);
   }
   return result2;
@@ -16488,6 +16627,7 @@ var init_relocate = __esm({
     init_props_binding();
     init_expression_parser();
     init_lowering_registry();
+    init_identifier_pattern();
     REGISTRY_SAFE_BINDING_KINDS = /* @__PURE__ */ new Set([
       "global",
       "module-import",
@@ -17716,19 +17856,19 @@ var init_emit_module_level = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function propExtractionName(stmt) {
-  if (!ts16.isVariableStatement(stmt)) return null;
+  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) return null;
+  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)) return null;
-  if (!ts16.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM) return null;
+  if (!ts17.isPropertyAccessExpression(core)) return null;
+  if (!ts17.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM) return null;
   if (core.name.text !== decl.name.text) return null;
   return decl.name.text;
 }
@@ -17739,17 +17879,17 @@ function pruneUnusedPropExtractions(code) {
       console.warn("[barefootjs] pruneUnusedPropExtractions: generated code did not parse; skipping prune");
       return code;
     }
-    const sourceFile = ts16.createSourceFile(
+    const sourceFile = ts17.createSourceFile(
       "generated.js",
       code,
-      ts16.ScriptTarget.Latest,
+      ts17.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts16.ScriptKind.JS
+      ts17.ScriptKind.JS
     );
     const spans = [];
     for (const stmt of sourceFile.statements) {
-      if (!ts16.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body) continue;
+      if (!ts17.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body) continue;
       for (const inner of stmt.body.statements) {
         const name2 = propExtractionName(inner);
         if (name2 !== null && !referenced.has(name2)) {
@@ -18794,7 +18934,8 @@ function buildReactiveEffectsPlan(args2) {
         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 }
       });
     }
   }
@@ -19242,7 +19383,7 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
 function buildKeyedOrIndexLookup(args2) {
   const hasBindings = (args2.paramBindings?.length ?? 0) > 0;
   if (args2.key !== null) {
-    const keyWithItem = hasBindings ? substituteLoopBindings(args2.key, args2.paramBindings, "item") : args2.key.replace(new RegExp(`\\b${args2.param}\\b`, "g"), "item");
+    const keyWithItem = hasBindings ? substituteLoopBindings(args2.key, args2.paramBindings, "item") : args2.key.replace(identifierPattern(args2.param, "g"), "item");
     return {
       kind: "keyed",
       arrayExpr: args2.array,
@@ -19269,6 +19410,7 @@ var init_build_event_delegation = __esm({
   "../jsx/src/ir-to-client-js/control-flow/plan/build-event-delegation.ts"() {
     "use strict";
     init_utils();
+    init_identifier_pattern();
     init_html_template();
   }
 });
@@ -19327,7 +19469,7 @@ var init_lazy_conditional = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   if (!preamble) return NO_PREAMBLE;
   if (preamble.builderNames.length > 0) {
@@ -19339,19 +19481,19 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   const text = preambleAnalysisText(preamble);
   if (text.trim().length === 0) return NO_PREAMBLE;
   const declaredNames = /* @__PURE__ */ new Set();
-  const sf = ts17.createSourceFile(
+  const sf = ts18.createSourceFile(
     "__lazy_preamble__.ts",
     text,
-    ts17.ScriptTarget.Latest,
+    ts18.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts17.ScriptKind.TS
+    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) {
       collectBindingNames3(decl.name, declaredNames);
@@ -19378,12 +19520,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   return { lazySafe: true, facts: { declaredNames, freeNames } };
 }
 function collectBindingNames3(name2, out) {
-  if (ts17.isIdentifier(name2)) {
+  if (ts18.isIdentifier(name2)) {
     out.add(name2.text);
     return;
   }
   for (const element of name2.elements) {
-    if (ts17.isOmittedExpression(element)) continue;
+    if (ts18.isOmittedExpression(element)) continue;
     collectBindingNames3(element.name, out);
   }
 }
@@ -19391,56 +19533,56 @@ function findImpureNode(root2, primableNames) {
   let found = null;
   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 === void 0;
+      const isSignalRead = ts18.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === void 0;
       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(root2);
   return found;
 }
-function isAssignmentOperator(kind2) {
-  return kind2 >= ts17.SyntaxKind.FirstAssignment && kind2 <= ts17.SyntaxKind.LastAssignment;
+function isAssignmentOperator2(kind2) {
+  return kind2 >= ts18.SyntaxKind.FirstAssignment && kind2 <= ts18.SyntaxKind.LastAssignment;
 }
 var NO_PREAMBLE, NO2;
 var init_lazy_preamble = __esm({
@@ -20038,7 +20180,7 @@ var init_claim_plan = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function bindingIdArg(ctx2, slotId) {
   if (!ctx2.profile || !slotId) return "";
   return `, ${JSON.stringify(`${ctx2.componentName}#binding:${slotId}`)}`;
@@ -20119,19 +20261,19 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
   if (!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)) return expr;
-  const root2 = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return expr;
+  const root2 = 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(root2);
   if (candidates.length === 0) return expr;
@@ -20168,19 +20310,19 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
   if (!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)) return expr;
-  const root2 = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return expr;
+  const root2 = 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(root2);
   if (candidates.length === 0) return expr;
@@ -20538,7 +20680,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
     );
   }
   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) {
@@ -20636,9 +20778,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);
@@ -21558,7 +21701,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})`);
   }
@@ -21619,6 +21762,7 @@ var init_event_delegation = __esm({
     "use strict";
     init_utils();
     init_csr_substitute();
+    init_identifier_pattern();
     NON_BUBBLING_EVENTS = /* @__PURE__ */ new Set([
       "blur",
       "focus",
@@ -22363,25 +22507,25 @@ var init_phases = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM) return code;
-  if (!new RegExp(`\\b${srcPropsName}\\b`).test(code)) return code;
-  const sourceFile = ts19.createSourceFile(
+  if (!identifierPattern(srcPropsName).test(code)) return code;
+  const sourceFile = ts20.createSourceFile(
     "init-body.ts",
     code,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts19.ScriptKind.TS
+    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) return code;
@@ -22395,18 +22539,19 @@ function rewritePropsObjectRef(code, propsObjectName) {
 function shouldRewrite(node) {
   const parent2 = node.parent;
   if (!parent2) return true;
-  if (ts19.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts19.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertySignature(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertyDeclaration(parent2) && parent2.name === node) return false;
-  if (ts19.isBindingElement(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts20.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertySignature(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyDeclaration(parent2) && parent2.name === node) return false;
+  if (ts20.isBindingElement(parent2) && parent2.name === node) return false;
   return true;
 }
 var init_rewrite_props_object = __esm({
   "../jsx/src/ir-to-client-js/rewrite-props-object.ts"() {
     "use strict";
     init_utils();
+    init_identifier_pattern();
   }
 });
 
@@ -23106,7 +23251,7 @@ var init_css_layer_prefixer = __esm({
 });
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function preprocessInlineJsxCallbacks(source, filePath) {
   const errors = [];
   const syntheticNames = [];
@@ -23126,15 +23271,15 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts20.createSourceFile(
+  const sourceFile = ts21.createSourceFile(
     filePath,
     source,
-    ts20.ScriptTarget.Latest,
+    ts21.ScriptTarget.Latest,
     true,
-    ts20.ScriptKind.TSX
+    ts21.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'")
+    (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 };
@@ -23157,20 +23302,20 @@ 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)) expr = expr.expression;
-    if (ts20.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    while (ts21.isParenthesizedExpression(expr)) expr = expr.expression;
+    if (ts21.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -23205,7 +23350,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name2 });
     return true;
   }
-  ts20.forEachChild(sourceFile, visit3);
+  ts21.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -23224,33 +23369,33 @@ 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 body2 = arrow.body;
-  while (ts20.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts21.isParenthesizedExpression(body2)) body2 = body2.expression;
   return isJsxLike(body2);
 }
 function blockReturnsJsx(block) {
   let found = false;
   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)) e = e.expression;
+      while (ts21.isParenthesizedExpression(e)) e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts20.isArrowFunction(n) || ts20.isFunctionDeclaration(n) || ts20.isFunctionExpression(n)) return;
-    ts20.forEachChild(n, visit3);
+    if (ts21.isArrowFunction(n) || ts21.isFunctionDeclaration(n) || ts21.isFunctionExpression(n)) return;
+    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 = /* @__PURE__ */ new Set();
@@ -23259,13 +23404,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames4(name2, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts20.isIdentifier(name2)) {
+  if (ts21.isIdentifier(name2)) {
     push(name2.text);
-  } else if (ts20.isObjectBindingPattern(name2)) {
+  } else if (ts21.isObjectBindingPattern(name2)) {
     name2.elements.forEach((el) => collectBindingNames4(el.name, out));
-  } else if (ts20.isArrayBindingPattern(name2)) {
+  } else if (ts21.isArrayBindingPattern(name2)) {
     name2.elements.forEach((el) => {
-      if (!ts20.isOmittedExpression(el)) collectBindingNames4(el.name, out);
+      if (!ts21.isOmittedExpression(el)) collectBindingNames4(el.name, out);
     });
   }
 }
@@ -23290,71 +23435,71 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name2);
   }
   function visit3(node) {
-    if (ts20.isIdentifier(node)) {
+    if (ts21.isIdentifier(node)) {
       const parent2 = node.parent;
-      if (parent2 && ts20.isPropertyAccessExpression(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertyAssignment(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertySignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertyDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isMethodDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isMethodSignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isEnumMember(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isBindingElement(parent2) && parent2.propertyName === node) return;
-      if (parent2 && ts20.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
+      if (parent2 && ts21.isPropertyAccessExpression(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertyAssignment(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertySignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertyDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isMethodDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isMethodSignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isEnumMember(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isBindingElement(parent2) && parent2.propertyName === node) return;
+      if (parent2 && ts21.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
         if (!isBound(node.text)) ids.add(node.text);
         return;
       }
-      if (parent2 && ts20.isParameter(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isVariableDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isFunctionDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isClassDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isJsxAttribute(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isJsxOpeningElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts21.isParameter(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isVariableDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isFunctionDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isClassDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isJsxAttribute(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isJsxOpeningElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
-      if (parent2 && ts20.isJsxClosingElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts21.isJsxClosingElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
       if (isBound(node.text)) return;
       ids.add(node.text);
       return;
     }
-    if (ts20.isVariableDeclaration(node)) {
+    if (ts21.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer) visit3(node.initializer);
       declared;
       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;
@@ -23374,27 +23519,27 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = /* @__PURE__ */ new Set();
   for (const stmt of sourceFile.statements) {
-    if (ts20.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts20.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts20.isVariableStatement(stmt)) {
+    if (ts21.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts21.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    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)) names.add(ic.namedBindings.name.text);
+        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)) names.add(stmt.name.text);
-    else if (ts20.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts20.isEnumDeclaration(stmt)) names.add(stmt.name.text);
+    } else if (ts21.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts21.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts21.isEnumDeclaration(stmt)) names.add(stmt.name.text);
   }
   return names;
 }
 function buildSyntheticDeclaration(name2, 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);
@@ -23413,7 +23558,7 @@ var init_preprocess_inline_jsx_callbacks = __esm({
 });
 
 // ../jsx/src/ssr-defaults.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function deriveStashFromDefaults(defaults, props) {
   const extra = {};
   for (const [name2, d] of Object.entries(defaults)) {
@@ -23493,11 +23638,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   const node = parseExpression2(expr);
   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);
 }
@@ -23514,21 +23659,21 @@ function tryStaticEval(expr, ctx2) {
 }
 function evalStatementsForReturn(statements, ctx2) {
   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) continue;
+        if (!ts22.isIdentifier(d.name) || !d.initializer) continue;
         const v = evalNode(d.initializer, ctx2);
         if (v !== UNRESOLVED) ctx2.bindings[d.name.text] = v;
       }
-    } else if (ts21.isReturnStatement(stmt)) {
+    } else if (ts22.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx2) : UNRESOLVED;
-    } else if (ts21.isIfStatement(stmt)) {
+    } else if (ts22.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx2);
       if (cond === UNRESOLVED) return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
         const taken = evalStatementsForReturn(
-          ts21.isBlock(branch) ? branch.statements : [branch],
+          ts22.isBlock(branch) ? branch.statements : [branch],
           ctx2
         );
         if (taken !== NO_RETURN) return taken;
@@ -23540,64 +23685,64 @@ function evalStatementsForReturn(statements, ctx2) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts21.createSourceFile(
+  const sf = ts22.createSourceFile(
     "__ssr_default__.ts",
     `(${expr})`,
-    ts21.ScriptTarget.Latest,
+    ts22.ScriptTarget.Latest,
     false,
-    ts21.ScriptKind.TS
+    ts22.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt)) return null;
-  const inner = ts21.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts22.isExpressionStatement(stmt)) return null;
+  const inner = ts22.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx2) {
-  if (ts21.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isAsExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isArrowFunction(node)) {
+  if (ts22.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isAsExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isArrowFunction(node)) {
     if (node.parameters.length !== 0) return UNRESOLVED;
-    if (!ts21.isBlock(node.body)) return evalNode(node.body, ctx2);
+    if (!ts22.isBlock(node.body)) return evalNode(node.body, ctx2);
     const localBindings = { ...ctx2.bindings };
     const localCtx = { ...ctx2, bindings: localBindings };
     const result2 = evalStatementsForReturn(node.body.statements, localCtx);
     return result2 === NO_RETURN ? UNRESOLVED : result2;
   }
-  if (ts21.isNumericLiteral(node)) return Number(node.text);
-  if (ts21.isStringLiteralLike(node)) return node.text;
-  if (node.kind === ts21.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === ts21.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === ts21.SyntaxKind.NullKeyword) return null;
-  if (ts21.isIdentifier(node)) {
+  if (ts22.isNumericLiteral(node)) return Number(node.text);
+  if (ts22.isStringLiteralLike(node)) return node.text;
+  if (node.kind === ts22.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts22.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts22.SyntaxKind.NullKeyword) return null;
+  if (ts22.isIdentifier(node)) {
     if (node.text === "undefined") return void 0;
     if (node.text in ctx2.bindings) return ctx2.bindings[node.text];
     if (ctx2.propsLike.has(node.text)) return void 0;
     return UNRESOLVED;
   }
-  if (ts21.isPrefixUnaryExpression(node)) {
+  if (ts22.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx2);
     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)) return UNRESOLVED;
+      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;
@@ -23608,17 +23753,17 @@ function evalNode(node, ctx2) {
     }
     return obj;
   }
-  if (ts21.isArrayLiteralExpression(node)) {
+  if (ts22.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts21.isOmittedExpression(elem)) return UNRESOLVED;
+      if (ts22.isOmittedExpression(elem)) return UNRESOLVED;
       const v = evalNode(elem, ctx2);
       if (v === UNRESOLVED) return UNRESOLVED;
       arr.push(v === void 0 ? null : v);
     }
     return arr;
   }
-  if (ts21.isElementAccessExpression(node)) {
+  if (ts22.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx2);
     if (base === void 0) return void 0;
     if (base === UNRESOLVED || base === null || typeof base !== "object") return UNRESOLVED;
@@ -23628,16 +23773,16 @@ function evalNode(node, ctx2) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : void 0;
   }
-  if (ts21.isPropertyAccessExpression(node)) {
+  if (ts22.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx2);
     if (baseResult === void 0) return void 0;
     return UNRESOLVED;
   }
-  if (ts21.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts21.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
+  if (ts22.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts22.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
       return ctx2.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, ctx2);
       if (Array.isArray(recv)) {
         let sep = ",";
@@ -23652,24 +23797,24 @@ function evalNode(node, ctx2) {
     }
     return UNRESOLVED;
   }
-  if (ts21.isConditionalExpression(node)) {
+  if (ts22.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx2);
     if (cond === UNRESOLVED) return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx2) : evalNode(node.whenFalse, ctx2);
   }
-  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, ctx2);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== void 0) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts21.SyntaxKind.BarBarToken) {
+    if (op === ts22.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts21.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts22.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 === UNRESOLVED) return UNRESOLVED;
       if (!l2) return l2;
@@ -23679,28 +23824,28 @@ function evalNode(node, ctx2) {
     const r2 = evalNode(node.right, ctx2);
     if (l === UNRESOLVED || r2 === UNRESOLVED) return UNRESOLVED;
     switch (op) {
-      case ts21.SyntaxKind.PlusToken:
+      case ts22.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r2 === "string") return `${l}${r2}`;
         if (typeof l === "number" && typeof r2 === "number") return l + r2;
         return UNRESOLVED;
-      case ts21.SyntaxKind.MinusToken:
+      case ts22.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r2 === "number" ? l - r2 : UNRESOLVED;
-      case ts21.SyntaxKind.AsteriskToken:
+      case ts22.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r2 === "number" ? l * r2 : UNRESOLVED;
-      case ts21.SyntaxKind.SlashToken:
+      case ts22.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l / r2 : UNRESOLVED;
-      case ts21.SyntaxKind.PercentToken:
+      case ts22.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l % r2 : UNRESOLVED;
-      case ts21.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts21.SyntaxKind.EqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsToken:
         return l === r2;
-      case ts21.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts21.SyntaxKind.ExclamationEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsToken:
         return l !== r2;
     }
     return UNRESOLVED;
   }
-  if (ts21.isTemplateExpression(node)) {
+  if (ts22.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0) return node.head.text;
     let acc = node.head.text;
     for (const span of node.templateSpans) {
@@ -23710,7 +23855,7 @@ function evalNode(node, ctx2) {
     }
     return acc;
   }
-  if (ts21.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts22.isNoSubstitutionTemplateLiteral(node)) return node.text;
   return UNRESOLVED;
 }
 var UNRESOLVED, NO_RETURN;
@@ -23723,7 +23868,7 @@ var init_ssr_defaults = __esm({
 });
 
 // ../jsx/src/augment-inherited-props.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = /* @__PURE__ */ new Map();
@@ -23750,35 +23895,35 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr)) return null;
-  if (!ts22.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
+  if (!expr || !ts23.isCallExpression(expr)) return null;
+  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)) return null;
+  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)) return arg.text;
-  if (ts22.isNumericLiteral(arg)) return Number(arg.text);
-  if (arg.kind === ts22.SyntaxKind.TrueKeyword) return true;
-  if (arg.kind === ts22.SyntaxKind.FalseKeyword) return false;
+  if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
+  if (ts23.isNumericLiteral(arg)) return Number(arg.text);
+  if (arg.kind === ts23.SyntaxKind.TrueKeyword) return true;
+  if (arg.kind === ts23.SyntaxKind.FalseKeyword) return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr)) return false;
+  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)) return null;
+  if (!stmt || !ts23.isExpressionStatement(stmt)) return null;
   let e = stmt.expression;
-  while (ts22.isParenthesizedExpression(e)) e = e.expression;
+  while (ts23.isParenthesizedExpression(e)) e = e.expression;
   return e;
 }
 function augmentInheritedPropAccesses(ir) {
@@ -23799,21 +23944,21 @@ function augmentInheritedPropAccesses(ir) {
   const coalesceLiteralTypes = /* @__PURE__ */ new Map();
   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)) left = left.expression;
-        if (ts22.isPropertyAccessExpression(left) && ts22.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        while (ts23.isParenthesizedExpression(left)) left = left.expression;
+        if (ts23.isPropertyAccessExpression(left) && ts23.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name2 = left.name.text;
           let right = n.right;
-          while (ts22.isParenthesizedExpression(right)) right = right.expression;
-          if (ts22.isPrefixUnaryExpression(right)) right = right.operand;
-          const kind2 = ts22.isNumericLiteral(right) ? "number" : right.kind === ts22.SyntaxKind.TrueKeyword || right.kind === ts22.SyntaxKind.FalseKeyword ? "boolean" : ts22.isStringLiteralLike(right) ? "string" : null;
+          while (ts23.isParenthesizedExpression(right)) right = right.expression;
+          if (ts23.isPrefixUnaryExpression(right)) right = right.operand;
+          const kind2 = ts23.isNumericLiteral(right) ? "number" : right.kind === ts23.SyntaxKind.TrueKeyword || right.kind === ts23.SyntaxKind.FalseKeyword ? "boolean" : ts23.isStringLiteralLike(right) ? "string" : null;
           if (kind2 && !coalesceLiteralTypes.has(name2)) coalesceLiteralTypes.set(name2, kind2);
         }
       }
-      ts22.forEachChild(n, visit3);
+      ts23.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -23909,39 +24054,39 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init)) init = init.expression;
+  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 sf = ts23.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init)) init = init.expression;
-  if (!init || !ts22.isTemplateExpression(init)) return null;
+  while (init && ts23.isParenthesizedExpression(init)) init = init.expression;
+  if (!init || !ts23.isTemplateExpression(init)) return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts22.isIdentifier(span.expression)) return null;
+    if (!ts23.isIdentifier(span.expression)) return null;
     const value2 = resolved.get(span.expression.text);
     if (value2 === void 0) return null;
     out += value2 + span.literal.text;
@@ -23967,31 +24112,32 @@ 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 === void 0) return null;
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt)) return null;
+  if (!ts23.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed)) return null;
+  while (ts23.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts23.isObjectLiteralExpression(parsed)) return null;
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop)) continue;
+    if (!ts23.isPropertyAssignment(prop)) continue;
     const name2 = prop.name;
-    const propKey = ts22.isIdentifier(name2) || ts22.isStringLiteral(name2) || ts22.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
+    const propKey = ts23.isIdentifier(name2) || ts23.isStringLiteral(name2) || ts23.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
     if (propKey !== key) continue;
     let v = prop.initializer;
-    while (ts22.isParenthesizedExpression(v)) v = v.expression;
-    if (ts22.isNumericLiteral(v)) return { kind: "number", text: v.text };
-    if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    while (ts23.isParenthesizedExpression(v)) v = v.expression;
+    if (ts23.isNumericLiteral(v)) return { kind: "number", text: v.text };
+    if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -23999,27 +24145,27 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__join.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts22.isParenthesizedExpression(node)) node = node.expression;
-  if (!node || !ts22.isCallExpression(node)) return null;
+  while (node && ts23.isParenthesizedExpression(node)) node = node.expression;
+  if (!node || !ts23.isCallExpression(node)) return null;
   const callee = node.expression;
-  if (!ts22.isPropertyAccessExpression(callee)) return null;
+  if (!ts23.isPropertyAccessExpression(callee)) return null;
   if (callee.name.text !== "join") return null;
   let recv = callee.expression;
-  while (ts22.isParenthesizedExpression(recv)) recv = recv.expression;
-  if (!ts22.isArrayLiteralExpression(recv)) return null;
+  while (ts23.isParenthesizedExpression(recv)) recv = recv.expression;
+  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;
@@ -24028,16 +24174,16 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
+    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
     else return null;
   }
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts22.isElementAccessExpression(val)) return null;
+  if (!ts23.isElementAccessExpression(val)) return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts22.isIdentifier(obj) || !ts22.isIdentifier(arg)) return null;
+  if (!ts23.isIdentifier(obj) || !ts23.isIdentifier(arg)) return null;
   let indexPropName;
   let defaultKey;
   const resolved = resolveKey?.(arg.text);
@@ -24051,35 +24197,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   }
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /* setParentNodes */
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt)) return null;
+  if (!ts23.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed)) return null;
+  while (ts23.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts23.isObjectLiteralExpression(parsed)) return null;
   const entries2 = [];
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop)) return null;
+    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)) v = v.expression;
-    if (ts22.isNumericLiteral(v)) {
+    while (ts23.isParenthesizedExpression(v)) v = v.expression;
+    if (ts23.isNumericLiteral(v)) {
       entries2.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       entries2.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -24351,7 +24497,7 @@ var init_rich_type_refusal = __esm({
 });
 
 // ../jsx/src/compiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function mergeTemplateImports(lines) {
   const result2 = [];
   const valueIdx = /* @__PURE__ */ new Map();
@@ -24416,12 +24562,12 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   if (entries2.some((e) => e.componentIR.metadata.isClientComponent)) {
     const topLevelNames = /* @__PURE__ */ 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) topLevelNames.add(stmt.name.text);
-        else if (ts23.isVariableStatement(stmt)) {
+        if (ts24.isFunctionDeclaration(stmt) && stmt.name) topLevelNames.add(stmt.name.text);
+        else if (ts24.isVariableStatement(stmt)) {
           for (const d of stmt.declarationList.declarations) {
-            if (ts23.isIdentifier(d.name)) topLevelNames.add(d.name.text);
+            if (ts24.isIdentifier(d.name)) topLevelNames.add(d.name.text);
           }
         }
       }
@@ -24482,13 +24628,13 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   const moduleStatementSeen = /* @__PURE__ */ new Set();
   const moduleStatementsOrdered = [];
   const collectModuleStatements = (block) => {
-    const sf = ts23.createSourceFile(
+    const sf = ts24.createSourceFile(
       "__bf_module_decls.tsx",
       block,
-      ts23.ScriptTarget.Latest,
+      ts24.ScriptTarget.Latest,
       /* setParentNodes */
       false,
-      ts23.ScriptKind.TSX
+      ts24.ScriptKind.TSX
     );
     for (const stmt of sf.statements) {
       const text = stmt.getText(sf);
@@ -24720,6 +24866,11 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   }
   return { files: files2, 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(ctx2) {
   const metadata = {
     componentName: ctx2.componentName || "Unknown",
@@ -24728,6 +24879,7 @@ function buildMetadata(ctx2) {
     isClientComponent: ctx2.hasUseClientDirective,
     typeDefinitions: ctx2.typeDefinitions,
     propsType: ctx2.propsType,
+    typeParameters: componentTypeParametersText(ctx2.componentNode, ctx2.sourceFile),
     propsParams: ctx2.propsParams,
     propsObjectName: ctx2.propsObjectName,
     restPropsName: ctx2.restPropsName,
@@ -24953,7 +25105,7 @@ var init_compiler = __esm({
 });
 
 // ../jsx/src/shared-program.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 import path6 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0) return process.cwd();
@@ -24971,10 +25123,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files2, options2 = {}) {
   const baseUrl = options2.baseUrl ?? commonParent(files2);
   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,
@@ -24984,7 +25136,7 @@ function createProgramForCorpus(files2, options2 = {}) {
     ...options2.compilerOptions
   };
   const absolute = files2.map((f) => path6.resolve(f));
-  return ts24.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
+  return ts25.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
 }
 var init_shared_program = __esm({
   "../jsx/src/shared-program.ts"() {
@@ -25020,6 +25172,7 @@ var init_jsx_adapter = __esm({
     init_env_signal();
     init_module_exports();
     init_csr_substitute();
+    init_identifier_pattern();
     JsxAdapter = class extends BaseAdapter {
       componentName = "";
       /**
@@ -25083,7 +25236,13 @@ var init_jsx_adapter = __esm({
           ...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((name2) => {
           const func = localFunctions.find((f) => f.name === name2);
           if (func) return func.body;
@@ -25111,9 +25270,12 @@ var init_jsx_adapter = __esm({
             lines.push(`  const ${signal2.getter} = () => ${initialValue}`);
           }
           if (signal2.setter) {
-            const setterUsed = new RegExp(`\\b${signal2.setter}\\b`).test(setterRefText);
+            const setterUsed = identifierPattern(signal2.setter).test(setterRefText);
             if (setterUsed) {
-              lines.push(`  const ${signal2.setter} = (..._args: any[]) => {}`);
+              const setterType = preserveTypes && signal2.type.kind !== "unknown" ? `(valueOrFn: ${signal2.type.raw} | ((prev: ${signal2.type.raw}) => ${signal2.type.raw})) => void` : null;
+              lines.push(
+                setterType ? `  const ${signal2.setter}: ${setterType} = () => {}` : `  const ${signal2.setter} = (..._args: any[]) => {}`
+              );
             }
           }
         }
@@ -25380,6 +25542,7 @@ var init_jsx_adapter = __esm({
 });
 
 // ../jsx/src/adapters/template-imports.ts
+import ts26 from "typescript";
 function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
   const remap = (imp) => {
     if (!rewriteRelative || !imp.source.startsWith(".")) return imp;
@@ -25421,6 +25584,48 @@ 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,
+    /* setParentNodes */
+    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(),
+      // Re-quote rather than reusing the original delimiters: a rewritten
+      // POSIX-relative path never contains a quote to escape.
+      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;
+}
 var CLIENT_PACKAGE_SOURCES;
 var init_template_imports = __esm({
   "../jsx/src/adapters/template-imports.ts"() {
@@ -25530,7 +25735,8 @@ export default ${this.componentName}` : "";
         const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
         const lines = [];
         const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
-        lines.push(`${exportPrefix}function ${name2}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+        const typeParameters = ir.metadata.typeParameters ?? "";
+        lines.push(`${exportPrefix}function ${name2}${typeParameters}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
         if (hasClientInteractivity) {
           lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name2}_\${Math.random().toString(36).slice(2, 8)}\``);
         } else {
@@ -26259,7 +26465,7 @@ var init_dangerous_inner_html = __esm({
 });
 
 // ../jsx/src/combine-client-js.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 function combineParentChildClientJs(files2) {
   const result2 = /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
@@ -26316,17 +26522,17 @@ function combineParentChildClientJs(files2) {
   return result2;
 }
 function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts25.createSourceFile(
+  const sourceFile = ts27.createSourceFile(
     "combine.js",
     content2,
-    ts25.ScriptTarget.Latest,
+    ts27.ScriptTarget.Latest,
     /*setParentNodes*/
     false,
-    ts25.ScriptKind.JS
+    ts27.ScriptKind.JS
   );
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts25.isImportDeclaration(stmt)) continue;
+    if (!ts27.isImportDeclaration(stmt)) continue;
     const start2 = stmt.getStart(sourceFile);
     const end2 = stmt.getEnd();
     importSpans.push([start2, end2]);
@@ -26334,8 +26540,8 @@ function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
     if (stmtText.includes("@bf-child:")) 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, /* @__PURE__ */ new Set());
       }
@@ -26510,7 +26716,7 @@ var init_loop_destructure = __esm({
 });
 
 // ../jsx/src/debug.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx2 = analyzeComponent(source, filePath, componentName);
   if (!ctx2.jsxReturn) {
@@ -26583,7 +26789,7 @@ function buildGraphFromIR(ir) {
     return propsObjectName ? exprReadsPropMember(expr, propsObjectName) : false;
   };
   const domBindings = [];
-  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, void 0, /* @__PURE__ */ new Set(), exprReadsProp);
+  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, void 0, BindingScope.EMPTY, exprReadsProp);
   const signalConsumers = /* @__PURE__ */ new Map();
   for (const s of meta.signals) signalConsumers.set(s.getter, []);
   for (const memo of meta.memos) {
@@ -27550,14 +27756,19 @@ function inferWrapReasonForAttrLike(hasStringReactive, hasPropsRef, flags) {
   const decision = decideWrapFromAstFlags(flags);
   return decision.wrap ? decision.reason : void 0;
 }
-function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, loopParams = /* @__PURE__ */ new Set(), readsProp = () => false) {
-  const exprReadsLoopParam = (n) => loopParams.size > 0 && (n.origin?.freeRefs?.some((r2) => loopParams.has(r2.name)) ?? false);
-  const attrReadsLoopParam = (free) => loopParams.size > 0 && free !== void 0 && [...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((r2) => boundNames.has(r2.name)) ?? false);
+  const attrReadsLoopParam = (free) => boundNames.size > 0 && free !== void 0 && 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) continue;
+        if (attr.name === "key" && boundNames.size > 0) continue;
         const expr = attrValueToString2(attr.value);
         if (!expr) continue;
         const deps = extractReactiveDeps(expr, signalGetters, memoNames);
@@ -27592,7 +27803,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;
     }
@@ -27619,7 +27830,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
     }
     case "conditional": {
       const decision = decideWrapFromAstFlags(node);
-      const loopReactive = loopParams.size > 0 && (node.origin?.freeRefs?.some((r2) => loopParams.has(r2.name)) ?? false);
+      const loopReactive = boundNames.size > 0 && (node.origin?.freeRefs?.some((r2) => boundNames.has(r2.name)) ?? false);
       if ((decision.wrap || loopReactive) && node.slotId) {
         const deps = extractReactiveDeps(node.condition, signalGetters, memoNames);
         bindings.push({
@@ -27635,14 +27846,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 !== void 0 && [...loopParams].some((p) => node.arrayFreeIdentifiers.has(p));
+        const loopReactive = boundNames.size > 0 && node.arrayFreeIdentifiers !== void 0 && setSomeIn(boundNames, node.arrayFreeIdentifiers);
         const isReactive = deps.length > 0 || node.callsReactiveGetters === true || loopReactive;
         const isFallback = !isReactive && node.hasFunctionCalls === true;
         if (isReactive || isFallback) {
@@ -27661,11 +27872,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;
     }
@@ -27695,21 +27904,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;
     }
@@ -27722,18 +27931,18 @@ 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;
   }
   let found = false;
   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;
@@ -27761,12 +27970,12 @@ function attrValueToString2(value2) {
 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);
     }
   }
@@ -27779,7 +27988,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);
     }
   }
@@ -27806,11 +28015,13 @@ var init_debug = __esm({
     init_ir_to_client_js();
     init_reactivity();
     init_utils();
+    init_identifier_pattern();
+    init_binding_scope();
   }
 });
 
 // ../jsx/src/profiler.ts
-import ts27 from "typescript";
+import ts29 from "typescript";
 function buildStaticBudget(source, filePath, componentName, options2 = {}) {
   const threshold = options2.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
   const program = createProgramForFile(source, filePath)?.program;
@@ -28065,14 +28276,14 @@ 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);
@@ -28358,19 +28569,19 @@ function assessBatchSafety(args2) {
   const signalGetters = new Set(args2.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts27.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts27.ScriptTarget.Latest, true);
+    sf = ts29.createSourceFile("__h.ts", `const __h = ${args2.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 name2 = node.expression.text;
       if (setters.has(name2)) calls.push({ pos: node.getStart(sf), kind: "write" });
       else if (D.has(name2) && node.arguments.length === 0) calls.push({ pos: node.getStart(sf), kind: "memoRead" });
       else if (!signalGetters.has(name2) && !memoNames.has(name2)) 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);
@@ -29175,6 +29386,7 @@ __export(src_exports, {
   resolveDangerousInnerHtml: () => resolveDangerousInnerHtml,
   resolveSetters: () => resolveSetters,
   resolveStaticLoopSource: () => resolveStaticLoopSource,
+  rewriteDynamicImportsInSource: () => rewriteDynamicImportsInSource,
   rewriteImportsForTemplate: () => rewriteImportsForTemplate,
   searchParamsLocalNames: () => searchParamsLocalNames,
   serializeParsedExpr: () => serializeParsedExpr,
@@ -110033,7 +110245,7 @@ __export(scenario_driver_exports, {
 import { writeFileSync as writeFileSync9, mkdtempSync, rmSync, readFileSync as readFileSync19, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
 import { join as join2, dirname as dirname4, resolve as resolve6 } from "node:path";
 import { tmpdir } from "node:os";
-import ts28 from "typescript";
+import ts30 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -110103,11 +110315,11 @@ function resolveLocalFile(spec) {
 }
 function rewriteLocalImports(js, chunkPath, inlined) {
   const chunkDir = dirname4(chunkPath);
-  const sf = ts28.createSourceFile("chunk.mjs", js, ts28.ScriptTarget.Latest, false, ts28.ScriptKind.JS);
+  const sf = ts30.createSourceFile("chunk.mjs", js, ts30.ScriptTarget.Latest, false, ts30.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts28.isImportDeclaration(stmt)) continue;
-    if (!ts28.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts30.isImportDeclaration(stmt)) continue;
+    if (!ts30.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -110119,13 +110331,13 @@ function rewriteLocalImports(js, chunkPath, inlined) {
     const abs = resolve6(resolved);
     if (inlined.has(abs)) {
       const clause = stmt.importClause;
-      if (clause && (clause.name || clause.namedBindings && ts28.isNamespaceImport(clause.namedBindings))) {
+      if (clause && (clause.name || clause.namedBindings && ts30.isNamespaceImport(clause.namedBindings))) {
         throw new Error(
           `"${spec}" (imported by ${chunkPath}) uses a default or namespace import of a sibling client file, which the dynamic scenario runner cannot bind after inlining that file into the run. Import its exports by name, or use the static budget (\`bf debug profile <component>\`), which needs no run.`
         );
       }
       const shims = [];
-      if (clause?.namedBindings && ts28.isNamedImports(clause.namedBindings)) {
+      if (clause?.namedBindings && ts30.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }