@barefootjs/jsx 0.26.2 → 0.26.4

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__/preamble-region-patch.test.ts

@@ -0,0 +1,150 @@
+/**
+ * #2389 patch-on-update: a keyed `.map()` row body whose preamble builds
+ * content from item state (`const stateLabel = t.done ? ... ; const cells
+ * = []; cells.push(<td>{stateLabel}</td>)`) goes STALE on a same-key item
+ * update — `mapArray` reuses the row via per-item `setItem`, re-running
+ * only the row's wired text/attr slots. `{cells}` had no slot wiring at
+ * all, so it froze at its mount-time content forever while the sibling
+ * `{t.name}` text slot updated normally.
+ *
+ * The fix: a loop-body expression child whose free identifiers intersect
+ * the preamble's `declaredNames` is classified as a preamble-patched
+ * region — slot-marked like an ordinary reactive text (so SSR/CSR row
+ * templates render `<!--bf:sN-->...<!--/-->` / `{bfText("sN")}` the same
+ * door a reactive text uses), but wired on the client via a dedicated
+ * `patchSlotRange`-based region-patch effect rather than a `reactiveTexts`
+ * `.textContent` assignment (which would corrupt the array-joined markup).
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+import { HonoAdapter } from '../../../adapter-hono/src/index.ts'
+
+const ROW_SOURCE = `
+  'use client'
+  import { createSignal } from '@barefootjs/client'
+  export function Todos() {
+    const [todos, setTodos] = createSignal([
+      { id: 1, name: 'a', done: false },
+      { id: 2, name: 'b', done: false },
+    ])
+    const toggle = (id: number) =>
+      setTodos(todos().map(t => t.id === id ? { ...t, done: !t.done } : t))
+    return (
+      <table><tbody>
+        {todos().map((t) => {
+          const stateLabel = t.done ? 'done & dusted' : 'open'
+          const cells = []
+          cells.push(<td className="state">{stateLabel}</td>)
+          return (
+            <tr key={t.id}>
+              {cells}
+              <td>{t.name}</td>
+              <td><button onClick={() => toggle(t.id)}>toggle</button></td>
+            </tr>
+          )
+        })}
+      </tbody></table>
+    )
+  }
+`
+
+function compileWith(adapter: TestAdapter | HonoAdapter, source: string = ROW_SOURCE) {
+  const result = compileJSX(source, 'Todos.tsx', { adapter })
+  expect(result.errors.filter((e) => e.severity === 'error')).toHaveLength(0)
+  const clientJs = result.files.find((f) => f.type === 'clientJs')
+  const marked = result.files.find((f) => f.type === 'markedTemplate' || f.type === 'ssr')
+  expect(clientJs).toBeDefined()
+  return { clientJs: clientJs!.content, marked: marked?.content, result }
+}
+
+describe('preamble-region-patch (#2389)', () => {
+  test('(a) row template + SSR marked template both carry the region slot marker', () => {
+    const { clientJs } = compileWith(new TestAdapter())
+    // Row template (the `__tpl.innerHTML = ...` string literal inside
+    // renderItem): the region renders as a paired comment marker around the
+    // array-joined value, exactly like a reactive text slot.
+    expect(clientJs).toMatch(/<!--bf:s\d+-->\$\{Array\.isArray\(cells\) \? cells\.join\(''\) : \(cells \?\? ''\)\}<!--\/-->/)
+
+    const hono = compileWith(new HonoAdapter())
+    expect(hono.clientJs).toContain('patchSlotRange')
+    // Hono SSR renders the SAME slotId through `renderExpression`'s generic
+    // `{bfText("id")}...{bfTextEnd()}` door — no bespoke region handling.
+    const slotMatch = /<!--bf:(s\d+)-->\$\{Array\.isArray\(cells\)/.exec(hono.clientJs)
+    expect(slotMatch).not.toBeNull()
+    const slotId = slotMatch![1]
+    expect(hono.marked).toContain(`{bfText("${slotId}")}`)
+    expect(hono.marked).toContain('{cells}')
+    expect(hono.marked).toContain('{bfTextEnd()}')
+  })
+
+  test('(b) renderItem emits the region-patch effect, re-running the preamble in accessor form', () => {
+    const { clientJs } = compileWith(new TestAdapter())
+    expect(clientJs).toContain('patchSlotRange')
+    // The preamble re-runs inside the effect with the loop-param accessor
+    // wrap (`t().done`), not the plain (`t.done`) form used at the
+    // top-level construction line.
+    expect(clientJs).toMatch(/createEffect\(\(\) => \{\s*const stateLabel = t\(\)\.done/)
+    // First run only records (trusts SSR/CSR mount-time content); only a
+    // SUBSEQUENT change patches via patchSlotRange.
+    expect(clientJs).toMatch(/if \(__last_\w+ === undefined\) \{ __last_\w+ = __html_\w+; return \}/)
+    expect(clientJs).toMatch(/patchSlotRange\(__el, 's\d+', __html_\w+\)/)
+  })
+
+  test('(c) a loop without a preamble gets no region', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Plain() {
+        const [items, setItems] = createSignal([{ id: 1, name: 'a' }])
+        return <ul>{items().map(t => <li key={t.id}>{t.name}</li>)}</ul>
+      }
+    `
+    const { clientJs } = compileWith(new TestAdapter(), source)
+    expect(clientJs).not.toContain('patchSlotRange')
+  })
+
+  test('(c) a static-array loop with a preamble gets no region', () => {
+    const source = `
+      import { createSignal } from '@barefootjs/client'
+      const items = [{ id: 1, done: false }, { id: 2, done: true }]
+      export function StaticRows() {
+        return (
+          <table><tbody>
+            {items.map((t) => {
+              const stateLabel = t.done ? 'done' : 'open'
+              const cells = []
+              cells.push(<td>{stateLabel}</td>)
+              return <tr key={t.id}>{cells}<td>{t.id}</td></tr>
+            })}
+          </tbody></table>
+        )
+      }
+    `
+    const { clientJs } = compileWith(new TestAdapter(), source)
+    expect(clientJs).not.toContain('patchSlotRange')
+  })
+
+  test('(d) a preamble local never referenced by an expression child gets no region', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Unread() {
+        const [todos, setTodos] = createSignal([{ id: 1, name: 'a', done: false }])
+        return (
+          <ul>
+            {todos().map((t) => {
+              // Declared but never read as a bare expression child anywhere
+              // in the returned JSX — nothing qualifies for a region.
+              const stateLabel = t.done ? 'done' : 'open'
+              return <li key={t.id}>{t.name}</li>
+            })}
+          </ul>
+        )
+      }
+    `
+    const { clientJs } = compileWith(new TestAdapter(), source)
+    expect(clientJs).not.toContain('patchSlotRange')
+  })
+})

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

@@ -124,8 +124,9 @@ describe('#1247 — static-loop CSR self-heal', () => {
     const m = clientJs.match(/if \(!__iterEl\) \{[\s\S]*?\n\s+\}\n\s+if \(__iterEl\)/)
     expect(m).toBeTruthy()
     const block = m![0]
-    // The cloned template must reference `emoji` directly.
-    expect(block).toMatch(/\$\{emoji\}/)
+    // The cloned template must reference `emoji` directly (possibly through
+    // the escapeAttr/escapeText interpolation wrappers).
+    expect(block).toMatch(/\$\{(?:escape(?:Attr|Text)\()?emoji\)?\}/)
     // It must NOT reference `__bfItem()` — that accessor only exists
     // inside `mapArray` renderItems, not inside a plain forEach.
     expect(block).not.toMatch(/__bfItem\(\)/)

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'
 

package/src/adapters/test-adapter.ts

@@ -253,6 +253,16 @@ export class TestAdapter extends JsxAdapter {
     // parsed as a block statement (matches hono-adapter behavior).
     const safeChildren = children.startsWith('{') ? `<>${children}</>` : children
 
+    // A `.map()` callback preamble (a Stage-2 value-only `const`, or a Stage-3
+    // arbitrary array-builder) runs verbatim in the block body. Use the typed
+    // carrier so raw JSX leaves stay intact for the JSX runtime; `{out}`-style
+    // element-array children render natively. (Without this the preamble was
+    // dropped and its identifiers rendered unbound.)
+    const preamble = loop.preamble?.ssrText
+    if (preamble) {
+      return `{${loop.array}.map((${loop.param}${indexParam}) => { ${preamble} return ${safeChildren} })}`
+    }
+
     return `{${loop.array}.map((${loop.param}${indexParam}) => ${safeChildren})}`
   }
 

package/src/analyzer-context.ts

@@ -25,6 +25,7 @@ import type {
   DeclinedReactiveFactory,
 } from './types.ts'
 import { type ExcludeRange, collectAllTypeRanges, reconstructWithoutTypes } from './strip-types.ts'
+import type { CallbackBodyAcceptor } from './adapters/interface.ts'
 
 /**
  * Deferred info for BF043 (props destructuring warning).
@@ -199,6 +200,15 @@ export interface AnalyzerContext {
 
   // Errors
   errors: CompilerError[]
+  /**
+   * Capability of the adapter this component is being compiled for: can its
+   * runtime render an off-subset callback body (`filter`/`sort`/… predicate)
+   * verbatim? Set from `TemplateAdapter.acceptsCallbackBody`; undefined for
+   * direct analyzer callers (no adapter) and DSL adapters. Consulted at the
+   * Phase-1 callback-lowering sites so a JS-runtime target isn't rejected for
+   * a body it could run. See `spec/callback-fidelity.md`.
+   */
+  acceptsCallbackBody?: CallbackBodyAcceptor
 
   // Directive
   hasUseClientDirective: boolean
@@ -232,11 +242,13 @@ export interface AnalyzerContext {
 
 export function createAnalyzerContext(
   sourceFile: ts.SourceFile,
-  filePath: string
+  filePath: string,
+  acceptsCallbackBody?: CallbackBodyAcceptor
 ): AnalyzerContext {
   return {
     sourceFile,
     filePath,
+    acceptsCallbackBody,
 
     componentName: null,
     componentNode: null,
@@ -300,6 +312,22 @@ export function createAnalyzerContext(
       } catch {
         ownSourceFile = undefined
       }
+      // Test-gated trust-boundary assertion (write-side string rule,
+      // CLAUDE.md): getJS output is spliced into emitted artifacts, so a
+      // JSX-bearing node here is a leak by construction — mixed content must
+      // travel as structured segments, never as raw text. Every getJS call
+      // site shares this contract; the env gate keeps the subtree walk off
+      // the production hot path (the trichotomy harness enables it). Scoped
+      // to error-free compiles: a compile that already refused loudly may
+      // take degraded fallback paths whose artifacts are gated by the error —
+      // the invariant this trips on is the SILENT leak.
+      if (process.env.BF_ASSERT_NO_JSX_IN_GETJS === '1' && this.errors.length === 0 && nodeContainsJsx(node)) {
+        throw new Error(
+          'getJS() called on a JSX-bearing node — raw JSX must never be spliced ' +
+          'into emitted output. Carry mixed content as structured segments ' +
+          '(MapCallbackPreamble / FlatMapCallback) instead.'
+        )
+      }
       if (ownSourceFile && ownSourceFile !== sourceFile) {
         return node.getText(ownSourceFile)
       }
@@ -308,6 +336,12 @@ export function createAnalyzerContext(
   }
 }
 
+/** Subtree JSX check for the test-gated getJS assertion above. */
+function nodeContainsJsx(node: ts.Node): boolean {
+  if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) return true
+  return ts.forEachChild(node, nodeContainsJsx) ?? false
+}
+
 // =============================================================================
 // Source Location Helper
 // =============================================================================