@barefootjs/jsx 0.33.4 → 0.34.0

package/src/__tests__/markup-prop-brand.test.ts

@@ -159,27 +159,18 @@ describe('markup-prop brand (#2651)', () => {
     expect(clientJs).toMatch(/get header\(\)\s*\{\s*return __slot\(/)
   })
 
-  // KNOWN BUG (#2702) — pins the CURRENT (broken) emission, not the
-  // correct one. `isSingleElementJsxChildren` (`ir-to-client-js/collect-
-  // elements.ts`) only brands the single-element jsx-children shape;
-  // #2651's PR body enumerated "conditional-in-fragment" as deliberately
-  // out of that PR's scope, and #2702 confirms it is actually broken, not
-  // merely unbranded-but-harmless: the child's own `escapeTextOrNode`
-  // reactive effect re-escapes the chosen branch's HTML as literal text
-  // the moment it first runs (real DOM corruption, verified directly —
-  // see `jsx-element-prop-fragment-conditional`'s fixture docstring,
-  // `packages/adapter-tests/fixtures/`, for the full mechanism and why no
-  // other shared conformance suite observes it: SSR is genuinely correct,
-  // and CSR conformance's `createEffect` mock never runs the effect).
-  //
-  // Graduation: once `bfMarkup()` branding is extended to this multi-part
-  // shape, this assertion starts failing — replace it with a positive
-  // `bfMarkup(...)`-wrapped assertion (mirroring test (b) above) and
-  // delete this comment block; that is the fixture's own graduation
-  // trigger too (its `expectedHtml` is already the correct SSR output, so
-  // no fixture change is needed, only this pin's removal and #2667's
-  // BF021 suggestion regaining the fragment-wrap escape).
-  test('(h) KNOWN BUG (#2702): a conditional-in-fragment jsx-children prop reaches initChild UNbranded', () => {
+  // #2702: a conditional-in-fragment jsx-children prop now brands EACH
+  // element branch with `bfMarkup()` (`jsxChildrenPropGetterExpr`,
+  // `ir-to-client-js/html-template.ts`) — the shape `isSingleElementJsx
+  // Children`'s narrower single-element gate (#2651) left unbranded,
+  // which corrupted the DOM the moment the child's own `escapeTextOrNode`
+  // reactive effect first ran (re-escaped the chosen branch's HTML as
+  // literal text; see `jsx-element-prop-fragment-conditional`'s fixture
+  // docstring for the full mechanism). Branding each LEAF rather than the
+  // whole ternary keeps a non-element branch (text/expression/`&&`'s
+  // `''`) unbranded and thus still escaped normally — see the sibling
+  // tests below.
+  test('(h) a conditional-in-fragment jsx-children prop brands each element branch with bfMarkup()', () => {
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -201,10 +192,158 @@ describe('markup-prop brand (#2651)', () => {
       }
     `
     const clientJs = clientJsFor(source)
-    // Bug: the getter returns a bare template-literal ternary — NOT
-    // wrapped in bfMarkup(...). If this ever starts matching bfMarkup(...)
-    // the bug is fixed; see the graduation note above.
-    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return cond\(\)\s*\?\s*`<a>x<\/a>`\s*:\s*`<b>y<\/b>`\s*\}/)
-    expect(clientJs).not.toMatch(/get header\(\)\s*\{\s*return bfMarkup\(/)
+    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return cond\(\)\s*\?\s*bfMarkup\(`<a>x<\/a>`\)\s*:\s*bfMarkup\(`<b>y<\/b>`\)\s*\}/)
+  })
+
+  test('(i) a conditional-in-fragment jsx-children prop leaves a non-element branch unbranded', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Card(props: { header?: any }) {
+        return <section><header>{props.header}</header></section>
+      }
+      export function label() { return 'x' }
+      export function TextBranch() {
+        const [cond, setCond] = createSignal(true)
+        return <Card header={<>{cond() ? <a>x</a> : 'plain'}</>} />
+      }
+      export function ExpressionBranch() {
+        const [cond, setCond] = createSignal(true)
+        return <Card header={<>{cond() ? <a>x</a> : label()}</>} />
+      }
+      export function LogicalAnd() {
+        const [cond, setCond] = createSignal(true)
+        return <Card header={<>{cond() && <a>x</a>}</>} />
+      }
+    `
+    const clientJs = clientJsFor(source)
+    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return cond\(\)\s*\?\s*bfMarkup\(`<a>x<\/a>`\)\s*:\s*'plain'\s*\}/)
+    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return cond\(\)\s*\?\s*bfMarkup\(`<a>x<\/a>`\)\s*:\s*label\(\)\s*\}/)
+    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return cond\(\)\s*\?\s*bfMarkup\(`<a>x<\/a>`\)\s*:\s*''\s*\}/)
+  })
+
+  test('(j) nested conditionals brand every element branch', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Card(props: { header?: any }) {
+        return <section><header>{props.header}</header></section>
+      }
+      export function P() {
+        const [a, setA] = createSignal(true)
+        const [b, setB] = createSignal(true)
+        return <Card header={<>{a() ? (b() ? <a>x</a> : <c>z</c>) : <b>y</b>}</>} />
+      }
+    `
+    const clientJs = clientJsFor(source)
+    expect(clientJs).toMatch(
+      /get header\(\)\s*\{\s*return a\(\)\s*\?\s*b\(\)\s*\?\s*bfMarkup\(`<a>x<\/a>`\)\s*:\s*bfMarkup\(`<c>z<\/c>`\)\s*:\s*bfMarkup\(`<b>y<\/b>`\)\s*\}/,
+    )
+  })
+
+  // A multi-child fragment (more than one flattened part) has no `bfMarkup`/
+  // `escapeTextOrNode` array contract — stays unbranded, unchanged from
+  // before #2702 (a separate, pre-existing gap, not this fix's scope).
+  test('(k) a multi-child fragment jsx-children prop stays unbranded', () => {
+    const source = `
+      'use client'
+      export function Card(props: { header?: any }) {
+        return <section><header>{props.header}</header></section>
+      }
+      export function P() {
+        return <Card header={<>text<strong>x</strong></>} />
+      }
+    `
+    const clientJs = clientJsFor(source)
+    expect(clientJs).toMatch(/get header\(\)\s*\{\s*return \["text", `<strong>x<\/strong>`\]\s*\}/)
+  })
+
+  // An explicit `children={<jsx/>}` prop stays unbranded regardless of
+  // shape — its consumer is a bare `{children}` passthrough with no
+  // unwrap call (test (b)'s comment above explains the same exclusion).
+  // pullfrog review, PR #2820: `jsxChildrenPropGetterExpr` (the shared
+  // brand-decision door test (h)-(k) pin) wasn't wired into EVERY builder
+  // that constructs the identical `get <propName>() { return <expr> }`
+  // getter — `buildComponentPropsExpr` (`control-flow/shared.ts`, shared by
+  // loop AND conditional-branch component reconciliation) and
+  // `buildStaticPropsExpr` (`build-static-array-child-init.ts`) both still
+  // called the plain, unbranded `irChildrenToJsExpr` directly. The same
+  // conditional-in-fragment shape test (h) pins for a top-level component
+  // corrupted the DOM at hydrate time when the component was instead
+  // instantiated inside a `.map()` loop.
+  test('(m) a conditional-in-fragment jsx-children prop is branded for a component instantiated inside a .map() loop', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Card(props: { header?: any }) {
+        return <header>{props.header}</header>
+      }
+      export function List() {
+        const [items, setItems] = createSignal([{ id: 1 }])
+        return (
+          <div>
+            {items().map(item => (
+              <Card key={item.id} header={<>{item.id > 0 ? <a>x</a> : <b>y</b>}</>} />
+            ))}
+          </div>
+        )
+      }
+    `
+    const clientJs = clientJsFor(source)
+    // Both the reactive-patch (initChild) and initial-mount (createComponent)
+    // paths through mapArray's callback must brand each element branch.
+    expect(clientJs).toMatch(
+      /initChild\('Card', __existing, \{ get header\(\) \{ return item\(\)\.id > 0 \? bfMarkup\(`<a>x<\/a>`\) : bfMarkup\(`<b>y<\/b>`\) \} \}\)/,
+    )
+    expect(clientJs).toMatch(
+      /createComponent\('Card', \{ get header\(\) \{ return item\(\)\.id > 0 \? bfMarkup\(`<a>x<\/a>`\) : bfMarkup\(`<b>y<\/b>`\) \} \}, item\(\)\.id\)/,
+    )
+  })
+
+  // pullfrog review, PR #2820: test (m) covers the SIGNAL-driven `.map()`
+  // loop (`buildComponentPropsExpr`); `buildStaticPropsExpr`
+  // (`build-static-array-child-init.ts`) — the sibling builder for a
+  // STATIC, non-signal array `.map()` — got the identical fix but no
+  // dedicated test, which is exactly the untested-call-site pattern that
+  // let #2702's original corruption go uncaught. Pins the hydrate-time
+  // `initChild` path this builder feeds.
+  test('(n) a conditional-in-fragment jsx-children prop is branded for a component instantiated inside a static (non-signal) array .map()', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Card(props: { header?: any }) {
+        return <header>{props.header}</header>
+      }
+      export function List() {
+        const [cond, setCond] = createSignal(true)
+        return (
+          <div>
+            {[{ id: 1 }].map(item => (
+              <Card key={item.id} header={<>{cond() ? <a>x</a> : <b>y</b>}</>} />
+            ))}
+          </div>
+        )
+      }
+    `
+    const clientJs = clientJsFor(source)
+    expect(clientJs).toMatch(
+      /initChild\('Card', childScope, \{ get header\(\) \{ return cond\(\) \? bfMarkup\(`<a>x<\/a>`\) : bfMarkup\(`<b>y<\/b>`\) \} \}\)/,
+    )
+  })
+
+  test('(l) an explicit children prop with a conditional stays unbranded', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Card(props: { children?: any }) {
+        return <section>{props.children}</section>
+      }
+      export function P() {
+        const [cond, setCond] = createSignal(true)
+        return <Card children={<>{cond() ? <a>x</a> : <b>y</b>}</>} />
+      }
+    `
+    const clientJs = clientJsFor(source)
+    expect(clientJs).toMatch(/get children\(\)\s*\{\s*return cond\(\)\s*\?\s*`<a>x<\/a>`\s*:\s*`<b>y<\/b>`\s*\}/)
   })
 })

package/src/__tests__/namespace-import-primitive.test.ts

@@ -0,0 +1,244 @@
+/**
+ * #2771 — `import * as bf from '@barefootjs/client'` followed by
+ * `bf.createSignal(0)` (or any other reactive primitive accessed off the
+ * namespace binding) compiled with ZERO diagnostics, but `resolvePrimitiveKind`'s
+ * fast path only matches a bare identifier callee — the checker-based slow
+ * path that DOES understand a namespace-qualified call only runs when a
+ * shared `ts.Program` is supplied (`CompileOptions.program`). Without one,
+ * the declaration is silently dropped from the compiled output and every
+ * reference to it throws `ReferenceError` at hydrate.
+ *
+ * BF013 refuses loudly instead, gated on NON-recognition — a compile that
+ * DOES supply a program (see `primitive-resolver-alias.test.ts`'s pattern)
+ * must never see this diagnostic, since that path already lowers the shape
+ * correctly.
+ */
+import { describe, test, expect } from 'bun:test'
+import path from 'path'
+import ts from 'typescript'
+import { compileJSX } from '../compiler'
+import { analyzeComponent } from '../index'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function errorsFor(source: string): Array<{ code?: string; severity: string }> {
+  const result = compileJSX(source, 'Counter.tsx', { adapter })
+  return result.errors.map(e => ({ code: e.code, severity: e.severity }))
+}
+
+function bf013(source: string) {
+  return errorsFor(source).find(e => e.code === 'BF013')
+}
+
+describe('#2771 — BF013: reactive primitive called through an unresolved namespace import', () => {
+  test('bf.createSignal(...) (array destructure) fires BF013', () => {
+    const result = compileJSX(
+      `
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        const [n, setN] = bf.createSignal(0)
+        return <button onClick={() => setN(n() + 1)}>{n()}</button>
+      }
+    `,
+      'Counter.tsx',
+      { adapter },
+    )
+    const err = result.errors.find(e => e.code === 'BF013')
+    expect(err).toBeDefined()
+    expect(err!.severity).toBe('error')
+    expect(err!.message).toContain('bf.createSignal')
+    expect(err!.suggestion?.escape).toEqual([{ kind: 'rewrite' }])
+  })
+
+  test('bf.createMemo(...) (array destructure) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      import { createSignal } from '@barefootjs/client'
+      export function Counter() {
+        const [n] = createSignal(1)
+        const [doubled] = bf.createMemo(() => n() * 2)
+        return <div>{doubled()}</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('bf.createEffect(...) (expression statement) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      import { createSignal } from '@barefootjs/client'
+      export function Counter() {
+        const [n] = createSignal(0)
+        bf.createEffect(() => { console.log(n()) })
+        return <div>{n()}</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('bf.onMount(...) (expression statement) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        bf.onMount(() => { console.log('mounted') })
+        return <div>static</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('bf.onCleanup(...) (expression statement) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        bf.onCleanup(() => { console.log('cleaned up') })
+        return <div>static</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('bf.createSearchParams(...) (array destructure) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        const [searchParams] = bf.createSearchParams()
+        return <div>{searchParams().get('sort')}</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('bf.createSignal(0)[0] (element access) fires BF013', () => {
+    const err = bf013(`
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        const n = bf.createSignal(0)[0]
+        return <div>{n()}</div>
+      }
+    `)
+    expect(err).toBeDefined()
+  })
+
+  test('a bare named import is unaffected (no BF013)', () => {
+    const errs = errorsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Counter() {
+        const [n, setN] = createSignal(0)
+        return <button onClick={() => setN(n() + 1)}>{n()}</button>
+      }
+    `)
+    expect(errs.find(e => e.code === 'BF013')).toBeUndefined()
+  })
+
+  test('a namespace import of a DIFFERENT module is unaffected (no BF013)', () => {
+    const result = compileJSX(
+      `
+      'use client'
+      import * as store from './store'
+      export function Counter() {
+        const [n, setN] = store.createSignal(0)
+        return <button onClick={() => setN(n() + 1)}>{n()}</button>
+      }
+    `,
+      'Counter.tsx',
+      { adapter },
+    )
+    expect(result.errors.find(e => e.code === 'BF013')).toBeUndefined()
+  })
+
+  test('a component-local binding shadowing the namespace name is unaffected (no BF013)', () => {
+    const result = compileJSX(
+      `
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        const bf = { createSignal: (x: number) => [() => x, (v: number) => {}] as const }
+        const [n, setN] = bf.createSignal(0)
+        return <button onClick={() => setN(n() + 1)}>{n()}</button>
+      }
+    `,
+      'Counter.tsx',
+      { adapter },
+    )
+    expect(result.errors.find(e => e.code === 'BF013')).toBeUndefined()
+  })
+
+  test('a type-only namespace import is unaffected (no BF013)', () => {
+    const result = compileJSX(
+      `
+      'use client'
+      import type * as bf from '@barefootjs/client'
+      export function Counter() {
+        return <div>static</div>
+      }
+    `,
+      'Counter.tsx',
+      { adapter },
+    )
+    expect(result.errors.find(e => e.code === 'BF013')).toBeUndefined()
+  })
+})
+
+describe('#2771 — checker-path pin: a shared Program resolves the namespace and never fires BF013', () => {
+  const CLIENT_DIR = path.resolve(__dirname, '../../../client/src')
+
+  function programFor(filePath: string, source: string): ts.Program {
+    const absolute = path.resolve(filePath)
+    const compilerOptions: ts.CompilerOptions = {
+      target: ts.ScriptTarget.Latest,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      jsx: ts.JsxEmit.ReactJSX,
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true,
+      esModuleInterop: true,
+      baseUrl: path.dirname(absolute),
+    }
+    const defaultHost = ts.createCompilerHost(compilerOptions)
+    const host: ts.CompilerHost = {
+      ...defaultHost,
+      getSourceFile(fileName, languageVersion) {
+        if (path.resolve(fileName) === absolute) {
+          return ts.createSourceFile(fileName, source, languageVersion, true, ts.ScriptKind.TSX)
+        }
+        return defaultHost.getSourceFile(fileName, languageVersion)
+      },
+      fileExists(fileName) {
+        if (path.resolve(fileName) === absolute) return true
+        return defaultHost.fileExists(fileName)
+      },
+      readFile(fileName) {
+        if (path.resolve(fileName) === absolute) return source
+        return defaultHost.readFile(fileName)
+      },
+    }
+    return ts.createProgram([absolute], compilerOptions, host)
+  }
+
+  test('with a shared Program, bf.createSignal resolves and BF013 never fires', () => {
+    const source = `
+      'use client'
+      import * as bf from '@barefootjs/client'
+      export function Counter() {
+        const [n, setN] = bf.createSignal(0)
+        return <button onClick={() => setN(n() + 1)}>{n()}</button>
+      }
+    `
+    const testFile = path.join(CLIENT_DIR, '__ns_primitive_checker_pin__.tsx')
+    const program = programFor(testFile, source)
+    const ctx = analyzeComponent(source, testFile, undefined, program)
+    expect(ctx.signals.length).toBe(1)
+    expect(ctx.errors.find(e => e.code === 'BF013')).toBeUndefined()
+  })
+})

package/src/__tests__/rewrite-destructured-props.test.ts

@@ -71,3 +71,56 @@ export { Btn }
     expect(js).not.toMatch(/\(_p\.size[^)]*\)-[0-9]/)
   })
 })
+
+// #2741: `rewriteDestructuredPropsInExpr` (the reactive `createEffect`
+// update path) used to run a bare `\b<prop>\b` regex over the whole
+// expression text, so an object-literal property whose KEY happened to
+// share a prop's name (`{ tag: tag }`) had the KEY rewritten too
+// (`{ _p.tag: _p.tag }`), which is not valid JS — the whole client module
+// failed to parse, silently (no diagnostic). Now delegates to the same
+// AST-based `rewriteBarePropRefs` (`prop-rewrite.ts`) the hydrate template
+// lambda already used, which distinguishes a key from a value reference.
+describe('reactive-effect prop rewrite does not touch object-literal keys (#2741)', () => {
+  test('an explicit-key object literal used in a reactive attribute keeps its keys', () => {
+    const source = `
+"use client"
+import { queryHref } from '@barefootjs/client'
+function Comp({ base, tag, page }: { base: string; tag: string; page: string }) {
+  return <a href={queryHref(base, { tag: tag, page: page ? page : '' })}>filter</a>
+}
+export { Comp }
+`
+    const js = compileClientJs(source)
+    expect(js).toContain("{ tag: _p.tag, page: _p.page ? _p.page : '' }")
+    expect(js).not.toContain('_p.tag:')
+    expect(js).not.toContain('_p.page:')
+  })
+
+  test('a keyed prop with a destructure default still gets the (_p.x ?? default) wrap only in value position', () => {
+    const source = `
+"use client"
+import { queryHref } from '@barefootjs/client'
+function Comp({ base, tag = 'all', page }: { base: string; tag?: string; page: string }) {
+  return <a href={queryHref(base, { tag: tag, page: page ? page : '' })}>filter</a>
+}
+export { Comp }
+`
+    const js = compileClientJs(source)
+    expect(js).toContain("{ tag: (_p.tag ?? 'all'), page: _p.page ? _p.page : '' }")
+    expect(js).not.toContain("(_p.tag ?? 'all'):")
+  })
+
+  test('a prop name shadowed by an inner callback parameter is not rewritten inside that callback', () => {
+    const source = `
+"use client"
+import { createSignal } from '@barefootjs/client'
+function Comp({ tag, items }: { tag: string; items: { a: string }[] }) {
+  const [n] = createSignal(0)
+  return <div data-x={n() + items.map((tag) => tag.a).join(',') + tag}></div>
+}
+export { Comp }
+`
+    const js = compileClientJs(source)
+    expect(js).toContain("items.map((tag) => tag.a).join(',') + _p.tag")
+  })
+})

package/src/__tests__/static-loop-csr-materialize.test.ts

@@ -242,7 +242,7 @@ describe('#1247 — static-loop CSR self-heal', () => {
     expect(clientJs).toMatch(/if \(!__iterEl\)/)
     // The cloned template body is a single `renderChild('Tag', ...)`
     // expression — props read from the destructured forEach param.
-    const matMatch = clientJs.match(/__tpl\.innerHTML = `([^`]*)`/)
+    const matMatch = clientJs.match(/__tpl\.innerHTML = withParentScope\(__scopeId, \(\) => `([^`]*)`\)/)
     expect(matMatch).toBeTruthy()
     const inner = matMatch![1]
     expect(inner).toMatch(/\$\{renderChild\('Tag', \{[^}]*id: id[^}]*variant: t\.variant[^}]*\}, id/)
@@ -287,7 +287,7 @@ describe('#1247 — static-loop CSR self-heal', () => {
     // Materialize branch present.
     expect(clientJs).toMatch(/if \(!__iterEl\)/)
     // Per-iteration template is `<li ...>...renderChild('Cell', ...)...</li>`.
-    const matMatch = clientJs.match(/__tpl\.innerHTML = `([^`]*)`/)
+    const matMatch = clientJs.match(/__tpl\.innerHTML = withParentScope\(__scopeId, \(\) => `([^`]*)`\)/)
     expect(matMatch).toBeTruthy()
     const inner = matMatch![1]
     expect(inner).toMatch(/^<li\b/)

package/src/adapters/child-scope.ts

@@ -20,3 +20,26 @@ export function derivesScopeFromSlot(
 ): boolean {
   return comp.slotId != null && comp.loopItemRoot !== true
 }
+
+/**
+ * The `renderChild(name, props, key, <here>)` tail arguments — the single
+ * decision point both CSR template emitters (`html-template.ts`'s two
+ * `case 'component'` branches) share, so they can't drift on it the way
+ * #2444 happened for `derivesScopeFromSlot` itself.
+ *
+ * A loop item root (`!derivesScopeFromSlot`) still gets its `slotId` and the
+ * `loopItemRoot` flag (#2833) rather than dropping the slot argument
+ * entirely as before: Hono stamps `bf-h`/`bf-m` on a row root too (just
+ * without deriving its `bf-s` from them), and a pure-CSR mount's static
+ * `qsaChildScopes` init selector needs that same marker to find the row.
+ */
+export function renderChildScopeArgs(
+  comp: Pick<IRComponent, 'slotId' | 'loopItemRoot'>,
+  keyArg: string
+): string {
+  if (comp.slotId == null) return keyArg
+  const key = keyArg || ', undefined'
+  return derivesScopeFromSlot(comp)
+    ? `${key}, '${comp.slotId}'`
+    : `${key}, '${comp.slotId}', true`
+}

package/src/adapters/parsed-expr-emitter.ts

@@ -35,6 +35,7 @@
 
 import type { ParsedExpr, FlatDepth, TemplatePart, ObjectLiteralProperty } from '../expression-parser.ts'
 import { asCallbackMethodCall } from '../expression-parser.ts'
+import type { LoweringMatcher, LoweringNode } from '../lowering-registry.ts'
 
 export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
@@ -95,6 +96,22 @@ export type SortMethod = 'sort' | 'toSorted'
 
 export type LiteralType = 'string' | 'number' | 'boolean' | 'null'
 
+/**
+ * An adapter's registered-lowering seam for the shared `call` dispatch
+ * (#2843). `matchers` are the same `ctx.state.loweringMatchers`-style list
+ * every adapter already binds at init; `render` maps one matched neutral
+ * node to this adapter's own template syntax (its body is typically what
+ * used to live inline in the adapter's `call()` method before this seam
+ * existed — see `renderLoweringNode` in the Go adapter's `url-builder.ts`
+ * for the shape). Returning null for a `kind`/`helper` this adapter has no
+ * mapping for lets the caller fall through to the ordinary `call()`
+ * dispatch, same as an unmatched call.
+ */
+export interface LoweringEmitter {
+  readonly matchers: readonly LoweringMatcher[]
+  render(node: LoweringNode, emit: (e: ParsedExpr) => string): string | null
+}
+
 /**
  * Adapter-side ParsedExpr lowering surface. One method per
  * `ParsedExpr.kind`. The shared `emitParsedExpr` runner dispatches
@@ -109,6 +126,17 @@ export interface ParsedExprEmitter {
   identifier(name: string): string
   literal(value: string | number | boolean | null, literalType: LiteralType): string
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string
+  // Optional (#2843): when present, `emitParsedExpr`'s `call` case tries
+  // every matcher FIRST — before `call()` itself, and before the
+  // higher-order `callbackMethod` recognition — so a registered lowering
+  // plugin's call is recognised no matter where in an expression tree it
+  // sits (a ternary branch, a template-literal interpolation, a binary
+  // operand, …), not only when the adapter's own top-level conversion entry
+  // point happens to consult the registry directly. Omitted entirely by an
+  // adapter that hasn't adopted the seam (e.g. Go, which still consults the
+  // registry inline in its own `call()` per #2842) — behaviour is then
+  // byte-identical to before this field existed.
+  lowering?: LoweringEmitter
   // `optional` is true for a `?.`-written access (`user?.name`); see the
   // `ParsedExpr` `member` variant's docstring in `expression-parser.ts`
   // for the single-hop caveat. Every adapter's `member()` implementation
@@ -340,6 +368,21 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
     case 'literal':
       return emitter.literal(expr.value, expr.literalType)
     case 'call': {
+      // #2843: a registered lowering plugin's call wins in EVERY value
+      // position this dispatcher reaches, not only an adapter's own
+      // top-level conversion entry point — see `LoweringEmitter`'s doc.
+      // First-match-wins; a matched node whose `render` declines (helper id
+      // this adapter has no mapping for) falls through to the ordinary
+      // dispatch below, same as an unmatched call.
+      if (emitter.lowering) {
+        for (const matcher of emitter.lowering.matchers) {
+          const node = matcher(expr.callee, expr.args)
+          if (!node) continue
+          const rendered = emitter.lowering.render(node, emit)
+          if (rendered !== null) return rendered
+          break
+        }
+      }
       // A higher-order callback call (`arr.filter(p)` / `arr.sort(cmp)` / …)
       // routes to the dedicated `callbackMethod` arm; any other call is generic.
       const cb = asCallbackMethodCall(expr)