@barefootjs/cli 0.31.3 → 0.31.4

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.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/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",
@@ -9286,7 +9474,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 +9483,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);
       }
@@ -9321,6 +9509,7 @@ function extractFunctionParams(value2) {
 var init_module_exports = __esm({
   "../jsx/src/module-exports.ts"() {
     "use strict";
+    init_identifier_pattern();
   }
 });
 
@@ -9984,176 +10173,6 @@ 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";
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -10398,17 +10417,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) {
@@ -11180,7 +11199,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 +11234,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 +11276,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;
   };
@@ -13812,7 +13831,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 +13899,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;
       }
     }
   }
@@ -14104,6 +14123,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 +14133,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 +14186,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 +14216,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 +14417,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 +14429,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 +14449,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 +14460,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 +14485,8 @@ var init_reactivity = __esm({
     init_prop_handling();
     init_csr_substitute();
     init_walker();
+    init_binding_scope();
+    init_identifier_pattern();
   }
 });
 
@@ -14724,13 +14759,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 +14797,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
               ctx2,
               siblingOffsets,
               n.param,
-              n.paramBindings
+              n.paramBindings,
+              innerPreambleNames,
+              n.index
             ));
           }
         }
@@ -14944,7 +14981,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 +15233,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 +15319,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,7 +15352,7 @@ 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);
+      const expanded = expandConstantForReactivity(n.condition, ctx2, sourceFreeIds, scope);
       if (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");
@@ -15324,27 +15362,27 @@ 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),
+        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 }
       });
     }
   });
   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 +15430,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;
@@ -15407,6 +15445,7 @@ var init_collect_elements = __esm({
     init_prop_handling();
     init_walker();
     init_loop_chain();
+    init_identifier_pattern();
     EMPTY_RENDER_EXPRS = /* @__PURE__ */ new Set(["null", "undefined", "false", "''", '""', "``"]);
     branchInnerLoopOptions = {
       collectItemBindings: true,
@@ -15921,7 +15960,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 +16060,7 @@ var init_imports = __esm({
     "use strict";
     init_builtins();
     init_value_references();
+    init_identifier_pattern();
     RUNTIME_IMPORT_CANDIDATES = [
       "createSignal",
       "createMemo",
@@ -16395,7 +16435,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 +16528,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",
@@ -19242,7 +19283,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 +19310,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();
   }
 });
@@ -21558,7 +21600,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 +21661,7 @@ var init_event_delegation = __esm({
     "use strict";
     init_utils();
     init_csr_substitute();
+    init_identifier_pattern();
     NON_BUBBLING_EVENTS = /* @__PURE__ */ new Set([
       "blur",
       "focus",
@@ -22367,7 +22410,7 @@ import ts19 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;
+  if (!identifierPattern(srcPropsName).test(code)) return code;
   const sourceFile = ts19.createSourceFile(
     "init-body.ts",
     code,
@@ -22407,6 +22450,7 @@ var init_rewrite_props_object = __esm({
   "../jsx/src/ir-to-client-js/rewrite-props-object.ts"() {
     "use strict";
     init_utils();
+    init_identifier_pattern();
   }
 });
 
@@ -25020,6 +25064,7 @@ var init_jsx_adapter = __esm({
     init_env_signal();
     init_module_exports();
     init_csr_substitute();
+    init_identifier_pattern();
     JsxAdapter = class extends BaseAdapter {
       componentName = "";
       /**
@@ -25111,7 +25156,7 @@ 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[]) => {}`);
             }
@@ -25380,6 +25425,7 @@ var init_jsx_adapter = __esm({
 });
 
 // ../jsx/src/adapters/template-imports.ts
+import ts25 from "typescript";
 function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
   const remap = (imp) => {
     if (!rewriteRelative || !imp.source.startsWith(".")) return imp;
@@ -25421,6 +25467,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 = ts25.createSourceFile(
+    "bf-template-fragment.tsx",
+    sourceText,
+    ts25.ScriptTarget.Latest,
+    /* setParentNodes */
+    false,
+    ts25.ScriptKind.TSX
+  );
+  const edits = [];
+  const visit3 = (node) => {
+    if (ts25.isCallExpression(node) && node.expression.kind === ts25.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts25.isStringLiteralLike(node.arguments[0])) {
+      collect(node.arguments[0]);
+    }
+    if (ts25.isImportTypeNode(node) && ts25.isLiteralTypeNode(node.argument)) {
+      const literal = node.argument.literal;
+      if (ts25.isStringLiteralLike(literal)) collect(literal);
+    }
+    ts25.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}'`
+    });
+  };
+  ts25.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"() {
@@ -26259,7 +26347,7 @@ var init_dangerous_inner_html = __esm({
 });
 
 // ../jsx/src/combine-client-js.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 function combineParentChildClientJs(files2) {
   const result2 = /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
@@ -26316,17 +26404,17 @@ function combineParentChildClientJs(files2) {
   return result2;
 }
 function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts25.createSourceFile(
+  const sourceFile = ts26.createSourceFile(
     "combine.js",
     content2,
-    ts25.ScriptTarget.Latest,
+    ts26.ScriptTarget.Latest,
     /*setParentNodes*/
     false,
-    ts25.ScriptKind.JS
+    ts26.ScriptKind.JS
   );
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts25.isImportDeclaration(stmt)) continue;
+    if (!ts26.isImportDeclaration(stmt)) continue;
     const start2 = stmt.getStart(sourceFile);
     const end2 = stmt.getEnd();
     importSpans.push([start2, end2]);
@@ -26334,8 +26422,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 = ts26.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts26.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, /* @__PURE__ */ new Set());
       }
@@ -26510,7 +26598,7 @@ var init_loop_destructure = __esm({
 });
 
 // ../jsx/src/debug.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx2 = analyzeComponent(source, filePath, componentName);
   if (!ctx2.jsxReturn) {
@@ -27722,18 +27810,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 = ts27.createSourceFile("__attr.tsx", `(${expr})`, ts27.ScriptTarget.Latest, true, ts27.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 (ts27.isPropertyAccessExpression(n) && ts27.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts26.forEachChild(n, visit3);
+    ts27.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -27761,12 +27849,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 +27867,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 +27894,12 @@ var init_debug = __esm({
     init_ir_to_client_js();
     init_reactivity();
     init_utils();
+    init_identifier_pattern();
   }
 });
 
 // ../jsx/src/profiler.ts
-import ts27 from "typescript";
+import ts28 from "typescript";
 function buildStaticBudget(source, filePath, componentName, options2 = {}) {
   const threshold = options2.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
   const program = createProgramForFile(source, filePath)?.program;
@@ -28065,14 +28154,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 = ts28.createSourceFile(filePath, source, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts27.isCallExpression(node) && ts27.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts28.isCallExpression(node) && ts28.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);
+    ts28.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -28358,19 +28447,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 = ts28.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts28.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts27.isCallExpression(node) && ts27.isIdentifier(node.expression)) {
+    if (ts28.isCallExpression(node) && ts28.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);
+    ts28.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -29175,6 +29264,7 @@ __export(src_exports, {
   resolveDangerousInnerHtml: () => resolveDangerousInnerHtml,
   resolveSetters: () => resolveSetters,
   resolveStaticLoopSource: () => resolveStaticLoopSource,
+  rewriteDynamicImportsInSource: () => rewriteDynamicImportsInSource,
   rewriteImportsForTemplate: () => rewriteImportsForTemplate,
   searchParamsLocalNames: () => searchParamsLocalNames,
   serializeParsedExpr: () => serializeParsedExpr,
@@ -110033,7 +110123,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 ts29 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -110103,11 +110193,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 = ts29.createSourceFile("chunk.mjs", js, ts29.ScriptTarget.Latest, false, ts29.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts28.isImportDeclaration(stmt)) continue;
-    if (!ts28.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts29.isImportDeclaration(stmt)) continue;
+    if (!ts29.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -110119,13 +110209,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 && ts29.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 && ts29.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/cli",
-  "version": "0.31.3",
+  "version": "0.31.4",
   "description": "CLI for agent-driven UI component discovery and scaffolding",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,12 +30,12 @@
     "esbuild": "^0.25.0",
     "typescript": "^5.0.0",
     "vite": "^6.0.0",
-    "@barefootjs/client": "0.31.3",
-    "@barefootjs/shared": "0.31.3"
+    "@barefootjs/client": "0.31.4",
+    "@barefootjs/shared": "0.31.4"
   },
   "devDependencies": {
-    "@barefootjs/jsx": "0.31.3",
-    "@barefootjs/vite": "0.31.3",
+    "@barefootjs/jsx": "0.31.4",
+    "@barefootjs/vite": "0.31.4",
     "@happy-dom/global-registrator": "^20.0.11",
     "@types/node": "^22.0.0",
     "happy-dom": "^20.0.11"