@barefootjs/jsx 0.26.3 → 0.27.0

package/src/__tests__/child-components-in-map.test.ts

@@ -211,7 +211,7 @@ describe('child components inside .map() (#344)', () => {
     expect(clientJs!.content).toContain('toggleRow(index)')
   })
 
-  test('dynamic signal array: component generates reconcileElements with createComponent', () => {
+  test('dynamic signal array: component generates mapArray with createComponent', () => {
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -321,7 +321,7 @@ describe('child components inside .map() (#344)', () => {
     const uniqueVars = new Set(allVars)
     expect(allVars.length).toBe(uniqueVars.size)
 
-    // Component slot ref ($c) and reconcileElements should both be present
+    // Component slot ref ($c) and mapArray should both be present
     expect(content).toContain('$c(__scope')
     expect(content).toContain('mapArray')
   })
@@ -355,7 +355,7 @@ describe('child components inside .map() (#344)', () => {
     expect(clientJs).toBeDefined()
     const content = clientJs!.content
 
-    // Should use reconcileElements with createComponent
+    // Should use mapArray with createComponent
     expect(content).toContain('mapArray')
     expect(content).toContain("createComponent('TableRow'")
 
@@ -650,7 +650,7 @@ describe('child components inside .map() (#344)', () => {
     expect(clientJs).toBeDefined()
     const content = clientJs!.content
 
-    // Dynamic array should use reconcileElements and event delegation
+    // Dynamic array should use mapArray and event delegation
     expect(content).toContain('mapArray')
     expect(content).toContain(".addEventListener('click', (__bfEvt) => {")
     expect(content).toContain('handleClick(item.id)')

package/src/__tests__/client-js-generation.test.ts

@@ -151,7 +151,7 @@ describe('Client JS generation', () => {
   })
 
   describe('map with index parameter', () => {
-    test('includes index parameter in reconcileElements renderItem callback', () => {
+    test('includes index parameter in mapArray renderItem callback', () => {
       const source = `
         'use client'
         import { createMemo } from '@barefootjs/client'
@@ -1753,8 +1753,17 @@ describe('Client JS generation', () => {
 
       // Should contain the preamble in the map callback
       expect(clientJs?.content).toContain('const label = item.name.toUpperCase()')
-      // Should contain the template with the label reference
-      expect(clientJs?.content).toContain('${label}')
+      // The sole child expression reads the preamble local `label` (#2389
+      // patch-on-update): it is classified as a preamble-patched region —
+      // slot-marked and escaped, like an ordinary text slot — rather than a
+      // bare `${label}` interpolation that would freeze on a same-key
+      // update. See `preamble-region-patch.test.ts` for the full region
+      // contract (row-template marker, region-patch effect, SSR parity).
+      expect(clientJs?.content).toContain('${escapeText(label)}')
+      // Slot unification A3: preamble regions now write through a claimed
+      // 'markup' slot instead of `patchSlotRange`.
+      expect(clientJs?.content).toContain("kind: 'markup'")
+      expect(clientJs?.content).toContain('lazySlots(__el')
     })
 
     test('handles block body with multiple variable declarations', () => {
@@ -2417,11 +2426,12 @@ describe('Client JS generation', () => {
       expect(clientJs).toBeDefined()
       const content = clientJs!.content
 
-      // Text node updates route through `__bfText`, which renders nullish
-      // values as '' (not the string "undefined") and also splices live
-      // Nodes by identity (#1663). The nullish guard moved from the inline
-      // `String(__val ?? '')` assignment into that helper.
-      expect(content).toContain('__bfText(')
+      // Text node updates route through a claimed 'markup' slot writer (slot
+      // unification A3), whose `writeMarkup` renders nullish values as ''
+      // (not the string "undefined") and also splices live Nodes by
+      // identity (#1663) — the same contract `__bfText` used to provide.
+      // The nullish guard lives in the runtime writer, not inline here.
+      expect(content).toContain("kind: 'markup'")
       expect(content).not.toMatch(/\.nodeValue = String\(__val\)(?! )/)
     })
 
@@ -2458,8 +2468,10 @@ describe('Client JS generation', () => {
       expect(clientJs).toBeDefined()
       const content = clientJs!.content
 
-      // text() inside a component inside a conditional uses $t() in branch-scoped effect
-      expect(content).toContain('$t(__branchScope')
+      // text() inside a component inside a conditional writes through a
+      // claimed 'markup' slot built fresh in the branch's own bindEvents
+      // (slot unification A3) — re-claimed on every branch activation.
+      expect(content).toContain("lazySlots(__branchScope, [{ id: '^s2', kind: 'markup', path: [] }])")
     })
 
     test('propagates insideConditional through fragment children', () => {
@@ -2489,8 +2501,10 @@ describe('Client JS generation', () => {
       expect(clientJs).toBeDefined()
       const content = clientJs!.content
 
-      // text() inside a fragment inside a conditional uses $t() in branch-scoped effect
-      expect(content).toContain('$t(__branchScope')
+      // text() inside a fragment inside a conditional writes through a
+      // claimed 'markup' slot built fresh in the branch's own bindEvents
+      // (slot unification A3) — re-claimed on every branch activation.
+      expect(content).toContain("lazySlots(__branchScope, [{ id: 's2', kind: 'markup', path: [] }])")
     })
   })
 

package/src/__tests__/compiler-runtime-contract.test.ts

@@ -154,11 +154,11 @@ describe('Compiler-Runtime Contract', () => {
       expect(js).not.toContain('data-key-2')
       // Outer loop items must have data-key in the SSR branch template.
       // Post-O-7 the emission is an unguarded template-literal interpolation
-      // (`data-key="${group.id}"`) instead of a `... != null ? ... : ''`
-      // ternary string concat.
-      expect(js).toMatch(/data-key="\$\{group\.id\}"/)
+      // — escapeAttr-wrapped like every dynamic attribute, so a `"` in a key
+      // can't corrupt the client-assembled HTML or diverge from SSR bytes.
+      expect(js).toMatch(/data-key="\$\{escapeAttr\(group\.id\)\}"/)
       // Inner loop items must have data-key-1 in the SSR branch template.
-      expect(js).toMatch(/data-key-1="\$\{item\.id\}"/)
+      expect(js).toMatch(/data-key-1="\$\{escapeAttr\(item\.id\)\}"/)
     })
 
     test('loop inside conditional wires reactive conditionals in mapArray callback', () => {

package/src/__tests__/composite-branch-loop.test.ts

@@ -2,7 +2,7 @@
  * BarefootJS Compiler - Composite loops inside conditional branches (#724)
  *
  * Verifies that loops with child components inside ternary conditionals
- * generate reconcileElements with createComponent in the branch's bindEvents.
+ * generate mapArray with createComponent in the branch's bindEvents.
  */
 
 import { describe, test, expect } from 'bun:test'
@@ -52,7 +52,7 @@ describe('composite loops inside conditional branches (#724)', () => {
     expect(clientJs).toBeDefined()
     const js = clientJs!.content
 
-    // Should use reconcileElements inside the branch's bindEvents
+    // Should use mapArray inside the branch's bindEvents
     expect(js).toContain('mapArray(')
 
     // After O-1's mode-collapse PR, child component init goes through the

package/src/__tests__/cross-file-client-signal.test.ts

@@ -104,7 +104,11 @@ export function Viewer() {
     const files = Object.fromEntries(r.files.map(f => [f.path, f.content]))
     const ssr = Object.values(files).find(c => c.includes('export function Viewer'))
     expect(ssr).toBeDefined()
-    expect(ssr).toContain('client:s')
+    // Slot unification Step B: `{val()}` is the SPAN's only, non-adjacent
+    // child, so its marker pair is elided entirely (see the identical note
+    // in module-level-signal.audit.test.ts) — the client's claim plan
+    // creates the missing Text node from `elidedPath` alone.
+    expect(ssr).not.toContain('bfText(')
     expect(ssr).not.toContain("const val = () =>")
   })
 

package/src/__tests__/delegated-handler-preamble.test.ts

@@ -0,0 +1,153 @@
+/**
+ * A keyed `.map()` body with an array-builder preamble (`const cells = [];
+ * cells.push(<span>...)`) plus a row-level event handler used to make EVERY
+ * delegated action throw `t is not a function` (BUG-3).
+ *
+ * Root cause: the delegated handler's item-lookup binds the plain `.find()`
+ * result under the loop param (`const t = items().find(...)`) — `t` is a
+ * plain object there, never a signal accessor. But the preamble's JSX leaf
+ * was rendered through `irToHtmlTemplate` WITH a loopParams spec, the same
+ * one used for the mapArray row-render context (where the param genuinely
+ * IS an accessor). That rewrote leaf refs to `t().name` — a call on a plain
+ * object — which throws at click time.
+ *
+ * `build-event-delegation.ts` now renders the delegation-context preamble
+ * leaf with no loopParams spec, so refs stay in their plain (`t.name`) form.
+ * It also only splices the preamble into a given event's handler when that
+ * handler's free identifiers actually reference one of the preamble's
+ * declared names (`MapCallbackPreamble.declaredNames`) — the common case is
+ * an array builder the handler never reads (`cells` here) — and, when
+ * spliced, the preamble always runs INSIDE the item-null guard (BUG-4: a
+ * `.find()` miss from a stale-DOM race must short-circuit before a preamble
+ * that dereferences the item runs).
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function clientJsFor(source: string): string {
+  const result = compileJSX(source, 'Repro.tsx', { adapter })
+  expect(result.errors.filter((e) => e.severity === 'error')).toHaveLength(0)
+  const clientJs = result.files.find((f) => f.type === 'clientJs')
+  expect(clientJs).toBeDefined()
+  return clientJs!.content
+}
+
+/**
+ * The delegated-dispatcher body sits between the loop's `addEventListener`
+ * call and the `hydrate(...)` call that follows it in the emitted module —
+ * isolate it so assertions about the HANDLER shape don't accidentally match
+ * the (legitimately accessor-form) mapArray row-render callback that
+ * precedes it in the same file.
+ */
+function delegationBlock(js: string): string {
+  const start = js.indexOf('.addEventListener(')
+  const end = js.indexOf('\n\nhydrate(')
+  expect(start).toBeGreaterThan(-1)
+  expect(end).toBeGreaterThan(start)
+  return js.slice(start, end)
+}
+
+describe('delegated-handler preamble splicing (BUG-3 / BUG-4)', () => {
+  test('unreferenced array-builder preamble: no getter-call leaf refs, no dead splice', () => {
+    const js = clientJsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function R2a() {
+        const [items, setItems] = createSignal([{ id: 1, name: 'x' }, { id: 2, name: 'y' }])
+        const del = (id: number) => setItems(items().filter(i => i.id !== id))
+        return <ul id="list">{items().map(t => {
+          const cells = []
+          cells.push(<span>{t.name}</span>)
+          return <li key={t.id}>{cells}<button className="del" onClick={() => del(t.id)}>del</button></li>
+        })}</ul>
+      }
+    `)
+    const handler = delegationBlock(js)
+
+    // BUG-3: the leaf inside the delegation-context preamble must stay in
+    // plain-object form — `t` is the `.find()` result, not a signal accessor.
+    expect(handler).not.toContain('t().')
+
+    // The preamble (`cells`) is never read by the click handler
+    // (`() => del(t.id)`) — it must not be spliced into the dispatcher at
+    // all. `cells.push` legitimately appears three times elsewhere: the
+    // mapArray row-render callback, the SSR-template literal it mirrors,
+    // and (#2389 patch-on-update) the `{cells}` region-patch effect, which
+    // re-runs the preamble so it re-reads the live per-item signal. It must
+    // not appear a FOURTH time, in the handler.
+    expect(handler).not.toContain('cells.push')
+    expect(js.split('cells.push')).toHaveLength(4) // three occurrences total
+
+    // The item guard still gates the handler call.
+    expect(handler).toContain('if (t) {')
+    expect(handler).toContain('(() => del(t.id))(__bfEvt)')
+  })
+
+  test('preamble referenced by the handler: spliced in plain form, inside the item guard', () => {
+    const js = clientJsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function R2b() {
+        const [items, setItems] = createSignal([{ id: 1, name: 'x' }, { id: 2, name: 'y' }])
+        const del = (label: string) => setItems(items().filter(i => i.name !== label))
+        return <ul id="list">{items().map(t => {
+          const label = t.name + '!'
+          return <li key={t.id}>{label}<button className="del" onClick={() => del(label)}>del</button></li>
+        })}</ul>
+      }
+    `)
+    const handler = delegationBlock(js)
+
+    // Spliced in plain (non-getter) form.
+    expect(handler).toContain('const label = t.name + \'!\';')
+    expect(handler).not.toContain('t().')
+
+    // Guard-order (part 3): the preamble line and the handler call both
+    // land AFTER `if (t) {`, i.e. inside the item-null guard.
+    const guardIdx = handler.indexOf('if (t) {')
+    const preambleIdx = handler.indexOf('const label = t.name')
+    const callIdx = handler.indexOf('(() => del(label))(__bfEvt)')
+    expect(guardIdx).toBeGreaterThanOrEqual(0)
+    expect(preambleIdx).toBeGreaterThan(guardIdx)
+    expect(callIdx).toBeGreaterThan(preambleIdx)
+  })
+
+  test('destructured param + preamble + handler: no accessor leaks, real destructure resolves refs', () => {
+    const js = clientJsFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function R2c() {
+        const [items, setItems] = createSignal([{ id: 1, name: 'x' }, { id: 2, name: 'y' }])
+        const del = (label: string) => setItems(items().filter(i => i.name !== label))
+        return <ul id="list">{items().map(({ id, name }) => {
+          const label = name + '!'
+          return <li key={id}>{label}<button className="del" onClick={() => del(label)}>del</button></li>
+        })}</ul>
+      }
+    `)
+    const handler = delegationBlock(js)
+
+    // No `__bfItem()`-style accessor leaks into the delegated handler — the
+    // destructured names resolve as real local bindings off `__bfLoopItem`.
+    expect(handler).not.toContain('__bfItem(')
+
+    // Real destructure (#951 TDZ-safe shape) binds `id`/`name` for real —
+    // the preamble and handler both close over the resulting plain locals.
+    expect(handler).toContain('const __bfLoopItem = ')
+    expect(handler).toContain('const { id, name } = __bfLoopItem')
+    expect(handler).toContain('const label = name + \'!\';')
+    expect(handler).toContain('(() => del(label))(__bfEvt)')
+
+    // Guard-order holds for the bindings-branch shape too.
+    const guardIdx = handler.indexOf('if (__bfLoopItem) {')
+    const preambleIdx = handler.indexOf('const label = name')
+    const callIdx = handler.indexOf('(() => del(label))(__bfEvt)')
+    expect(guardIdx).toBeGreaterThanOrEqual(0)
+    expect(preambleIdx).toBeGreaterThan(guardIdx)
+    expect(callIdx).toBeGreaterThan(preambleIdx)
+  })
+})

package/src/__tests__/early-return-scope-var-ref.test.ts

@@ -65,12 +65,10 @@ describe('JSX expression referencing a local declared inside an early-return if-
 
     const content = clientJsContent(result)
 
-    // Pre-fix: emitted `updateClientMarker(__scope, 's4', aLocal)` at
-    // outer init scope — `aLocal` undefined. Post-fix: the JSX is
-    // inlined directly into the template, so the createEffect /
-    // updateClientMarker block is not needed at all for this static
-    // shape.
-    expect(content).not.toContain('updateClientMarker')
+    // Pre-fix, `aLocal` leaked into a reactive-update block at outer init
+    // scope where it doesn't exist (see file docstring). Post-fix: the JSX
+    // is inlined directly into the template, so no reactive-update block is
+    // needed at all for this static shape.
     expect(content).not.toMatch(/\baLocal\b/)
 
     const hydrate = hydrateLine(result)
@@ -97,9 +95,10 @@ describe('JSX expression referencing a local declared inside an early-return if-
     const content = clientJsContent(result)
     // The bare `label` identifier must not appear in the emitted init
     // function — it's resolved to its initializer value at IR-build
-    // time.
-    expect(content).not.toMatch(/updateClientMarker\([^)]*\blabel\b[^)]*\)/)
-    expect(content).toContain("updateClientMarker(__scope, 's4', 'hello')")
+    // time. `@client` writes through a claimed 'text' slot writer
+    // (`claim-slots.ts`).
+    expect(content).not.toMatch(/__bfw_\w+\([^)]*\blabel\b[^)]*\)/)
+    expect(content).toContain("__bfw_s4('s4', 'hello')")
   })
 
   test('ternary scope var (`readOnly ? null : <jsx/>`) routes to client-only conditional', () => {
@@ -124,8 +123,8 @@ describe('JSX expression referencing a local declared inside an early-return if-
     expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
 
     const content = clientJsContent(result)
-    // Pre-fix: `updateClientMarker(__scope, 's*', compactResize)`
-    // referenced an undeclared name. Post-fix: the ternary becomes an
+    // Pre-fix, `compactResize` leaked into the emitted reactive-update
+    // block as an undeclared name. Post-fix: the ternary becomes an
     // IRConditional with `clientOnly: true`, routed through `insert()`
     // — and `props.readOnly` is rewritten to `_p.readOnly`.
     expect(content).not.toMatch(/\bcompactResize\b/)

package/src/__tests__/flatmap-segments.test.ts

@@ -22,9 +22,13 @@ import { TestAdapter } from '../adapters/test-adapter'
 
 describe('flatMap block bodies on structured segments', () => {
   test('leaf text interpolations are escapeText-wrapped in the client bundle', () => {
+    // The early return keeps this a STATEMENT-carrying body (segments
+    // carrier) — a pure single-`return` projection now lowers to neutral
+    // nested-loop IR instead (see the projection tests below).
     const src = `
 function F({ items }: { items: { id: string; tags: string[] }[] }) {
   return <ul>{items.flatMap((it) => {
+    if (it.tags.length > 9) return []
     return it.tags.map((t) => <li key={t}>{t}</li>)
   })}</ul>
 }
@@ -59,6 +63,184 @@ export { F }
     expect(tpl).not.toMatch(/[^.\w]limit\b/)
   })
 
+  test('projection expression bodies lower to neutral IR + descriptor client', () => {
+    // `it => it.tags.map(...)` (no braces, no statements) is a pure
+    // nested-loop PROJECTION: it lowers to neutral IR (inner IRLoop child)
+    // that every SSR adapter templatizes — including DSL backends, per
+    // spec/callback-fidelity.md's fidelity table — while the client
+    // reconciles the flattened leaves through the descriptor mapArray path
+    // synthesized from the same inner loop. Pre-fix it fell through to the
+    // IRExpression scalar path and spliced raw JSX into the bundle.
+    const src = `
+function F({ items }: { items: { id: string; tags: string[] }[] }) {
+  return <ul>{items.flatMap((it) => it.tags.map((t) => <li key={t}>{t}</li>))}</ul>
+}
+export { F }
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    expect(r.errors).toHaveLength(0)
+    const cj = r.files.find(f => f.type === 'clientJs')!.content
+    // No raw JSX anywhere in the bundle.
+    expect(cj).not.toMatch(/<li key=\{t\}>/)
+    expect(cj).not.toMatch(/__BF_JSX_/)
+    if (cj.includes('mapArray(')) {
+      // Descriptor accessor flattens through the inner loop with the leaf key.
+      expect(cj).toMatch(/\.flatMap\(\(it\) => it\.tags\.map\(\(t\) => \(\{ k: \(t\), h: `<li/)
+      expect(cj).toMatch(/String\(__bfD\.k \?\? __bfI\)/)
+    }
+  })
+
+  test('a member-expression tag leaf is a component, not a projection leaf', () => {
+    // `<icons.Tag/>` starts lowercase but is a component per JSX semantics —
+    // the wireless-leaf gate must not admit it to the projection route
+    // (which cannot wire components). It falls to the segments carrier,
+    // where a DSL-tier adapter refuses loudly instead of templatizing a
+    // component tag as literal HTML.
+    const src = `
+import { icons } from './icons'
+function F({ items }: { items: { id: string; tags: string[] }[] }) {
+  return <ul>{items.flatMap((it) => it.tags.map((t) => <icons.Tag key={t} label={t} />))}</ul>
+}
+export { F }
+`
+    const dsl = new TestAdapter()
+    ;(dsl as { acceptsCallbackBody?: () => boolean }).acceptsCallbackBody = () => false
+    const r = compileJSX(src, 'F.tsx', { adapter: dsl })
+    expect(r.errors.filter(e => e.severity === 'error').length).toBeGreaterThan(0)
+  })
+
+  test('single-return block projection lowers identically (DSL adapters accept it)', () => {
+    const src = `
+function F({ items }: { items: { id: string; tags: string[] }[] }) {
+  return <ul>{items.flatMap((it) => {
+    return it.tags.map((t) => <li key={t}>{t}</li>)
+  })}</ul>
+}
+export { F }
+`
+    const dsl = new TestAdapter()
+    ;(dsl as { acceptsCallbackBody?: () => boolean }).acceptsCallbackBody = () => false
+    const r = compileJSX(src, 'F.tsx', { adapter: dsl })
+    // Neutral IR — no BF021 gate on a DSL-tier adapter.
+    expect(r.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  })
+
+  test('destructured prop refs rewrite to _p.xxx in expression-body hydrate templates', () => {
+    const src = `
+function F({ owner, items }: { owner: string; items: { id: string; tags: string[] }[] }) {
+  return <ul>{items.flatMap((it) => it.tags.map((t) => <li key={t}>{t} ({owner})</li>))}</ul>
+}
+export { F }
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    expect(r.errors).toHaveLength(0)
+    const cj = r.files.find(f => f.type === 'clientJs')!.content
+    const tpl = cj.match(/template: \(_p\) => `[\s\S]*?` \}\)/)?.[0] ?? ''
+    expect(tpl).toMatch(/_p\.owner/)
+    expect(tpl).not.toMatch(/[^.\w]owner\b/)
+  })
+
+  test('client loop reconciles the FLATTENED descriptors, not the source items', () => {
+    // The mapArray accessor flattens through the callback body — each leaf a
+    // `({ k, h })` descriptor keyed by the leaf's own `key` — so hydration
+    // adopts every SSR leaf (not one per source item), adds build real
+    // elements from `h` (not an empty template), and the keyFn is the leaf
+    // key (not null/index). This pins the client half of the flatMap loop;
+    // pre-fix it emitted `mapArray(() => todos(), _sN, null, …innerHTML = ``…)`
+    // — leaf loss at hydration and a cloneNode(null) crash on adds.
+    const src = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function F() {
+  const [todos, setTodos] = createSignal<{ id: number; tags: string[] }[]>([{ id: 1, tags: ['a'] }])
+  return <ul>{todos().flatMap((t) => {
+    if (t.tags.length > 5) return []
+    const prefix = t.id + ':'
+    return t.tags.map((tag) => <li key={\`\${t.id}:\${tag}\`}>{prefix}{tag}</li>)
+  })}</ul>
+}
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    expect(r.errors).toHaveLength(0)
+    const cj = r.files.find(f => f.type === 'clientJs')!.content
+    // Flattened source with descriptor leaves…
+    expect(cj).toMatch(/mapArray\(\(\) => \(todos\(\)\)\.flatMap\(\(t\) => \{/)
+    expect(cj).toMatch(/\(\{ k: \(`\$\{t\.id\}:\$\{tag\}`\), h: `<li>/)
+    // …keyed on the leaf key with index fallback…
+    expect(cj).toMatch(/\(__bfD, __bfI\) => String\(__bfD\.k \?\? __bfI\)/)
+    // …renderItem builds from the descriptor HTML and patches on change…
+    expect(cj).toMatch(/__tpl\.innerHTML = __bfD\(\)\.h/)
+    expect(cj).toMatch(/patchLeaf\(__el, __html\)/)
+    // …and the statements-before-return are NOT duplicated as a renderItem
+    // preamble (the segments carrier is the single door).
+    expect(cj).not.toMatch(/return \[\];* if \(__existing\)/)
+    // Leaf data-key never rides the string templates — mapArray stamps it.
+    expect(cj).not.toMatch(/data-key/)
+  })
+
+  test('a leaf with an event handler refuses loudly (no silent dead DOM)', () => {
+    const src = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function F() {
+  const [todos, setTodos] = createSignal<{ id: number; tags: string[] }[]>([])
+  return <ul>{todos().flatMap((t) => {
+    return t.tags.map((tag) => <li key={tag} onClick={() => console.log(tag)}>{tag}</li>)
+  })}</ul>
+}
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    const errs = r.errors.filter(e => e.severity === 'error')
+    expect(errs.length).toBeGreaterThan(0)
+    expect(errs[0].message).toContain('cannot carry')
+  })
+
+  test('a fragment leaf refuses loudly (descriptor path is single-element)', () => {
+    // The renderItem adopts `template.content.firstElementChild` and
+    // patchLeaf patches ONE element root — a fragment leaf would silently
+    // drop its siblings client-side while SSR renders them all.
+    const src = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function F() {
+  const [todos, setTodos] = createSignal<{ id: number; tags: string[] }[]>([])
+  return <ul>{todos().flatMap((t) => {
+    return t.tags.map((tag) => <><b>{tag}</b><i>{tag}</i></>)
+  })}</ul>
+}
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    const errs = r.errors.filter(e => e.severity === 'error')
+    expect(errs.length).toBeGreaterThan(0)
+    expect(errs.some(e => e.message.includes('must be a single'))).toBe(true)
+  })
+
+  test('the structural net stays armed when an unrelated diagnostic fired earlier', () => {
+    // The scalar-fallthrough net de-dups against refusals fired during the
+    // SAME map call (entry-count gate), never against diagnostics recorded
+    // earlier in the file — a prior error in another loop must not let raw
+    // JSX splice silently into the bundle.
+    const src = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function F() {
+  const [todos, setTodos] = createSignal<{ id: number; tags: string[] }[]>([])
+  const wrap = (n: unknown) => n
+  return <div>
+    <ul>{todos().flatMap((t) => {
+      return t.tags.map((tag) => <li key={tag} onClick={() => console.log(tag)}>{tag}</li>)
+    })}</ul>
+    <ol>{todos().map((t) => wrap(<li>{t.id}</li>))}</ol>
+  </div>
+}
+`
+    const r = compileJSX(src, 'F.tsx', { adapter: new TestAdapter() })
+    const errs = r.errors.filter(e => e.severity === 'error')
+    // One refusal per loop: the leaf-wiring refusal AND the structural net.
+    expect(errs.some(e => e.message.includes('cannot carry'))).toBe(true)
+    expect(errs.some(e => e.message.includes('would leak verbatim'))).toBe(true)
+  })
+
   test('TS type annotations in the block body are stripped from the client bundle', () => {
     const src = `
 function F({ items }: { items: { id: string; labels: string[] }[] }) {

package/src/__tests__/inline-jsx-callback.test.ts

@@ -440,10 +440,12 @@ describe('inline JSX as object-literal arrow value (#1663)', () => {
     expect(js).toMatch(/hydrate\(\s*['"]BFInlineJsxCallback1(?:__|['"])/)
   })
 
-  test('dynamic JSX-returning call routes the slot through __bfText', () => {
+  test('dynamic JSX-returning call routes the slot through a claimed markup slot', () => {
     // The child expression `{themeLogo(props.id)}` evaluates to a live
     // component element on the client; the slot update must splice it in by
-    // identity via __bfText rather than stringify it into "[object …]".
+    // identity via a claimed 'markup' slot writer (slot unification A3)
+    // rather than stringify it into "[object …]" — the same contract
+    // `__bfText` used to provide.
     const source = `
       'use client'
       import { BrandLogo } from './brand-logo'
@@ -458,7 +460,7 @@ describe('inline JSX as object-literal arrow value (#1663)', () => {
       }
     `
     const js = clientJs(source)
-    expect(js).toContain('__bfText(')
-    expect(js).toMatch(/__bfText[^']*from '@barefootjs\/client\/runtime'/)
+    expect(js).toContain("kind: 'markup'")
+    expect(js).toMatch(/lazySlots[^']*from '@barefootjs\/client\/runtime'/)
   })
 })

package/src/__tests__/ir-jsx-props.test.ts

@@ -359,11 +359,12 @@ describe('JSX props (#559)', () => {
 
       const clientJs = result.files.find(f => f.type === 'clientJs')
       expect(clientJs).toBeDefined()
-      // The text update routes through `__bfText`, which preserves the
-      // server-rendered DOM for `__isSlot` values (and splices live Nodes
-      // by identity) instead of the old inline `nodeValue = String(...)`
-      // assignment. The `__isSlot` guard now lives inside that helper (#1663).
-      expect(clientJs!.content).toContain('__bfText')
+      // The text update routes through a claimed 'markup' slot writer (slot
+      // unification A3), whose `writeMarkup` preserves the server-rendered
+      // DOM for `__isSlot` values (and splices live Nodes by identity)
+      // instead of the old inline `nodeValue = String(...)` assignment —
+      // the same contract `__bfText` used to provide (#1663).
+      expect(clientJs!.content).toContain("kind: 'markup'")
     })
   })
 })

package/src/__tests__/loop-fallback-wrap.test.ts

@@ -18,7 +18,7 @@
  * and the conditional follow-up (#941), so this loop widening closes
  * the divergence gap between the allow-list path and the AST-flag path.
  *
- * Over-reconciliation of a pure-call array has a real cost (reconcileList
+ * Over-reconciliation of a pure-call array has a real cost (mapArray
  * is not a cheap primitive), so the fixture sweep in the accompanying
  * PR measures byte delta too; but the silent-drop bug this closes is
  * the expensive one — a frozen client list is a visible correctness
@@ -89,8 +89,8 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
 
   test('inline literal array stays static (optimisation preserved)', () => {
     // `[1, 2, 3]` is an ArrayLiteralExpression with no calls — the
-    // existing static-render path is the right call. No reconcileList /
-    // mapArray should appear.
+    // existing static-render path is the right call. No `mapArray` call
+    // should appear.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -107,7 +107,6 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
 
     const clientJs = getClientJs(source, 'List.tsx')
     expect(clientJs).not.toMatch(/\bmapArray\s*\(/)
-    expect(clientJs).not.toMatch(/\breconcileList\s*\(/)
   })
 
   test('prop array compiles to mapArray (#1586)', () => {