@barefootjs/jsx 0.31.3 → 0.31.4

package/src/__tests__/identifier-pattern.test.ts

@@ -0,0 +1,170 @@
+/**
+ * #2592 — `$`-containing identifiers broke the compiler's
+ * `new RegExp(`\\b${name}\\b`)` "does this expression reference identifier
+ * X?" heuristic in two ways: an unescaped `$` acts as a regex end anchor
+ * (false negative anywhere but the very end of the pattern), and even once
+ * escaped, `\b` treats `$` as a non-word character, so it fails to find a
+ * boundary between e.g. `(` and a leading `$` (both non-word — no
+ * transition). See `../identifier-pattern.ts` for the fix.
+ */
+import { describe, test, expect } from 'bun:test'
+import { identifierPattern, identifierCallPattern } from '../identifier-pattern.ts'
+import { compileJSX } from '../compiler.ts'
+import { TestAdapter } from '../adapters/test-adapter.ts'
+
+describe('identifierPattern (#2592)', () => {
+  describe.each(['$item', 'item$', 'a$b', 'item'])('name = %p', (name) => {
+    test('matches a standalone parenthesized reference', () => {
+      expect(identifierPattern(name).test(`(${name})`)).toBe(true)
+    })
+
+    test('matches a reference after a binary operator', () => {
+      expect(identifierPattern(name).test(`x + ${name}`)).toBe(true)
+    })
+
+    test('matches as the base of a member-access expression', () => {
+      expect(identifierPattern(name).test(`${name}.foo`)).toBe(true)
+    })
+
+    test('does not match when it is a substring of a longer identifier (suffix)', () => {
+      expect(identifierPattern(name).test(`my${name}`)).toBe(false)
+    })
+
+    test('does not match when it is a substring of a longer identifier (prefix)', () => {
+      expect(identifierPattern(name).test(`${name}s`)).toBe(false)
+    })
+
+    test('does not match when it appears as a substring inside another identifier', () => {
+      // e.g. name="item" inside "xitem" / name="$item" inside "x$item"
+      expect(identifierPattern(name).test(`x${name}`)).toBe(false)
+    })
+  })
+
+  // Literal spellings from the issue, so the fixture reads without having
+  // to mentally substitute the parameterised %p name above.
+  test('$item: matches ($item), x + $item, $item.foo', () => {
+    const re = identifierPattern('$item')
+    expect(re.test('($item)')).toBe(true)
+    expect(re.test('x + $item')).toBe(true)
+    expect(re.test('$item.foo')).toBe(true)
+  })
+
+  test('$item: does not match my$item, $items, item$s, aitem, xitem', () => {
+    const re = identifierPattern('$item')
+    expect(re.test('my$item')).toBe(false)
+    expect(re.test('$items')).toBe(false)
+    expect(re.test('item$s')).toBe(false)
+    expect(re.test('aitem')).toBe(false)
+    expect(re.test('xitem')).toBe(false)
+  })
+
+  test('item (plain, no $) still matches only standalone references', () => {
+    const re = identifierPattern('item')
+    expect(re.test('(item)')).toBe(true)
+    expect(re.test('x + item')).toBe(true)
+    expect(re.test('item.foo')).toBe(true)
+    expect(re.test('my$item')).toBe(false)
+    expect(re.test('$items')).toBe(false)
+    expect(re.test('item$s')).toBe(false)
+    expect(re.test('aitem')).toBe(false)
+    expect(re.test('xitem')).toBe(false)
+  })
+
+  test('the `g` flag supports substitution scanning across multiple matches', () => {
+    const re = identifierPattern('$x', 'g')
+    expect('$x + $x'.replace(re, () => 'Y')).toBe('Y + Y')
+  })
+
+  test('regex-metacharacter identifiers are escaped, not interpreted', () => {
+    // Not a realistic JS identifier, but guards the escape step directly:
+    // an unescaped '.' would match any character.
+    const re = identifierPattern('a.b')
+    expect(re.test('a.b')).toBe(true)
+    expect(re.test('axb')).toBe(false)
+  })
+})
+
+describe('identifierCallPattern (#2592)', () => {
+  test('matches call syntax for a $-prefixed getter, with or without whitespace', () => {
+    expect(identifierCallPattern('$count').test('$count()')).toBe(true)
+    expect(identifierCallPattern('$count').test('$count ()')).toBe(true)
+    expect(identifierCallPattern('$count').test('1 + $count()')).toBe(true)
+  })
+
+  test('does not match a bare (non-call) reference', () => {
+    expect(identifierCallPattern('$count').test('$count')).toBe(false)
+  })
+
+  test('does not match when the name is a substring of a longer call', () => {
+    expect(identifierCallPattern('$count').test('my$count()')).toBe(false)
+    expect(identifierCallPattern('$count').test('$counter()')).toBe(false)
+  })
+
+  test('plain (non-$) getter names keep matching call syntax as before', () => {
+    expect(identifierCallPattern('count').test('count()')).toBe(true)
+    expect(identifierCallPattern('count').test('acount()')).toBe(false)
+    expect(identifierCallPattern('count').test('counter()')).toBe(false)
+  })
+})
+
+// -----------------------------------------------------------------------------
+// End-to-end: a `.map()` callback whose param is `$item` must classify
+// identically to one named `item` — same slotId allocation, same
+// `$item() ` accessor-wrapping in the emitted client JS. Before the fix,
+// `referencesLoopParam` / `wrapLoopParamAsAccessor`'s `\b$item\b` pattern
+// never matched, so the loop body silently lost slotId/reactive
+// classification for the `$item`-named param (wrong-but-silent: `bun test`
+// still passed because nothing asserted the accessor wrap for a `$`-param
+// until now). Verified red-without/green-with: reverting `identifier-
+// pattern.ts` to a plain `` new RegExp(`\\b${name}\\b`) ``-style
+// implementation fails this describe block while leaving the plain-`item`
+// sibling test green — see PR description for the local repro.
+// -----------------------------------------------------------------------------
+describe('$-prefixed loop param compiles identically to a plain-named one (#2592)', () => {
+  const adapter = new TestAdapter()
+
+  function compileMapBody(param: string): string {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      type Row = { id: number; label: string }
+      export function List() {
+        const [rows] = createSignal<Row[]>([])
+        return (
+          <ul>
+            {rows().map((${param}) => (
+              <Card key={${param}.id}>
+                <CardHeader>{${param}.label}</CardHeader>
+              </Card>
+            ))}
+          </ul>
+        )
+      }
+    `
+    const result = compileJSX(source, 'List.tsx', { adapter })
+    const errors = result.errors.filter(e => e.severity === 'error')
+    if (errors.length > 0) throw new Error(errors.map(e => e.message).join('\n'))
+    return result.files.find(f => f.type === 'clientJs')!.content
+  }
+
+  test('a plain `item` param is wrapped as an accessor in the child component prop', () => {
+    const js = compileMapBody('item')
+    expect(js).toContain('item().label')
+  })
+
+  test('a `$item` param is wrapped as an accessor identically (was previously left bare)', () => {
+    const js = compileMapBody('$item')
+    expect(js).toContain('$item().label')
+    expect(js).toContain('$item().id')
+  })
+})
+
+describe('flags handling', () => {
+  test("passing flags that already include 'u' does not throw (no duplicate flag)", () => {
+    const p = identifierPattern('item', 'gu')
+    expect(p.flags).toBe('gu')
+    const c = identifierCallPattern('item', 'u')
+    expect(c.flags).toBe('u')
+    expect('a item b item'.replace(identifierPattern('item', 'gu'), 'x')).toBe('a x b x')
+  })
+})

package/src/__tests__/loop-child-reactive-attr-const-shadow.test.ts

@@ -0,0 +1,107 @@
+/**
+ * #2482 Stage 1b — `prop-handling.ts`'s `expandConstantForReactivity` /
+ * `expandDynamicPropValue` run on `ClientJsContext`, a per-component object
+ * with no loop-scope field at all. Both do a flat
+ * `ctx.localConstants.find((c) => c.name === trimmedValue)` lookup with no
+ * awareness that the expression being expanded might be sitting inside a
+ * `.map()` row whose OWN item/index/destructured/preamble binding shadows
+ * that same-named module/component-level const — the lookup resolves to
+ * the OUTER const's value regardless.
+ *
+ * This test pins the reachable, currently-shipping instance: a per-item
+ * reactive DOM attribute (forced via `/* @client *\/`, so it bypasses the
+ * loop-param-only reactivity classifier and always reaches
+ * `collectLoopChildReactiveAttrs` → `expandConstantForReactivity`) whose
+ * value is a bare reference to the loop's OWN item parameter, which
+ * shares a name with a module-level const. Before the fix, the per-item
+ * `createEffect`-equivalent (`applyItem`/`createRow` in the lazy-row
+ * runtime) baked in the outer const's fixed literal for every row instead
+ * of reading the row's own item value — every row rendered the SAME
+ * `data-label`, and it never diverged from that one baked value.
+ *
+ * Modeled on `csr-template-loop-shadowing.test.ts` (the sibling shadowing
+ * fix for the CSR *template* lambda, #2222) — this is the analogous fix
+ * for the per-item *reactive attribute effect* body, a different codegen
+ * path (`reactivity.ts`'s `collectLoopChildReactiveAttrs`, not
+ * `html-template.ts`).
+ *
+ * A second describe block below pins the INDEX-param shadowing case
+ * (Copilot review on PR #2595): `buildLoopRowScope` initially omitted
+ * the loop's second callback param (`.map((item, i) => ...)`'s `i`) from
+ * the `BindingScope` it builds, so an `i`-shadows-a-module-const attr
+ * const-folded the outer value exactly like the item-param case above,
+ * empirically confirmed reachable through the same
+ * `collectLoopChildReactiveAttrs` → `expandConstantForReactivity` path.
+ * Fixed by threading the IR loop's `index` field through
+ * `collectLoopChildBindings` / `collectLoopChildConditionals` /
+ * `summarizeLoopChildBranch` / `collectLoopChildReactiveAttrs` /
+ * `collectLoopChildReactiveTexts` into `buildLoopRowScope`.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function clientJsFor(source: string): string {
+  const result = compileJSX(source, 'Repro.tsx', { adapter })
+  expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  const clientJs = result.files.find(f => f.type === 'clientJs')
+  expect(clientJs).toBeDefined()
+  return clientJs!.content
+}
+
+describe('loop-child reactive attr vs a loop-param shadowing a module const (#2482)', () => {
+  test('a /* @client */ attr reading the shadowing item param reads the row value, not the outer const', () => {
+    const js = clientJsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Widget({ items }: { items: string[] }) {
+        const label = 'MODULE_CONST'
+        const [n, setN] = createSignal(0)
+        return (
+          <div onClick={() => setN(n() + 1)}>
+            <ul>
+              {items.map((label) => (
+                <li key={label} data-label={/* @client */ label}>{n()}</li>
+              ))}
+            </ul>
+          </div>
+        )
+      }
+    `)
+
+    // The per-item attribute effect must read the row's OWN item
+    // accessor — never the outer module const's baked literal.
+    expect(js).toContain('const __x = label()')
+    expect(js).not.toContain("const __x = 'MODULE_CONST'")
+  })
+})
+
+describe('loop-child reactive attr vs a loop INDEX param shadowing a module const (#2482 / #2595)', () => {
+  test('a /* @client */ attr reading the shadowing index param reads the row index, not the outer const', () => {
+    const js = clientJsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Widget({ items }: { items: string[] }) {
+        const i = 'MODULE_CONST'
+        const [n, setN] = createSignal(0)
+        return (
+          <div onClick={() => setN(n() + 1)}>
+            <ul>
+              {items.map((item, i) => (
+                <li key={item} data-idx={/* @client */ i}>{n()}</li>
+              ))}
+            </ul>
+          </div>
+        )
+      }
+    `)
+
+    // The per-item attribute effect must read the row's OWN index
+    // closure variable — never the outer module const's baked literal.
+    expect(js).toContain("const __v = i;")
+    expect(js).not.toContain("const __v = 'MODULE_CONST';")
+  })
+})

package/src/__tests__/rewrite-dynamic-imports.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Unit coverage for `rewriteDynamicImportsInSource` (#2588) — the source-text
+ * counterpart to `rewriteImportsForTemplate`.
+ *
+ * The e2e half lives in `packages/vite/src/__tests__/dynamic-import-rewrite.test.ts`
+ * (real `vite build`, real emitted template). This half pins the cases that
+ * an e2e fixture can't isolate: which AST nodes count, and the false matches
+ * a regex-based implementation would produce. Those false-match cases are
+ * the entire reason this parses (CLAUDE.md: never parse JS/TS with regex) —
+ * without them, a regex rewrite would pass every other assertion here.
+ */
+import { describe, test, expect } from 'bun:test'
+import { rewriteDynamicImportsInSource } from '../adapters/template-imports.ts'
+
+/** Stand-in for `buildRelativeImportRewriter`: shifts one directory deeper. */
+const deeper = (spec: string): string => `../${spec}`
+
+describe('rewriteDynamicImportsInSource', () => {
+  test('rewrites a dynamic import call', () => {
+    expect(rewriteDynamicImportsInSource(`const m = import('./heavy')`, deeper))
+      .toBe(`const m = import('.././heavy')`)
+  })
+
+  test('rewrites an import type node (`typeof import(...)`)', () => {
+    expect(rewriteDynamicImportsInSource(`let p: Promise<typeof import('../lib/x')> | null = null`, deeper))
+      .toBe(`let p: Promise<typeof import('../../lib/x')> | null = null`)
+  })
+
+  test('rewrites a qualified import type (`import(...).Foo`)', () => {
+    expect(rewriteDynamicImportsInSource(`let v: import('../lib/x').Foo`, deeper))
+      .toBe(`let v: import('../../lib/x').Foo`)
+  })
+
+  test('rewrites every occurrence, keeping earlier spans intact', () => {
+    const out = rewriteDynamicImportsInSource(
+      `const a = import('./one'); const b = import('./two'); const c = import('./three')`,
+      deeper,
+    )
+    expect(out).toBe(
+      `const a = import('.././one'); const b = import('.././two'); const c = import('.././three')`,
+    )
+  })
+
+  test('leaves bare specifiers alone', () => {
+    const src = `const m = import('hono/jsx')`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('leaves a non-literal specifier alone', () => {
+    const src = `const m = import(chunkPath)`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('leaves static import statements to rewriteImportsForTemplate', () => {
+    // The adapter rewrites those from the parsed `templateImports` list; if
+    // this touched them too they would be rewritten twice.
+    const src = `import { x } from './sibling'`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('does not touch `import(` inside a string literal', () => {
+    const src = `const code = "const m = import('./heavy')"`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('does not touch `import(` inside a template literal', () => {
+    const src = 'const code = `await import(\'./heavy\')`'
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('does not touch `import(` inside a comment', () => {
+    const src = `// const m = import('./heavy')\nconst n = 1`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+
+  test('rewrites inside a TSX component body without disturbing the JSX', () => {
+    const src = [
+      `export function Lazy() {`,
+      `  const onClick = async () => { await import('./heavy') }`,
+      `  return <button onClick={onClick} data-x="import('./nope')">go</button>`,
+      `}`,
+    ].join('\n')
+    const out = rewriteDynamicImportsInSource(src, deeper)
+    expect(out).toContain(`await import('.././heavy')`)
+    // The attribute string is data, not a module reference.
+    expect(out).toContain(`data-x="import('./nope')"`)
+  })
+
+  test('returns the input unchanged when the rewriter is a no-op', () => {
+    const src = `const m = import('./heavy')`
+    expect(rewriteDynamicImportsInSource(src, (s) => s)).toBe(src)
+  })
+
+  test('returns the input unchanged when there is nothing to rewrite', () => {
+    const src = `export const answer = 42`
+    expect(rewriteDynamicImportsInSource(src, deeper)).toBe(src)
+  })
+})

package/src/adapters/jsx-adapter.ts

@@ -19,6 +19,7 @@ import type { CallbackBodyAcceptor } from './interface.ts'
 import { ENV_SIGNAL_CLIENT_FACTORY } from './env-signal.ts'
 import { formatParamWithType, findReachableNames } from '../module-exports.ts'
 import { extractFreeIdentifiersFromText } from '../ir-to-client-js/csr-substitute.ts'
+import { identifierPattern } from '../identifier-pattern.ts'
 
 export interface JsxAdapterConfig {
   /** Use typed versions (typedInitialValue, etc.) for type-safe .tsx output */
@@ -165,7 +166,7 @@ export abstract class JsxAdapter extends BaseAdapter {
 
       // Create a no-op setter for SSR — omit entirely if not referenced anywhere
       if (signal.setter) {
-        const setterUsed = new RegExp(`\\b${signal.setter}\\b`).test(setterRefText)
+        const setterUsed = identifierPattern(signal.setter).test(setterRefText)
         if (setterUsed) {
           lines.push(`  const ${signal.setter} = (..._args: any[]) => {}`)
         }

package/src/adapters/template-imports.ts

@@ -16,6 +16,7 @@
  * Adapters are responsible for calling this themselves before emitting any
  * import block. The compiler hands them `metadata.imports` unchanged.
  */
+import ts from 'typescript'
 import type { ImportInfo, ImportSpecifier } from '../types.ts'
 
 const CLIENT_PACKAGE_SOURCES = new Set([
@@ -77,3 +78,95 @@ export function rewriteImportsForTemplate(
 function specKey(s: ImportSpecifier): string {
   return `${s.isDefault ? 'd' : ''}${s.isNamespace ? 'n' : ''}:${s.name}:${s.alias ?? ''}`
 }
+
+/**
+ * Re-anchor relative specifiers carried inside emitted SOURCE TEXT — the
+ * counterpart to `rewriteImportsForTemplate`, which only sees the parsed
+ * static import list (`metadata.templateImports`).
+ *
+ * Declaration bodies re-emitted verbatim into a template
+ * (`generateModuleScopeDeclarations`' consts/functions, a component body's
+ * local handlers) can carry their own module references that never appear
+ * in that list:
+ *
+ * - `import('./x')` — a dynamic import expression
+ * - `typeof import('./x')` — an import TYPE node
+ *
+ * Those specifiers are written relative to the SOURCE file, so they break
+ * once the template is emitted to a directory at a different depth — the
+ * same depth shift `rewriteImportsForTemplate` already fixes for static
+ * imports (#1453, #2588).
+ *
+ * Only literal relative paths beginning with `.` are rewritten; bare
+ * specifiers pass through, matching `remap`'s guard above. A non-literal
+ * argument (`import(someVar)`) is left alone — there is no specifier to
+ * re-anchor, and guessing would be worse than leaving the source as-is.
+ *
+ * Parsed with the TS AST and applied by span splicing rather than by
+ * matching text: a regex would false-match `import(` inside a string or a
+ * comment, which is exactly the class of bug the repo-wide "never parse JS
+ * with regex" rule exists to prevent. Splices are applied back-to-front so
+ * earlier spans keep their offsets.
+ */
+export function rewriteDynamicImportsInSource(
+  sourceText: string,
+  rewriteRelative: (importPath: string) => string,
+): string {
+  // Cheap pre-check: skip the parse entirely for the overwhelmingly common
+  // case of text with no dynamic import at all. Substring presence is not
+  // used to LOCATE anything — the AST still does that — so a false positive
+  // here costs one wasted parse and a false negative is impossible.
+  if (!sourceText.includes('import')) return sourceText
+
+  const sf = ts.createSourceFile(
+    'bf-template-fragment.tsx',
+    sourceText,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */ false,
+    ts.ScriptKind.TSX,
+  )
+
+  const edits: Array<{ start: number, end: number, text: string }> = []
+
+  const visit = (node: ts.Node): void => {
+    // `import('./x')` — the argument is the first (and only) call argument.
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+      node.arguments.length > 0 &&
+      ts.isStringLiteralLike(node.arguments[0])
+    ) {
+      collect(node.arguments[0] as ts.StringLiteralLike)
+    }
+    // `typeof import('./x')` / `import('./x').Foo` — a TYPE-position node
+    // whose argument is a literal type wrapping the string.
+    if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+      const literal = node.argument.literal
+      if (ts.isStringLiteralLike(literal)) collect(literal)
+    }
+    ts.forEachChild(node, visit)
+  }
+
+  const collect = (literal: ts.StringLiteralLike): void => {
+    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}'`,
+    })
+  }
+
+  ts.forEachChild(sf, visit)
+  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
+}

package/src/debug.ts

@@ -29,6 +29,7 @@ import { analyzeClientNeeds } from './ir-to-client-js/index.ts'
 import type { WrapReason } from './ir-to-client-js/reactivity.ts'
 import { decideWrapFromAstFlags } from './ir-to-client-js/reactivity.ts'
 import { tokenContainsIdent } from './ir-to-client-js/utils.ts'
+import { identifierCallPattern } from './identifier-pattern.ts'
 
 // =============================================================================
 // Types
@@ -1990,12 +1991,12 @@ function attrValueToString(value: AttrValue): string | null {
 function extractReactiveDeps(expr: string, signalGetters: Set<string>, memoNames: Set<string>): string[] {
   const deps: string[] = []
   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)
     }
   }
@@ -2012,7 +2013,7 @@ function extractSetterRefs(expr: string, signalGetters: Set<string>): string[] {
   }
   // Also detect signal getter reads in handler
   for (const getter of signalGetters) {
-    if (new RegExp(`\\b${getter}\\s*\\(`).test(expr)) {
+    if (identifierCallPattern(getter).test(expr)) {
       refs.push(getter)
     }
   }

package/src/identifier-pattern.ts

@@ -0,0 +1,79 @@
+/**
+ * Single door for building "does this expression text reference identifier
+ * X?" regexes (#2592).
+ *
+ * The naive `new RegExp(`\\b${name}\\b`)` idiom used throughout the compiler
+ * breaks for `$`-containing identifiers (legal in JS: `$item`, `item$`,
+ * `a$b`) in two independent ways:
+ *
+ *   1. Unescaped: an interpolated `$` is a regex metacharacter (end-of-
+ *      input/line anchor), so `\b$item\b` / `\ba$b\b` can (almost) never
+ *      match mid-string — false negative.
+ *   2. Even escaped, `\b` requires a `\w`/non-`\w` transition and `$` is
+ *      not `\w` (`[A-Za-z0-9_]`) — so `\b\$item\b` still fails to match the
+ *      leading boundary in `($item)` (both `(` and `$` are non-word, so no
+ *      transition occurs there).
+ *
+ * `identifierPattern` / `identifierCallPattern` fix both: the identifier
+ * text is escaped before interpolation, and the boundary is asserted with
+ * lookaround against `\p{ID_Continue}` (Unicode "can continue an
+ * identifier") unioned with `$`, so `$` is correctly treated as
+ * identifier-like on both sides of the match.
+ *
+ * Scope: these remain the same *bounded lexical heuristic* the compiler has
+ * always used for expression-text scanning (not a general JS/TS parse —
+ * see CLAUDE.md's structural-parsing rule, which does not apply to this
+ * class of check). This module only fixes the `$` boundary bug; it does not
+ * change what the heuristic considers a "reference" (string literals,
+ * comments, and member-access tails are still opaque to it — callers that
+ * need that precision use `tokenContainsIdent` / `node.freeIdentifiers`
+ * instead, per #1267).
+ */
+
+// Duplicate regex flags throw at construction ('gu' + 'u' -> SyntaxError),
+// so `u` is added only when the caller didn't already pass it.
+function withUnicodeFlag(flags: string): string {
+  return flags.includes('u') ? flags : `${flags}u`
+}
+
+/** Escape regex metacharacters in a literal identifier before interpolation. */
+export function escapeIdentifierForRegex(name: string): string {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Lookaround fragments asserting "not preceded/followed by an identifier
+ * continuation character (including `$`)". `$` is a legal identifier char
+ * in JS but is not `\p{ID_Continue}`, so it's unioned in explicitly.
+ *
+ * Exported for the few call sites that must splice extra assertions
+ * between the identifier and the trailing boundary (e.g. "not followed by
+ * a call" as well as "not followed by an identifier char") — compose with
+ * these fragments rather than reintroducing a bare `\b`.
+ */
+export const ID_BOUNDARY_BEFORE = '(?<![\\p{ID_Continue}$])'
+export const ID_BOUNDARY_AFTER = '(?![\\p{ID_Continue}$])'
+
+/**
+ * Regex matching a standalone reference to identifier `name` — the `$`-safe
+ * replacement for `new RegExp(`\\b${name}\\b`)`. Always carries the `u`
+ * (unicode) flag, required for `\p{ID_Continue}`; pass additional flags
+ * (e.g. `'g'` for `String.replace`/`matchAll` substitution sites) via
+ * `flags`.
+ */
+export function identifierPattern(name: string, flags = ''): RegExp {
+  const esc = escapeIdentifierForRegex(name)
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}${ID_BOUNDARY_AFTER}`, withUnicodeFlag(flags))
+}
+
+/**
+ * Regex matching identifier `name` used in call position (`name(...)`,
+ * allowing whitespace before the paren) — the `$`-safe replacement for
+ * `new RegExp(`\\b${name}\\s*\\(`)`. No trailing boundary assertion is
+ * needed: `\s`/`(` are already not `\p{ID_Continue}`/`$`, so they can't be
+ * mistaken for a continuation of `name`.
+ */
+export function identifierCallPattern(name: string, flags = ''): RegExp {
+  const esc = escapeIdentifierForRegex(name)
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}\\s*\\(`, withUnicodeFlag(flags))
+}

package/src/index.ts

@@ -89,7 +89,7 @@ export type {
 } from './adapters/interface.ts'
 export { JsxAdapter } from './adapters/jsx-adapter.ts'
 export type { JsxAdapterConfig } from './adapters/jsx-adapter.ts'
-export { rewriteImportsForTemplate } from './adapters/template-imports.ts'
+export { rewriteImportsForTemplate, rewriteDynamicImportsInSource } from './adapters/template-imports.ts'
 export { emitParsedExpr, groupBinaryOperand, isStringTypedOperand, isStringConcatBinary } from './adapters/parsed-expr-emitter.ts'
 export type { ParsedExprEmitter, HigherOrderMethod, ArrayMethod, SortMethod, LiteralType } from './adapters/parsed-expr-emitter.ts'
 export { collectLoopBoundNames } from './adapters/loop-bound-names.ts'