@barefootjs/jsx 0.26.2 → 0.26.3

package/src/__tests__/map-body-no-silent-divergence.test.ts

@@ -0,0 +1,360 @@
+/**
+ * The no-silent-divergence trichotomy, made executable (Stage 3 root cure,
+ * spec/callback-fidelity.md).
+ *
+ * For EVERY `.map()` callback body shape, exactly one of these must hold:
+ *   1. it compiles clean AND the emitted client bundle is sound
+ *      (parses as plain JS, no raw JSX, no compiler-internal sentinel), or
+ *   2. the compiler raises a BF error (loud, actionable refusal).
+ *
+ * A shape that compiles clean but emits a broken bundle is a SILENT HOLE —
+ * the failure class this harness exists to make impossible to reintroduce.
+ * Shapes cannot be enumerated; axes can. The matrix below sweeps:
+ *
+ *   - return kind: single element / fragment / bare identifier / ternary
+ *   - loop position: top-level / nested inner map / conditional branch
+ *   - array kind: prop / module-scope const / signal
+ *   - leaf content: static+interpolation / event handler / component
+ *   - adapter tier: JS runtime / DSL (acceptsCallbackBody = false)
+ *
+ * `KNOWN_HOLES` pins the exact current reality: entries are shapes that are
+ * silent holes TODAY, tracked so the set only ever shrinks. A fixed hole must
+ * be removed from the set (the test fails if a listed hole stops leaking —
+ * no stale entries). The root-cure commits drive this set to empty; it must
+ * never grow.
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+import ts from 'typescript'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+// Arm the getJS trust-boundary assertion (analyzer-context.ts) for THIS
+// file's compiles only: any getJS call on a JSX-bearing node throws instead
+// of splicing raw JSX into output. Scoped via beforeAll/afterAll because bun
+// runs suite files in one process — a module-scope assignment would leak the
+// assertion into every later file and fail pre-existing raw-JSX-via-getJS
+// paths outside this harness's axes (e.g. the Array.from mapper lowering),
+// which are tracked for their own segments migration rather than pinned here.
+let prevAssertEnv: string | undefined
+beforeAll(() => {
+  prevAssertEnv = process.env.BF_ASSERT_NO_JSX_IN_GETJS
+  process.env.BF_ASSERT_NO_JSX_IN_GETJS = '1'
+})
+afterAll(() => {
+  if (prevAssertEnv === undefined) delete process.env.BF_ASSERT_NO_JSX_IN_GETJS
+  else process.env.BF_ASSERT_NO_JSX_IN_GETJS = prevAssertEnv
+})
+
+interface Shape {
+  id: string
+  source: string
+  /** Run on the DSL tier too (default: JS runtime only). */
+  dslTier?: boolean
+}
+
+/** Shapes that are silent holes today. Shrink-only — never add entries. */
+// EMPTY — and it must stay that way. The structured-preamble migration healed
+// the multi-root, nested-inner-map, and branch-loop holes by construction
+// (every plan builder renders through the single `renderPreamble` door), and
+// the Phase-1 acceptance guard closed the return-shape holes (bare identifier,
+// ternary: no single element root → loud BF021 with restructuring guidance).
+// A future entry here means a NEW silent hole shipped: fix the leak, don't
+// grow the set.
+const KNOWN_HOLES: ReadonlySet<string> = new Set([])
+
+const shapes: Shape[] = [
+  {
+    id: 'canonical-array-builder',
+    dslTier: true,
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'while-push-builder',
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    let i = 0
+    while (i < r.cells.length) { out.push(<td>{r.cells[i]}</td>); i++ }
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'conditional-push-builder',
+    source: `
+function T({ rows }: { rows: { id: string; on: boolean; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) if (r.on) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'return-bare-identifier',
+    dslTier: true,
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <ul>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<li key={r.id + c}>{c}</li>)
+    return out
+  })}</ul>
+}
+export { T }`,
+  },
+  {
+    id: 'return-multi-root-fragment',
+    dslTier: true,
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const extra = <td>x</td>
+    return <>{r.cells.map((c) => <td key={c}>{c}</td>)}{extra}</>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'return-ternary-after-builder',
+    source: `
+function T({ rows }: { rows: { id: string; on: boolean; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return r.on ? <tr key={r.id}>{out}</tr> : <tr key={r.id}><td>off</td></tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'nested-inner-map-builder',
+    source: `
+function T({ groups }: { groups: { id: string; rows: { id: string; cells: string[] }[] }[] }) {
+  return <div>{groups.map((g) => (
+    <table key={g.id}><tbody>{g.rows.map((r) => {
+      const out = []
+      for (const c of r.cells) out.push(<td>{c}</td>)
+      return <tr key={r.id}>{out}</tr>
+    })}</tbody></table>
+  ))}</div>
+}
+export { T }`,
+  },
+  {
+    id: 'branch-loop-builder',
+    source: `
+'use client'
+import { createSignal } from '@barefootjs/client'
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  const [show] = createSignal(true)
+  return <div>{show() ? <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table> : <p>none</p>}</div>
+}
+export { T }`,
+  },
+  {
+    id: 'static-module-const-array-builder',
+    source: `
+const ROWS = [{ id: '1', cells: ['a', 'b'] }, { id: '2', cells: ['c'] }]
+function T() {
+  return <table><tbody>{ROWS.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'signal-array-builder',
+    source: `
+'use client'
+import { createSignal } from '@barefootjs/client'
+function T() {
+  const [rows] = createSignal([{ id: '1', cells: ['a'] }])
+  return <table><tbody>{rows().map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'leaf-with-event-handler',
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td onClick={() => console.log(c)}>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'component-root-builder',
+    // Builder preamble + component root: the component would receive raw HTML
+    // strings on the client but JSX elements at SSR — refused (dom-ops row
+    // construction cannot host a string-lowered preamble).
+    source: `
+import { Row } from './row'
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <Row key={r.id} cells={out} />
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'leaf-with-component',
+    source: `
+import { Badge } from './badge'
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td><Badge label={c} /></td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+  {
+    id: 'flatmap-block-body',
+    // flatMap block bodies ride the same segments + renderPreamble machinery.
+    source: `
+function T({ items }: { items: { id: string; tags: string[] }[] }) {
+  return <ul>{items.flatMap((it) => {
+    return it.tags.map((t) => <li key={t}>{t}</li>)
+  })}</ul>
+}
+export { T }`,
+  },
+  {
+    id: 'flatmap-nested-in-map',
+    source: `
+function T({ groups }: { groups: { id: string; items: { id: string; tags: string[] }[] }[] }) {
+  return <div>{groups.map((g) => (
+    <ul key={g.id}>{g.items.flatMap((it) => {
+      return it.tags.map((t) => <li key={t}>{t}</li>)
+    })}</ul>
+  ))}</div>
+}
+export { T }`,
+  },
+  {
+    id: 'flatmap-leaf-in-template-literal',
+    // A leaf inside a template literal is refused (segment boundary would
+    // split the literal's lexical state) — same rule as map preambles.
+    source: `
+function T({ items }: { items: { id: string }[] }) {
+  return <ul>{items.flatMap((it) => {
+    const s = \`x\${<b>{it.id}</b>}\`
+    return [<li key={it.id}>{s}</li>]
+  })}</ul>
+}
+export { T }`,
+  },
+  {
+    id: 'value-only-preamble',
+    dslTier: true,
+    source: `
+function T({ items }: { items: { id: string; name: string }[] }) {
+  return <ul>{items.map((it) => {
+    const label = it.name.toUpperCase()
+    return <li key={it.id}>{label}</li>
+  })}</ul>
+}
+export { T }`,
+  },
+  {
+    id: 'client-marked-builder-on-dsl',
+    dslTier: true,
+    source: `
+function T({ rows }: { rows: { id: string; cells: string[] }[] }) {
+  return <table><tbody>{/* @client */ rows.map((r) => {
+    const out = []
+    for (const c of r.cells) out.push(<td>{c}</td>)
+    return <tr key={r.id}>{out}</tr>
+  })}</tbody></table>
+}
+export { T }`,
+  },
+]
+
+interface Soundness {
+  hasBfError: boolean
+  sentinelLeak: boolean
+  rawJsxLeak: boolean
+  parseErrors: number
+}
+
+function assess(source: string, dsl: boolean): Soundness {
+  const a = new TestAdapter()
+  if (dsl) a.acceptsCallbackBody = () => false
+  const r = compileJSX(source, 'T.tsx', { adapter: a })
+  const cj = r.files.find((f) => f.type === 'clientJs')?.content ?? ''
+
+  // Emitted client JS must be plain JS: parse it with JSX disabled and count
+  // syntactic diagnostics. Raw JSX (`out.push(<td>…)`) is not valid plain JS.
+  const sf = ts.createSourceFile('bundle.js', cj, ts.ScriptTarget.ES2022, /*setParentNodes*/ false, ts.ScriptKind.JS)
+  const parseErrors = (sf as unknown as { parseDiagnostics: unknown[] }).parseDiagnostics.length
+
+  return {
+    hasBfError: r.errors.some((e) => e.severity !== 'warning'),
+    sentinelLeak: /__BF_JSX_\d+__/.test(cj),
+    rawJsxLeak: /\bpush\(</.test(cj),
+    parseErrors,
+  }
+}
+
+function isSound(s: Soundness): boolean {
+  return !s.sentinelLeak && !s.rawJsxLeak && s.parseErrors === 0
+}
+
+describe('.map() body trichotomy — sound bundle XOR loud error, never silence', () => {
+  for (const shape of shapes) {
+    const tiers = shape.dslTier ? [false, true] : [false]
+    for (const dsl of tiers) {
+      const tier = dsl ? 'DSL' : 'JS-runtime'
+      // Holes are tracked on the JS-runtime tier (DSL refuses via gating).
+      const isKnownHole = !dsl && KNOWN_HOLES.has(shape.id)
+
+      test(`${shape.id} (${tier})${isKnownHole ? ' [known hole]' : ''}`, () => {
+        const s = assess(shape.source, dsl)
+        if (isKnownHole) {
+          // Pin the hole precisely: it must still be SILENT (no error) and
+          // UNSOUND. When a root-cure commit fixes it, this assertion fails,
+          // forcing the entry's removal — the set can only shrink.
+          expect(s.hasBfError).toBe(false)
+          expect(isSound(s)).toBe(false)
+        } else {
+          // The trichotomy: sound clean compile, or a loud error.
+          expect(s.hasBfError || isSound(s)).toBe(true)
+          if (s.hasBfError) {
+            // Even a refused compile must not leak the sentinel into output.
+            expect(s.sentinelLeak).toBe(false)
+          }
+        }
+      })
+    }
+  }
+})

package/src/__tests__/map-multi-return-body.test.ts

@@ -0,0 +1,172 @@
+/**
+ * Stage 2 of spec/callback-fidelity.md — folding a `.map()` callback whose
+ * body is an if/else-if chain or `switch` (including fallthrough case labels),
+ * optionally preceded by a leading-`const`/`let` preamble, into a nested
+ * `IRConditional`, instead of the prior silent verbatim leak. The preamble
+ * fold is adapter-gated: a JS runtime folds it, a DSL adapter refuses (BF021 +
+ * `/* @client *\/`). Also pins the conservative bail for shapes the fold can't
+ * carry — a branch-local local, or a preamble with a null-returning branch —
+ * so nothing is dropped silently.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { extractMultiReturnJsxBranches } from '../analyzer'
+import { TestAdapter } from '../adapters/test-adapter'
+import * as ts from 'typescript'
+
+const adapter = new TestAdapter()
+
+function clientJs(source: string): string {
+  const result = compileJSX(source, 'List.tsx', { adapter })
+  expect(result.errors).toHaveLength(0)
+  const cj = result.files.find(f => f.type === 'clientJs')
+  expect(cj).toBeDefined()
+  return cj!.content
+}
+
+const wrap = (body: string) => `
+function List({ items }: { items: { id: string; on: boolean; kind: string }[] }) {
+  return <ul>{items.map((it) => ${body})}</ul>
+}
+export { List }
+`
+
+describe('.map() multi-return body fold (Stage 2)', () => {
+  test('if/else-if chain folds to a conditional — no raw JSX leak', () => {
+    const js = clientJs(wrap(`{
+      if (it.kind === 'a') return <li key={it.id}>A</li>
+      else if (it.kind === 'b') return <li key={it.id}>B</li>
+      return <li key={it.id}>C</li>
+    }`))
+    // The raw \`if (...) return <li ...>\` must not survive into the callback.
+    expect(js).not.toMatch(/return <li/)
+    // A ternary chain over the branch conditions is emitted instead.
+    expect(js).toMatch(/kind === 'a'/)
+    expect(js).toMatch(/kind === 'b'/)
+  })
+
+  test('switch (with default) folds with a parenthesized strict-equality condition', () => {
+    const js = clientJs(wrap(`{
+      switch (it.kind) {
+        case 'a': return <b key={it.id}>A</b>
+        default: return <span key={it.id}>D</span>
+      }
+    }`))
+    expect(js).not.toMatch(/switch\s*\(/)
+    // Both operands parenthesized so a low-precedence case keeps === semantics.
+    expect(js).toMatch(/\(it\(\)\.kind\) === \('a'\)/)
+  })
+
+  test('switch with fallthrough case labels folds with an OR condition', () => {
+    const js = clientJs(wrap(`{
+      switch (it.kind) {
+        case 'a':
+        case 'b':
+          return <b key={it.id}>AB</b>
+        default:
+          return <span key={it.id}>D</span>
+      }
+    }`))
+    expect(js).not.toMatch(/switch\s*\(/)
+    expect(js).not.toMatch(/return <(b|span)/)
+    // Both fallthrough labels OR-joined into one branch condition.
+    expect(js).toMatch(/=== \('a'\)/)
+    expect(js).toMatch(/=== \('b'\)/)
+    expect(js).toMatch(/\|\|/)
+  })
+
+  describe('conservative bail — no silent drop', () => {
+    function extract(body: string, allowPreamble = false) {
+      const sf = ts.createSourceFile('t.tsx', `const f = (it: any) => ${body}`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+      let block: ts.Block | undefined
+      const visit = (n: ts.Node) => {
+        if (ts.isArrowFunction(n) && ts.isBlock(n.body)) block = n.body
+        ts.forEachChild(n, visit)
+      }
+      visit(sf)
+      return extractMultiReturnJsxBranches(block!, allowPreamble)
+    }
+
+    test('a branch-local const bails (would otherwise be dropped)', () => {
+      const r = extract(`{ if (it.on) { const x = it.kind; return <b>{x}</b> } return <span>Z</span> }`)
+      expect(r).toBeNull()
+    })
+
+    test('a switch case with an extra statement bails', () => {
+      const r = extract(`{ switch (it.kind) { case 'a': { const y = it.id; return <b>{y}</b> } default: return <span>D</span> } }`)
+      expect(r).toBeNull()
+    })
+
+    test('a switch case with a break before the return bails (return unreachable)', () => {
+      // `case 'a': break; return <A/>` — the break makes the return
+      // unreachable at runtime (the case exits to undefined), so it must not
+      // fold as if it rendered <A/>. (#2378 review.)
+      const r = extract(`{ switch (it.kind) { case 'a': break; return <b>A</b>; default: return <span>D</span> } }`)
+      expect(r).toBeNull()
+    })
+
+    test('a leading const is a preamble only when allowPreamble is set', () => {
+      const body = `{ const label = it.kind; if (it.on) return <b>{label}</b>; return <span>{label}</span> }`
+      // The helper-function inliner passes no allowPreamble — bails.
+      expect(extract(body)).toBeNull()
+      // The .map() body fold opts in — collects the leading const as a preamble.
+      const r = extract(body, true)
+      expect(r).not.toBeNull()
+      expect(r!.preamble?.length).toBe(1)
+    })
+
+    test('a leading `var` preamble is not collected (var hoisting semantics)', () => {
+      // Only `const`/`let` are collectable; `var` hoists differently, so the
+      // per-iteration preamble emit wouldn't preserve semantics. (#2379 review.)
+      const body = `{ var label = it.kind; if (it.on) return <b>{label}</b>; return <span>{label}</span> }`
+      expect(extract(body, true)).toBeNull()
+    })
+
+    test('a preamble with a null-returning branch bails (mapArrayAnchored hazard)', () => {
+      // `const f = …; if (!f) return null; return <div key={fid}>…</div>` — the
+      // null early-return routes the loop through the anchored conditional-item
+      // runtime, where a preamble local breaks keyed reactivity (the
+      // pivot-table demo shape). Fold only the all-JSX preamble case.
+      const body = `{ const f = it.field; if (!f) return null; return <div key={it.id}>{f}</div> }`
+      expect(extract(body, true)).toBeNull()
+    })
+  })
+
+  describe('leading-const preamble is adapter-gated (JS folds, DSL refuses)', () => {
+    const preambleBody = `{
+      const label = it.kind.toUpperCase()
+      if (it.on) return <b key={it.id}>{label}</b>
+      return <span key={it.id}>{label}</span>
+    }`
+
+    function compileWith(source: string, dsl: boolean) {
+      const a = new TestAdapter()
+      // Model a DSL adapter: its template runtime can't run a callback body
+      // verbatim, so `acceptsCallbackBody` reports false for every kind.
+      if (dsl) a.acceptsCallbackBody = () => false
+      return compileJSX(source, 'List.tsx', { adapter: a })
+    }
+
+    test('a JS-runtime adapter folds the preamble (const emitted, no error)', () => {
+      const r = compileWith(wrap(preambleBody), false)
+      expect(r.errors).toHaveLength(0)
+      const cj = r.files.find(f => f.type === 'clientJs')!
+      expect(cj.content).toMatch(/const label\b/)
+      expect(cj.content).not.toMatch(/return <(b|span)/)
+    })
+
+    test('a DSL adapter refuses with BF021 + the /* @client */ escape', () => {
+      const r = compileWith(wrap(preambleBody), true)
+      const bf021 = r.errors.filter(e => e.code === 'BF021')
+      expect(bf021).toHaveLength(1)
+      expect(bf021[0].suggestion?.message).toContain('@client')
+    })
+
+    test('/* @client */ suppresses the DSL refusal', () => {
+      const clientSource = wrap(preambleBody).replace('items.map', '/* @client */ items.map')
+      const r = compileWith(clientSource, true)
+      expect(r.errors.filter(e => e.code === 'BF021')).toHaveLength(0)
+    })
+  })
+})

package/src/__tests__/unsupported-expression.test.ts

@@ -125,13 +125,31 @@ describe('Unsupported Expression Error (BF021)', () => {
     expect(ir!.type).toBe('element')
   })
 
-  test('compileJSX includes IR-phase BF021 errors in result', () => {
-    const result = compileJSX(unsupportedSource, 'TodoList.tsx', { adapter })
+  test('compileJSX surfaces IR-phase BF021 for a DSL target (no acceptsCallbackBody)', () => {
+    // Model a DSL adapter: its template runtime can't run an off-subset
+    // predicate verbatim, so the Phase-1 diagnostic must surface in the result.
+    // Real DSL adapters leave `acceptsCallbackBody` unset; the gate
+    // (`?.(kind) ?? false`) treats unset and a false-returning predicate
+    // identically, so override it to decline every callback kind.
+    const dslAdapter = new TestAdapter()
+    dslAdapter.acceptsCallbackBody = () => false
+    const result = compileJSX(unsupportedSource, 'TodoList.tsx', { adapter: dslAdapter })
     const bf021 = result.errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
     expect(bf021).toHaveLength(1)
     expect(bf021[0].severity).toBe('error')
     expect(bf021[0].message).toContain('Expression cannot be compiled to marked template')
+    expect(bf021[0].suggestion?.message).toContain('@client')
+  })
+
+  test('compileJSX does NOT raise BF021 for a JS-runtime target (fidelity)', () => {
+    // A JS runtime (Hono / CSR — the default TestAdapter, extending JsxAdapter)
+    // runs the predicate verbatim, so an off-subset body is not a universal
+    // error. It stays in the array string for the runtime to evaluate.
+    // See spec/callback-fidelity.md.
+    const result = compileJSX(unsupportedSource, 'TodoList.tsx', { adapter })
+    const bf021 = result.errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+    expect(bf021).toHaveLength(0)
   })
 })
 

package/src/adapters/interface.ts

@@ -130,6 +130,37 @@ export type TemplatePrimitiveRegistry = Record<string, TemplatePrimitiveEmit>
  */
 export type TemplateCallAcceptor = (calleeName: string) => boolean
 
+/**
+ * The collection-method callbacks whose body the compiler may hand to a
+ * backend to run. Used by {@link CallbackBodyAcceptor}. See
+ * `spec/callback-fidelity.md`.
+ */
+export type CallbackBodyKind =
+  | 'filter'
+  | 'sort'
+  | 'map'
+  | 'flatMap'
+  | 'find'
+  | 'some'
+  | 'every'
+  | 'reduce'
+
+/**
+ * Predicate: can this adapter's runtime render an *off-subset* callback body
+ * of the given kind verbatim? A callback whose body the compiler can't express
+ * as a template / ParsedExpr subtree is only renderable at SSR by a backend
+ * whose template runtime is a full JS engine.
+ *
+ * JS-runtime adapters (Hono SSR, CSR — anything extending `JsxAdapter`) return
+ * true, so the compiler keeps the callback inlined for the runtime to execute
+ * instead of raising a universal Phase-1 diagnostic. DSL adapters (Go, Perl,
+ * …) leave this undefined; an off-subset body then raises the usual diagnostic
+ * with the `/* @client *\/` escape, and the user opts that piece into
+ * client-only rendering. Granular by kind so a DSL adapter may later accept a
+ * subset (e.g. `filter` but not `sort`). See `spec/callback-fidelity.md`.
+ */
+export type CallbackBodyAcceptor = (kind: CallbackBodyKind) => boolean
+
 export interface TemplateAdapter {
   name: string
   extension: string
@@ -201,6 +232,15 @@ export interface TemplateAdapter {
    */
   acceptsTemplateCall?: TemplateCallAcceptor
 
+  /**
+   * Whether this adapter's runtime can render an off-subset callback body
+   * (`filter`/`sort`/`find`/… predicate or comparator the compiler can't
+   * lower to a template / ParsedExpr) verbatim. JS-runtime adapters set this
+   * (via `JsxAdapter`); DSL adapters leave it undefined and instead surface
+   * the diagnostic + `/* @client *\/` escape. See `spec/callback-fidelity.md`.
+   */
+  acceptsCallbackBody?: CallbackBodyAcceptor
+
   // Main entry point - generates complete template from IR
   generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput
 

package/src/adapters/jsx-adapter.ts

@@ -12,6 +12,7 @@ import type {
 } from '../types.ts'
 import { BF_SCOPE, BF_SLOT, BF_COND } from '@barefootjs/shared'
 import { BaseAdapter } from './interface.ts'
+import type { CallbackBodyAcceptor } from './interface.ts'
 import { ENV_SIGNAL_CLIENT_FACTORY } from './env-signal.ts'
 import { formatParamWithType, findReachableNames } from '../module-exports.ts'
 
@@ -26,6 +27,15 @@ export abstract class JsxAdapter extends BaseAdapter {
   /** Subclasses define whether to use typed values for type-safe output */
   protected abstract jsxConfig: JsxAdapterConfig
 
+  /**
+   * JS-runtime adapters (Hono SSR, CSR, the test adapter) render an off-subset
+   * callback body by running it verbatim, so the compiler need not raise a
+   * universal Phase-1 diagnostic for a `filter`/`sort`/… body it can't lower.
+   * DSL adapters extend `BaseAdapter` and leave this undefined.
+   * See `spec/callback-fidelity.md`.
+   */
+  acceptsCallbackBody: CallbackBodyAcceptor = () => true
+
   // ===========================================================================
   // Import Formatting
   // ===========================================================================

package/src/adapters/loop-bound-names.ts

@@ -57,8 +57,12 @@ export function collectLoopBoundNames(ir: ComponentIR): Set<string> {
         for (const nested of node.nestedComponents ?? []) {
           for (const child of nested.children) visit(child)
         }
-        for (const frag of node.flatMapCallback?.fragments ?? []) {
-          visit(frag.ir)
+        for (const seg of node.flatMapCallback?.segments ?? []) {
+          if (seg.kind === 'jsx') visit(seg.ir)
+        }
+        // Preamble leaves (array-builder bodies) are nested IR the same way.
+        for (const seg of node.preamble?.segments ?? []) {
+          if (seg.kind === 'jsx') visit(seg.ir)
         }
         break
       case 'conditional':

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

@@ -87,16 +87,11 @@ export type ArrayMethod =
  */
 export type SortMethod = 'sort' | 'toSorted'
 
-/**
- * `reduce` / `reduceRight` are handled by the dedicated `reduceMethod()`
- * dispatcher arm (#1448 Tier C) for the same reason sort is: they carry
- * a structured `ReduceOp` (the parsed arithmetic-fold spec) rather than
- * a `ParsedExpr[]` args list, so folding them into `arrayMethod()` would
- * force a spec-or-args runtime check at every call site. The method name
- * is threaded through so adapters can pick the fold direction (left for
- * `reduce`, right for `reduceRight`).
- */
-export type ReduceMethod = 'reduce' | 'reduceRight'
+// NB: there is no structured `reduce` / `reduceRight` emitter type here.
+// #2018 P5 removed the folded `ReduceOp` form — a `.reduce(fn, init)` now
+// arrives as a generic `call` whose reducer body + initial value serialize
+// to the runtime evaluator, so no dedicated `reduceMethod()` dispatcher (or
+// `ReduceMethod` type) exists.
 
 export type LiteralType = 'string' | 'number' | 'boolean' | 'null'