@barefootjs/jsx 0.33.4 → 0.34.0

package/src/__tests__/issue-2806-rest-bag-template-rewrite.test.ts

@@ -0,0 +1,136 @@
+/**
+ * #2806 — a component reading its own rest-bag spread directly in JSX
+ * (`{rest.header}`, not spread onto an element's attrs) emitted a CSR
+ * template that referenced the bare, unbound `rest` identifier.
+ *
+ * The rest binding IS `_p` at runtime (`applyRestAttrs` excludes the
+ * consumed keys by name rather than constructing a narrower object, and
+ * the init body already rewrites `rest.x` → `_p.x` via
+ * `rewritePropsObjectRef`, #2723). The four CSR/static template builders
+ * in `html-template.ts` each call that same function for `propsObjectName`
+ * but were passing `null` for the rest name, so a direct rest-bag read
+ * never got the same treatment there.
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function clientJs(source: string): string {
+  const result = compileJSX(source, 'Repro.tsx', { adapter })
+  expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  return result.files.find(f => f.type === 'clientJs')!.content
+}
+
+describe('#2806 — rest-bag identifier resolves in the CSR template', () => {
+  test('a direct rest-bag read in a text expression emits `_p.x`, not bare `rest`', () => {
+    const content = clientJs(`
+      "use client";
+      import { createSignal } from '@barefootjs/client'
+      export function Card({ children, ...rest }: { children?: any; [key: string]: any }) {
+        const [cond, setCond] = createSignal(true)
+        return (
+          <section>
+            <header>{cond() ? rest.header : null}</header>
+            <div>{children}</div>
+          </section>
+        )
+      }
+    `)
+    expect(content).toContain('_p.header')
+    expect(content).not.toMatch(/[^.\w]rest\.header/)
+  })
+
+  test('a rest-bag read inside a `.map()` row still resolves', () => {
+    // NOTE: `rest.items ?? []` is classified `isStaticArray` here (no signal,
+    // no `isArrayExprDirectPropRef` match — see `jsx-to-ir.ts`'s `isStaticArray`
+    // derivation), so this row is emitted through `buildStaticLoopPlan`'s
+    // SSR-time-only `forEach`, NOT through the reactive `mapArray`/`mapArrayLazy`
+    // loop emitters. It does not exercise those two paths — the tests below do.
+    const content = clientJs(`
+      "use client";
+      export function Row({ children, ...rest }: { children?: any; items?: Array<{ id: number }>; [key: string]: any }) {
+        return (
+          <ul>
+            {(rest.items ?? []).map((item: { id: number }) => (
+              <li key={item.id}>{rest.suffix}</li>
+            ))}
+          </ul>
+        )
+      }
+    `)
+    expect(content).toContain('_p.suffix')
+    expect(content).not.toMatch(/[^.\w]rest\.suffix/)
+  })
+
+  test('a rest-bag read inside a lazy-eligible `.map()` row resolves (`mapArrayLazy`)', () => {
+    // Signal-backed source + a keyed, single-root, child-component-free row
+    // is lazy-eligible (`lazyRowEligibility`), so this hits the `createRow`/
+    // `applyOuter` bodies emitted by `stringify/lazy-row.ts` — a SEPARATE
+    // emitter from the whole-init-body rewrite the other tests here exercise
+    // only incidentally through the eager `mapArray` row body.
+    const content = clientJs(`
+      "use client";
+      import { createSignal } from '@barefootjs/client'
+      export function Row({ children, ...rest }: { children?: any; [key: string]: any }) {
+        const [items, setItems] = createSignal<{ id: number }[]>([])
+        return (
+          <ul>
+            {items().map((item: { id: number }) => (
+              <li key={item.id}>{item.id}{rest.suffix}</li>
+            ))}
+          </ul>
+        )
+      }
+    `)
+    expect(content).toContain('mapArrayLazy')
+    expect(content).toContain('_p.suffix')
+    expect(content).not.toMatch(/[^.\w]rest\.suffix/)
+  })
+
+  test('a rest-bag read inside an eager `.map()` row with a child component resolves (`mapArray`)', () => {
+    // A child component in the row forces eager `mapArray` eligibility
+    // (`lazyRowEligibility`'s `hasChildComponent` gate) — the loop-row-body
+    // emission path #2812 actually fixed (the `hydrate(... template: ...)`
+    // line and the CSR/static template builders in `html-template.ts`).
+    const content = clientJs(`
+      "use client";
+      import { createSignal } from '@barefootjs/client'
+      function Item(props: { id: number }) {
+        return <span>{props.id}</span>
+      }
+      export function Row({ children, ...rest }: { children?: any; [key: string]: any }) {
+        const [items, setItems] = createSignal<{ id: number }[]>([])
+        return (
+          <ul>
+            {items().map((item: { id: number }) => (
+              <li key={item.id}><Item id={item.id} />{rest.suffix}</li>
+            ))}
+          </ul>
+        )
+      }
+    `)
+    expect(content).toContain('mapArray(')
+    expect(content).toContain('_p.suffix')
+    expect(content).not.toMatch(/[^.\w]rest\.suffix/)
+  })
+
+  test('a `.map()` row PARAMETER literally named `rest` is not rewritten (shadow guard)', () => {
+    const content = clientJs(`
+      "use client";
+      export function List({ children, ...outer }: { children?: any; [key: string]: any }) {
+        const rows = [{ id: 1, name: 'a' }]
+        return (
+          <ul>
+            {rows.map(rest => (
+              <li key={rest.id}>{rest.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `)
+    expect(content).not.toContain('_p.name')
+    expect(content).toContain('rest.name')
+  })
+})

package/src/__tests__/issue-2835-props-type-member-name-collision.test.ts

@@ -0,0 +1,259 @@
+/**
+ * #2835 — `isDirectPropBindingName` (jsx-to-ir.ts) checked `ctx.patterns.props`,
+ * a regex-matching set that, for a whole `(props: Props)` parameter, includes
+ * every one of `Props`'s type-member names regardless of whether that name is
+ * bound to anything in the current component (`extractPropsFromTypeMembers`,
+ * analyzer.ts — needed there so `props.<key>` still regex-matches). Reused as
+ * a "is this name a prop binding" check, that over-inclusion let an unrelated
+ * module/local identifier resolve as prop-derived purely by sharing a type
+ * member's name, with zero aliasing involved (reproduces identically on
+ * pre-#2724 `main`).
+ *
+ * Fix: `isDirectPropBindingName` now reads `ctx.boundPropNames`
+ * (`boundPropLocalNames`, `props-binding.ts`) — empty for a whole
+ * non-destructured props parameter, since `propsParams` there is type-member
+ * names, not local bindings.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { TestAdapter } from '../adapters/test-adapter'
+import type { IRNode } from '../types'
+
+const adapter = new TestAdapter()
+
+function getClientJs(source: string, filename: string): string {
+  const result = compileJSX(source, filename, { 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
+}
+
+/** First `IRLoop` node found in a DFS of the component IR. */
+function findLoop(node: IRNode | null, predicate: (n: any) => boolean = () => true): any {
+  if (!node || typeof node !== 'object') return undefined
+  if ((node as any).type === 'loop' && predicate(node)) return node
+  for (const key of Object.keys(node)) {
+    const v = (node as any)[key]
+    if (Array.isArray(v)) {
+      for (const c of v) {
+        const found = findLoop(c, predicate)
+        if (found) return found
+      }
+    } else if (v && typeof v === 'object') {
+      const found = findLoop(v, predicate)
+      if (found) return found
+    }
+  }
+  return undefined
+}
+
+/** First element node with a non-null `slotId`, found in a DFS of the IR. */
+function findSlottedElement(node: IRNode | null): any {
+  if (!node || typeof node !== 'object') return undefined
+  if ((node as any).type === 'element' && (node as any).slotId) return node
+  for (const key of Object.keys(node)) {
+    const v = (node as any)[key]
+    if (Array.isArray(v)) {
+      for (const c of v) {
+        const found = findSlottedElement(c)
+        if (found) return found
+      }
+    } else if (v && typeof v === 'object') {
+      const found = findSlottedElement(v)
+      if (found) return found
+    }
+  }
+  return undefined
+}
+
+function loopFlags(source: string, filename: string, predicate?: (n: any) => boolean) {
+  const ctx = analyzeComponent(source, filename, 'List')
+  const ir = jsxToIR(ctx)
+  expect(ir).not.toBeNull()
+  const loop = findLoop(ir, predicate)
+  expect(loop).toBeDefined()
+  return { isStaticArray: loop.isStaticArray as boolean, isPropDerivedArray: loop.isPropDerivedArray as boolean | undefined }
+}
+
+const CHILD = `
+  type ItemProps = { label: string }
+  function Item(props: ItemProps) {
+    const [on, setOn] = createSignal(false)
+    return <button onClick={() => setOn(!on())}>{props.label}: {on() ? 'ON' : 'OFF'}</button>
+  }
+`
+
+describe('#2835 — name collision with a whole-props type member is not prop-derived', () => {
+  test('headline: a module const colliding with `Props.base` stays static (type alias)', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      type Props = { base: ItemProps[] }
+      export function List(props: Props) {
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'ModuleConstCollision.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('same collision with `interface Props`', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      interface Props { base: ItemProps[] }
+      export function List(props: Props) {
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'InterfaceCollision.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('same collision with an inline type-literal props annotation', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      export function List(props: { base: ItemProps[] }) {
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'InlineTypeCollision.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('a component-local const literal colliding with a type member also stays static (not reachable via Go BF101 either — bakedChildLoop screens it out first)', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      type Props = { base: ItemProps[] }
+      export function List(props: Props) {
+        const base = [{ label: 'z' }]
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'LocalConstCollision.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('the collision survives an alias hop', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      type Props = { base: ItemProps[] }
+      export function List(props: Props) {
+        const b = base
+        return <div>{b.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'AliasedCollision.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('regression guard: destructured props still resolve to mapArray', () => {
+    const clientJs = getClientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      ${CHILD}
+      type Props = { base: ItemProps[] }
+      export function List({ base }: Props) {
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'DestructuredRegression.tsx')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
+    expect(clientJs).not.toMatch(/qsaChildScopes\(/)
+  })
+
+  test('regression guard: a renamed destructure ({ base: rows }) still resolves to mapArray', () => {
+    const clientJs = getClientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      ${CHILD}
+      type Props = { base: ItemProps[] }
+      export function List({ base: rows }: Props) {
+        return <div>{rows.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'RenamedDestructureRegression.tsx')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
+    expect(clientJs).not.toMatch(/qsaChildScopes\(/)
+  })
+
+  test('regression guard: a renamed destructure keeps a same-named module const static (no name collision through the rename)', () => {
+    const flags = loopFlags(`
+      'use client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      type Props = { base: ItemProps[] }
+      export function List({ base: rows }: Props) {
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'RenamedDestructureModuleConst.tsx')
+    expect(flags.isStaticArray).toBe(true)
+    expect(flags.isPropDerivedArray).toBeUndefined()
+  })
+
+  test('regression guard: whole-props body destructure (`const { base } = props`) still resolves to mapArray via `.parsed`, not the name-only branch', () => {
+    const clientJs = getClientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      ${CHILD}
+      type Props = { base: ItemProps[] }
+      export function List(props: Props) {
+        const { base } = props
+        return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'WholePropsBodyDestructure.tsx')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
+    expect(clientJs).not.toMatch(/qsaChildScopes\(/)
+  })
+
+  test('regression guard: direct `props.base` access still resolves to mapArray', () => {
+    const clientJs = getClientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      ${CHILD}
+      type Props = { base: ItemProps[] }
+      export function List(props: Props) {
+        return <div>{props.base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'DirectMemberAccessRegression.tsx')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
+    expect(clientJs).not.toMatch(/qsaChildScopes\(/)
+  })
+
+  test('regression guard: a rest-spread sibling name is unaffected (no collision to guard against)', () => {
+    const clientJs = getClientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      ${CHILD}
+      const base = [{ label: 'z' }]
+      type Props = { other: string; base: ItemProps[] }
+      export function List({ other, ...rest }: Props) {
+        return <div>{other}{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+      }
+    `, 'RestSpreadSibling.tsx')
+    expect(clientJs).not.toMatch(/\bmapArray(Lazy)?\s*\(/)
+  })
+
+  test('non-impact pin: `ctx.patterns.props`\' regex detection of `props.<key>` in a whole-props component is unaffected — the element still gets a slot id', () => {
+    const ctx = analyzeComponent(`
+      'use client'
+      type Props = { base: { label: string }[] }
+      export function List(props: Props) {
+        return <div class={props.base.length ? 'a' : 'b'}>static</div>
+      }
+    `, 'NonImpactPin.tsx', 'List')
+    const ir = jsxToIR(ctx)
+    const el = findSlottedElement(ir)
+    expect(el).toBeDefined()
+    expect(el.slotId).not.toBeNull()
+  })
+})

package/src/__tests__/loop-item-root-scope.test.ts

@@ -185,7 +185,7 @@ describe('IRComponent.loopItemRoot (#2444)', () => {
     expect(clientJs!.content).toMatch(/renderChild\('Badge[^']*',\s*\{text:\s*row\.label\},\s*undefined,\s*'s\d+'\)/)
   })
 
-  test('CSR template: a component that IS the loop row root gets no slot suffix', () => {
+  test('CSR template: a component that IS the loop row root still passes its slot id, with the loopItemRoot flag (#2833)', () => {
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -207,7 +207,11 @@ describe('IRComponent.loopItemRoot (#2444)', () => {
     expect(result.errors).toHaveLength(0)
     const clientJs = result.files.find(f => f.type === 'clientJs')
     expect(clientJs).toBeDefined()
-    // Static-array loop item root: no slot suffix — it owns its own random id.
-    expect(clientJs!.content).not.toMatch(/renderChild\('row',[^)]*'s\d+'\)/)
+    // A row root still doesn't DERIVE its scope from the slot (no `_sN`
+    // scope-id suffix elsewhere in this file's other assertions), but it
+    // must keep slot identity — a pure-CSR mount's static init selector
+    // depends on the `bf-h`/`bf-m` this renders, per `renderChild`'s
+    // `loopItemRoot` param docstring (component.ts).
+    expect(clientJs!.content).toMatch(/renderChild\('Row[^']*',\s*\{label: row\.label\},\s*row\.id,\s*'s\d+',\s*true\)/)
   })
 })

package/src/__tests__/lowering-value-position.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Registered-lowering recognition at ANY value position (#2843), not only
+ * a call's own top-level entry point. Two independent seams share this
+ * shared-layer test:
+ *
+ *  - the SUPPORT GATE (`isSupported`/`isSupportedValue`, `expression-parser.ts`),
+ *    which must admit a matched call's own params — even an `object-literal`,
+ *    normally refused at `rendered` position — wherever it's nested
+ *    (a ternary branch, a template-literal interpolation, a binary operand),
+ *    by re-checking the neutral node's `loweringNodeChildren` instead of the
+ *    call's raw `args`;
+ *  - the shared `emitParsedExpr` DISPATCHER (`parsed-expr-emitter.ts`), whose
+ *    `call` case now tries an emitter's optional `lowering` seam before its
+ *    ordinary `call()`/`callbackMethod` dispatch, so an adapter that adopts
+ *    it renders the matched node correctly at any nesting depth too.
+ *
+ * Uses a standalone SAMPLE plugin (independent of `queryHref`) so these tests
+ * exercise the mechanism itself, mirroring `lowering-registry.test.ts`.
+ */
+
+import { describe, test, expect, afterEach } from 'bun:test'
+import {
+  registerLoweringPlugin,
+  getLoweringPlugins,
+  prepareLoweringMatchers,
+  __resetLoweringPluginsForTest,
+  isSupported,
+  isSupportedValue,
+  emitParsedExpr,
+  type LoweringPlugin,
+  type LoweringEmitter,
+  type ParsedExprEmitter,
+  type IRMetadata,
+  type ParsedExpr,
+} from '../index'
+
+// A minimal sample plugin: active only when the component imports anything
+// from `@sample/pkg`, lowering `demo(base, { … })` to a neutral `guard-list`
+// on the `query` helper — the exact shape `queryHref` produces, so these
+// tests exercise the same object-literal-admission path #2743/#2841 needed.
+const samplePlugin: LoweringPlugin = {
+  name: 'sample-value-position-demo',
+  prepare(metadata) {
+    const active = metadata.imports.some(i => i.source === '@sample/pkg' && !i.isTypeOnly)
+    if (!active) return null
+    return (callee, args) => {
+      if (callee.kind !== 'identifier' || callee.name !== 'demo') return null
+      const [base, obj] = args
+      if (!base || obj?.kind !== 'object-literal') return null
+      return {
+        kind: 'guard-list',
+        helper: 'query',
+        base,
+        triples: obj.properties
+          .filter((p): p is Extract<typeof p, { kind: 'prop' }> => p.kind === 'prop')
+          .map(p => ({ guard: null, key: p.key, value: p.value })),
+      }
+    }
+  },
+}
+
+function metadataImporting(source: string): IRMetadata {
+  return { imports: [{ source, isTypeOnly: false, specifiers: [] }] } as unknown as IRMetadata
+}
+
+afterEach(() => {
+  const remaining = getLoweringPlugins().filter(p => p.name !== 'sample-value-position-demo')
+  __resetLoweringPluginsForTest(remaining)
+})
+
+const base = { kind: 'literal', value: '/x', literalType: 'string' } as ParsedExpr
+const tagValue = { kind: 'literal', value: 'a', literalType: 'string' } as ParsedExpr
+const paramsObj = {
+  kind: 'object-literal',
+  raw: '{ tag: "a" }',
+  properties: [{ kind: 'prop', key: 'tag', shorthand: false, value: tagValue }],
+} as ParsedExpr
+const demoCall = { kind: 'call', callee: { kind: 'identifier', name: 'demo' }, args: [base, paramsObj] } as ParsedExpr
+
+function matchers(): ReturnType<typeof prepareLoweringMatchers> {
+  registerLoweringPlugin(samplePlugin)
+  return prepareLoweringMatchers(metadataImporting('@sample/pkg'))
+}
+
+describe('isSupported / isSupportedValue with loweringMatchers (#2843)', () => {
+  test('a matched call nested in a conditional branch is admitted at rendered position', () => {
+    const ms = matchers()
+    const cond: ParsedExpr = {
+      kind: 'conditional',
+      test: { kind: 'identifier', name: 'ok' },
+      consequent: demoCall,
+      alternate: { kind: 'literal', value: '/fallback', literalType: 'string' },
+    }
+    expect(isSupported(cond, { loweringMatchers: ms }).supported).toBe(true)
+    // Without matchers, the same tree is refused (the object-literal arg).
+    expect(isSupported(cond).supported).toBe(false)
+  })
+
+  test('a matched call nested in a logical operand is admitted', () => {
+    const ms = matchers()
+    const logical: ParsedExpr = {
+      kind: 'logical',
+      op: '||',
+      left: demoCall,
+      right: { kind: 'literal', value: '/fallback', literalType: 'string' },
+    }
+    expect(isSupported(logical, { loweringMatchers: ms }).supported).toBe(true)
+  })
+
+  test('a matched call nested in a template-literal interpolation is admitted', () => {
+    const ms = matchers()
+    const tmpl: ParsedExpr = {
+      kind: 'template-literal',
+      parts: [
+        { type: 'string', value: 'pre ' },
+        { type: 'expression', expr: demoCall },
+      ],
+    }
+    expect(isSupported(tmpl, { loweringMatchers: ms }).supported).toBe(true)
+  })
+
+  test('an unmatched call inside the same shapes still refuses (no regression)', () => {
+    const ms = matchers()
+    const unmatchedCall: ParsedExpr = {
+      kind: 'call',
+      callee: { kind: 'identifier', name: 'other' },
+      args: [base, paramsObj],
+    }
+    const cond: ParsedExpr = {
+      kind: 'conditional',
+      test: { kind: 'identifier', name: 'ok' },
+      consequent: unmatchedCall,
+      alternate: { kind: 'literal', value: '/fallback', literalType: 'string' },
+    }
+    expect(isSupported(cond, { loweringMatchers: ms }).supported).toBe(false)
+  })
+
+  test('a matched call whose own child is unsupported still refuses, loudly (sound-or-loud)', () => {
+    const ms = matchers()
+    // The value of the one triple is itself an unsupported node (a bare
+    // arrow function) — the plugin's node still carries it as a child, so
+    // it must still be checked, not silently passed through.
+    const arrow: ParsedExpr = { kind: 'arrow', params: ['x'], body: { kind: 'identifier', name: 'x' } }
+    const badParams = {
+      kind: 'object-literal',
+      raw: '{ tag: (x) => x }',
+      properties: [{ kind: 'prop', key: 'tag', shorthand: false, value: arrow }],
+    } as ParsedExpr
+    const badCall: ParsedExpr = {
+      kind: 'call',
+      callee: { kind: 'identifier', name: 'demo' },
+      args: [base, badParams],
+    }
+    expect(isSupported(badCall, { loweringMatchers: ms }).supported).toBe(false)
+  })
+
+  test('isSupportedValue behaves the same way as isSupported for a matched nested call', () => {
+    const ms = matchers()
+    const cond: ParsedExpr = {
+      kind: 'conditional',
+      test: { kind: 'identifier', name: 'ok' },
+      consequent: demoCall,
+      alternate: { kind: 'literal', value: '/fallback', literalType: 'string' },
+    }
+    expect(isSupportedValue(cond, { loweringMatchers: ms }).supported).toBe(true)
+  })
+})
+
+describe('emitParsedExpr dispatch with an emitter.lowering seam (#2843)', () => {
+  // A stub emitter exercising only what the `call` case needs; every other
+  // method throws so an accidental fallthrough fails loudly in the test.
+  function stubEmitter(lowering?: LoweringEmitter): ParsedExprEmitter {
+    const unimplemented = (name: string) => () => {
+      throw new Error(`unexpected emitter.${name} call in this test`)
+    }
+    return {
+      identifier: (name: string) => `ID(${name})`,
+      literal: (v) => `LIT(${JSON.stringify(v)})`,
+      call: (callee, args, emit) => `CALL(${emit(callee)}, ${args.map(emit).join(', ')})`,
+      member: unimplemented('member'),
+      indexAccess: unimplemented('indexAccess'),
+      binary: unimplemented('binary'),
+      unary: unimplemented('unary'),
+      logical: unimplemented('logical'),
+      conditional: unimplemented('conditional'),
+      templateLiteral: unimplemented('templateLiteral'),
+      callbackMethod: unimplemented('callbackMethod'),
+      arrow: unimplemented('arrow'),
+      regex: unimplemented('regex'),
+      arrayLiteral: unimplemented('arrayLiteral'),
+      objectLiteral: (_props, raw) => `OBJ(${raw})`,
+      arrayMethod: unimplemented('arrayMethod'),
+      flatMethod: unimplemented('flatMethod'),
+      unsupported: (raw) => `UNSUPPORTED(${raw})`,
+      lowering,
+    }
+  }
+
+  test('a matched call renders via emitter.lowering.render, not the ordinary call() dispatch', () => {
+    const ms = matchers()
+    const lowering: LoweringEmitter = {
+      matchers: ms,
+      render: (node, emit) => {
+        if (node.kind !== 'guard-list') return null
+        const parts = node.triples.map(t => `${t.key}=${emit(t.value)}`).join('&')
+        return `QUERY(${emit(node.base)}, ${parts})`
+      },
+    }
+    expect(emitParsedExpr(demoCall, stubEmitter(lowering))).toBe('QUERY(LIT("/x"), tag=LIT("a"))')
+  })
+
+  test('without emitter.lowering, the same call falls through to the ordinary call() dispatch', () => {
+    expect(emitParsedExpr(demoCall, stubEmitter())).toBe('CALL(ID(demo), LIT("/x"), OBJ({ tag: "a" }))')
+  })
+
+  test('lowering present but the node kind/helper has no mapping falls through to call()', () => {
+    const ms = matchers()
+    const lowering: LoweringEmitter = { matchers: ms, render: () => null }
+    expect(emitParsedExpr(demoCall, stubEmitter(lowering))).toBe('CALL(ID(demo), LIT("/x"), OBJ({ tag: "a" }))')
+  })
+
+  test('an unmatched call is unaffected by an emitter.lowering seam', () => {
+    const ms = matchers()
+    const lowering: LoweringEmitter = { matchers: ms, render: () => 'SHOULD NOT BE REACHED' }
+    const unmatchedCall: ParsedExpr = {
+      kind: 'call',
+      callee: { kind: 'identifier', name: 'other' },
+      args: [base],
+    }
+    expect(emitParsedExpr(unmatchedCall, stubEmitter(lowering))).toBe('CALL(ID(other), LIT("/x"))')
+  })
+})