@barefootjs/jsx 0.26.4 → 0.28.0

package/src/__tests__/loop-branch-bare-expression-reactive-text.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Emission pin for the loop-branch-stale-text fix.
+ *
+ * `summarizeLoopChildBranch` (ir-to-client-js/collect-elements.ts) used to
+ * collect NO `reactiveTexts` for ANY loop-row conditional branch whose whole
+ * content is a bare `expression` (no wrapping element) — including a plain
+ * property read like `row.label`, which can never construct a live DOM
+ * node. That blanket skip meant a keyed row's branch text silently froze at
+ * its mount-time value whenever the item changed without the conditional's
+ * OWN condition flipping (`insert()`, runtime/insert.ts, correctly no-ops
+ * when its condition is unchanged — branch-internal updates are the effect
+ * system's job).
+ *
+ * The fix narrows the skip to `node.hasFunctionCalls` (jsx-to-ir.ts's
+ * `exprHasFunctionCalls`, a recursive AST walk — catches a call nested
+ * anywhere, not just a top-level one) — a call can return a live DOM node
+ * (a hoisted `renderNode={(n) => <Pill/>}` callback lowered to a component
+ * call, #1211/#1213, pinned by `nested-loop-conditional.test.ts`) and the
+ * compiler cannot tell from syntax whether it does, so that shape must keep
+ * the skip. Everything call-free is provably incapable of yielding a Node
+ * and is now collected.
+ *
+ * The companion half of the fix lives in `transformConditionalBranch`
+ * (jsx-to-ir.ts): a bare loop-item read like `row.label` previously got NO
+ * `slotId` at all (`needsSlot` didn't consider a `render-item` free
+ * reference), so even with the collect-elements.ts skip narrowed there was
+ * nothing for the new effect — or the `<!--bf:sN-->` marker
+ * `irToHtmlTemplate` emits for it — to attach to. Both are exercised here
+ * together because neither half alone reproduces the fix.
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function clientJsFor(branchTrue: string): string {
+  const source = `
+    'use client'
+    import { createSignal } from '@barefootjs/client'
+    type Props = { format?: (s: string) => string }
+    type Row = { id: number; label: string; done: boolean }
+    export function C(_p: Props) {
+      const [rows] = createSignal<Row[]>([])
+      return <ul>{rows().map(row => <li key={row.id}>{row.done ? ${branchTrue} : 'pending'}</li>)}</ul>
+    }
+  `
+  const result = compileJSX(source, 'C.tsx', { adapter })
+  const errors = result.errors.filter(e => e.severity === 'error')
+  if (errors.length > 0) throw new Error(errors.map(e => e.message).join('\n'))
+  return result.files.find(f => f.type === 'clientJs')!.content
+}
+
+describe('loop-branch-stale-text — reactiveTexts narrowing (collect-elements.ts)', () => {
+  test('a bare property-read branch (no call anywhere) gets its own text effect', () => {
+    const js = clientJsFor('row.label')
+    expect(js).toContain("escapeTextOrNode(row().label)")
+    // And a slotId was actually allocated for it — `transformConditionalBranch`'s
+    // `refsLoopParam` half of the fix, without which the effect above would
+    // have nothing to `lazySlots(...)` claim.
+    expect(js).toMatch(/lazySlots\(__branchScope, \[\{ id: 's\d+', kind: 'markup', path: \[\] \}\]\)/)
+  })
+
+  test('a template-literal branch built from property reads only (no call) also gets a text effect', () => {
+    const js = clientJsFor('`[${row.label}]`')
+    expect(js).toContain('escapeTextOrNode(`[${row().label}]`)')
+  })
+
+  test('a branch with a call ANYWHERE (top-level) keeps the skip — no per-item text effect', () => {
+    const js = clientJsFor('_p.format(row.label)')
+    expect(js).not.toContain('escapeTextOrNode(_p.format(row().label))')
+    // bindEvents for that arm stays empty (mirrors the pre-fix shape exactly).
+    expect(js).toMatch(/bindEvents: \(__branchScope, \{ isFirstRun: __bfFirstRun = false \} = \{\}\) => \{\s*\}/m)
+  })
+
+  test('a branch with a call NESTED inside a template literal also keeps the skip', () => {
+    // The call is not at the top level of the expression — `exprHasFunctionCalls`
+    // is a full recursive AST walk, so this must be caught too.
+    const js = clientJsFor('`${_p.format(row.label)}!`')
+    expect(js).not.toContain("escapeTextOrNode(`${_p.format(row().label)}!`)")
+  })
+
+  test('a branch with a call nested inside a sub-ternary keeps the skip', () => {
+    const js = clientJsFor("row.id > 0 ? _p.format(row.label) : row.label")
+    // The outer branch (itself a nested conditional) is unaffected by this
+    // narrowing — nested conditionals already get their own `insert()` via
+    // `collectLoopChildConditionals`, never through `reactiveTexts`. This
+    // case exists to confirm compilation succeeds and the call-bearing leaf
+    // still doesn't get a bare reactiveTexts effect wrapping the whole
+    // nested-ternary expression text.
+    expect(js).not.toContain('escapeTextOrNode(row.id > 0 ? _p.format(row().label) : row().label)')
+  })
+
+  test('an inert literal branch (no loop-param ref, no call) stays exactly as before — no slotId, no effect', () => {
+    const js = clientJsFor("'yes'")
+    expect(js).not.toContain("escapeTextOrNode('yes')")
+  })
+})

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
@@ -58,7 +58,7 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     const clientJs = getClientJs(source, 'List.tsx')
     // Dynamic loops emit a `mapArray(` call site. Tighter than
     // `/mapArray|reconcile/` which would fire on any stray mention.
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).toContain('items()')
   })
 
@@ -83,14 +83,14 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'List.tsx')
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).toContain('getItems()')
   })
 
   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)', () => {
@@ -125,7 +124,11 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'List.tsx')
-    expect(clientJs).toMatch(/\bmapArray\s*\(/)
+    // `mapArrayLazy` counts: a keyed, single-root, conditional-free row over a
+    // PROP array is lazy-row-eligible (spec/slot-unification.md §9.4 — props
+    // are the canonical hydration-consistent source), so it takes the lazy
+    // reconciler. What #1586 pins is "reconciles at all", not which family.
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
   })
 
   test('unrecognised-call chain with filter now reconciles', () => {
@@ -150,7 +153,7 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'DoneList.tsx')
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).toContain('computeItems()')
   })
 
@@ -182,7 +185,7 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     // Outer reconciles via mapArray. Also assert the inner loop's array
     // expression (`o.children`) appears in the emitted template — without
     // this, the test would pass even if the inner loop were dropped.
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).toContain('outer()')
     expect(clientJs).toContain('o.children')
   })
@@ -220,8 +223,13 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     // mapArray is emitted (widening now applies). renderItem uses the
     // synthetic `__bfItem` param; references to `cfg` are rewritten
     // inline and no unwrap statement is emitted.
-    expect(clientJs).toContain('mapArray(')
-    expect(clientJs).toContain('(__bfItem, ')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
+    // The synthetic accessor param, in whichever reconciler shape applies:
+    // `mapArray`'s renderItem head `(__bfItem, __idx, __existing) =>`, or a
+    // lazy row plan's `const __bfItem = () => __e.item` binding
+    // (spec/slot-unification.md §9). Either way the destructured references
+    // below must read through the accessor, which is what this pins.
+    expect(clientJs).toMatch(/\(__bfItem, |const __bfItem = \(\) => __e\.item/)
     expect(clientJs).not.toContain('const [, cfg] = __bfItem();')
     expect(clientJs).toContain('__bfItem()[1].color')
   })
@@ -248,7 +256,7 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'Shelf.tsx')
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).toContain('listOf()')
   })
 
@@ -279,8 +287,13 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'TypedLegend.tsx')
-    expect(clientJs).toContain('mapArray(')
-    expect(clientJs).toContain('(__bfItem, ')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
+    // The synthetic accessor param, in whichever reconciler shape applies:
+    // `mapArray`'s renderItem head `(__bfItem, __idx, __existing) =>`, or a
+    // lazy row plan's `const __bfItem = () => __e.item` binding
+    // (spec/slot-unification.md §9). Either way the destructured references
+    // below must read through the accessor, which is what this pins.
+    expect(clientJs).toMatch(/\(__bfItem, |const __bfItem = \(\) => __e\.item/)
     expect(clientJs).not.toContain('const [, cfg] = __bfItem();')
     expect(clientJs).toContain('__bfItem()[1].color')
   })
@@ -310,8 +323,13 @@ describe('Solid-style wrap-by-default fallback for loops (#943)', () => {
     `
 
     const clientJs = getClientJs(source, 'Fields.tsx')
-    expect(clientJs).toContain('mapArray(')
-    expect(clientJs).toContain('(__bfItem, ')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
+    // The synthetic accessor param, in whichever reconciler shape applies:
+    // `mapArray`'s renderItem head `(__bfItem, __idx, __existing) =>`, or a
+    // lazy row plan's `const __bfItem = () => __e.item` binding
+    // (spec/slot-unification.md §9). Either way the destructured references
+    // below must read through the accessor, which is what this pins.
+    expect(clientJs).toMatch(/\(__bfItem, |const __bfItem = \(\) => __e\.item/)
     expect(clientJs).not.toContain('const { label, value } = __bfItem();')
     expect(clientJs).toContain('__bfItem().label')
     expect(clientJs).toContain('__bfItem().value')

package/src/__tests__/loop-hoisted-template.test.ts

@@ -72,16 +72,20 @@ describe('hoisted loop-body skeleton template (perf)', () => {
     `
     const { clientJs, template } = compile(source, 'Bench.tsx')
 
-    // Hoisted declaration present, before the mapArray call.
+    // Hoisted declaration present, before the reconciler call. This row shape
+    // is also lazy-row-eligible (spec/slot-unification.md §9.4), so the
+    // reconciler is `mapArrayLazy` and the clone happens in the row plan's
+    // `createRow` rather than in a `mapArray` renderItem — the hoisting
+    // question this suite pins is orthogonal to which reconciler consumes it.
     const declIdx = clientJs.indexOf('.innerHTML = `<tr')
-    const mapArrayIdx = clientJs.indexOf('mapArray(')
+    const mapArrayIdx = clientJs.search(/\bmapArray(Lazy)?\(/)
     expect(declIdx).toBeGreaterThan(-1)
     expect(mapArrayIdx).toBeGreaterThan(-1)
     expect(declIdx).toBeLessThan(mapArrayIdx)
 
-    // renderItem clones from the hoisted template instead of re-parsing
+    // The row is built by cloning the hoisted template instead of re-parsing
     // innerHTML per row.
-    expect(clientJs).toMatch(/const __el = __existing \?\? __tpl_\w+\.content\.firstElementChild\.cloneNode\(true\)/)
+    expect(clientJs).toMatch(/const __el = __tpl_\w+\.content\.firstElementChild\.cloneNode\(true\)/)
 
     // The hoisted template itself carries no interpolations and no dynamic
     // `class` attribute (that's covered by the reactive-attr createEffect).
@@ -172,7 +176,7 @@ describe('hoisted loop-body skeleton template (perf)', () => {
       }
     `
     const { clientJs } = compile(source, 'SpreadList.tsx')
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     expect(clientJs).not.toMatch(/__tpl_\w+ = document\.createElement\('template'\)/)
   })
 
@@ -195,7 +199,7 @@ describe('hoisted loop-body skeleton template (perf)', () => {
       }
     `
     const { clientJs } = compile(source, 'Dots.tsx')
-    expect(clientJs).toContain('mapArray(')
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\(/)
     // A `<circle>` root with only dynamic attrs (all covered by reactive-attr
     // createEffects) and a literal `r="4"` is exactly the shape the fast path
     // proves safe — this DOES hoist, and it must wrap in a synthetic `<svg>`

package/src/__tests__/module-level-signal.audit.test.ts

@@ -234,8 +234,13 @@ export function Counter() {
     const ssr = files['Counter.tsx']
     // SSR template should NOT declare count as a getter
     expect(ssr).not.toContain('const count = () =>')
-    // SSR template should have a client-only placeholder (not the value)
-    expect(ssr).toContain('client:s')
+    // Slot unification Step B: `{count()}` is the SPAN's only, non-adjacent
+    // child, so `client-only-elision.ts` elides its marker pair entirely —
+    // no `bfText`/`bfTextEnd` call reaches the SSR output at all. The
+    // client's claim plan (`Counter.client.js`) creates the missing Text
+    // node from `elidedPath` alone; see `claim-slots.test.ts`'s
+    // "markerless text kind" describe block for the runtime contract.
+    expect(ssr).not.toContain('bfText(')
   })
 
   test('full compile: exported signal uses `export const` in client JS', () => {

package/src/__tests__/nested-loop-conditional.test.ts

@@ -134,13 +134,14 @@ describe('nested loops/conditionals inside mapArray (#830, #839)', () => {
     expect(mapArrayCount).toBeGreaterThanOrEqual(3)
   })
 
-  test('reactive text inside conditional inside inner loop uses re-query pattern (#840)', () => {
+  test('reactive text inside conditional inside inner loop uses re-claim pattern (#840)', () => {
     // When a reactive text is inside a conditional branch inside a nested (inner) loop,
     // insert() may replace the SSR element after the text node is captured.
-    // The generated code must use the re-query pattern:
-    //   createEffect(() => { const [__rt] = $t(...) ... })
-    // NOT the capture-then-effect pattern:
-    //   { const [__rt] = $t(...); if (__rt) createEffect(() => ...) }
+    // Slot unification A3: the generated code must re-claim on EVERY run via
+    // a fresh `claimSlots(...).write(...)` call inside the effect body — not
+    // a `lazySlots` writer built once outside it, which would go stale once
+    // insert() swaps the branch's DOM (see `stringifyInnerLoops`' docstring
+    // in `ir-to-client-js/control-flow/stringify/inner-loop.ts`).
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -175,8 +176,9 @@ describe('nested loops/conditionals inside mapArray (#830, #839)', () => {
     expect(clientJs).toBeDefined()
     const content = clientJs!.content
 
-    // Re-query pattern: $t() inside createEffect so it always finds the live node
-    expect(content).toContain('createEffect(() => { const [__rt] = $t(')
+    // Re-claim pattern: a fresh `claimSlots(...)` call inside createEffect so
+    // it always resolves against the live node, never a cached stale ref.
+    expect(content).toMatch(/createEffect\(\(\) => \{ claimSlots\(__innerEl\w*, \[\{ id: 's\d+', kind: 'text', path: \[\] \}\]\)\.write\('s\d+', String\(/)
   })
 
   test('event handler inside conditional branch of loop item appears in bindEvents (#839)', () => {

package/src/__tests__/nested-loop-reactive-attrs.test.ts

@@ -339,7 +339,7 @@ describe('reactive attributes inside a nested .map() body (#135)', () => {
     // The innermost loop's per-item renderItem must emit BOTH a
     // reactive-text effect for `panel.text` and a reactive-attr effect
     // for `panel.cls` — the bug dropped only the former.
-    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?\.textContent = String\(panel\(\)\.text\)/)
+    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?__bfw_\w+\('s\d+', String\(panel\(\)\.text\)\)/)
     expect(content).toContain("setAttribute('class'")
   })
 
@@ -395,7 +395,7 @@ describe('reactive attributes inside a nested .map() body (#135)', () => {
     // textContent write — `labelAt(` also appears in the static template
     // clone, so asserting it independently would pass even with the
     // effect missing (the exact regression here).
-    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?\.textContent = String\(labelAt\(pi\)\)/)
+    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?__bfw_\w+\('s\d+', String\(labelAt\(pi\)\)\)/)
     expect(content).toContain("setAttribute('class'")
   })
 })

package/src/__tests__/preamble-region-patch.test.ts

@@ -11,9 +11,13 @@
  * 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).
+ * door a reactive text uses), but wired on the client via a claimed
+ * 'markup' slot writer (`@barefootjs/client/runtime/claim-slots.ts`) rather
+ * than a `reactiveTexts` `.textContent` assignment (which would corrupt the
+ * array-joined markup). Dedup — skip the DOM write when the new value
+ * matches the writer's own held `last` value — lives inside that writer;
+ * every write, including the first, applies unless deduped (see
+ * `claim-slots.ts`'s module docstring).
  */
 
 import { describe, test, expect } from 'bun:test'
@@ -68,7 +72,8 @@ describe('preamble-region-patch (#2389)', () => {
     expect(clientJs).toMatch(/<!--bf:s\d+-->\$\{Array\.isArray\(cells\) \? cells\.join\(''\) : \(cells \?\? ''\)\}<!--\/-->/)
 
     const hono = compileWith(new HonoAdapter())
-    expect(hono.clientJs).toContain('patchSlotRange')
+    expect(hono.clientJs).toContain("kind: 'markup'")
+    expect(hono.clientJs).toContain('lazySlots(__el')
     // 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)
@@ -81,15 +86,16 @@ describe('preamble-region-patch (#2389)', () => {
 
   test('(b) renderItem emits the region-patch effect, re-running the preamble in accessor form', () => {
     const { clientJs } = compileWith(new TestAdapter())
-    expect(clientJs).toContain('patchSlotRange')
+    expect(clientJs).toContain("kind: 'markup'")
     // 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+\)/)
+    // The write goes through the claimed 'markup' writer — dedup (skip an
+    // unchanged string, on every write including the first) now lives
+    // inside `writeMarkup` itself (`claim-slots.ts`), not a per-region
+    // `__last` local next to the write call.
+    expect(clientJs).toMatch(/__bfw_\w+\('s\d+', Array\.isArray\(cells\)/)
   })
 
   test('(c) a loop without a preamble gets no region', () => {
@@ -102,7 +108,7 @@ describe('preamble-region-patch (#2389)', () => {
       }
     `
     const { clientJs } = compileWith(new TestAdapter(), source)
-    expect(clientJs).not.toContain('patchSlotRange')
+    expect(clientJs).not.toContain("kind: 'markup'")
   })
 
   test('(c) a static-array loop with a preamble gets no region', () => {
@@ -123,7 +129,7 @@ describe('preamble-region-patch (#2389)', () => {
       }
     `
     const { clientJs } = compileWith(new TestAdapter(), source)
-    expect(clientJs).not.toContain('patchSlotRange')
+    expect(clientJs).not.toContain("kind: 'markup'")
   })
 
   test('(d) a preamble local never referenced by an expression child gets no region', () => {
@@ -145,6 +151,6 @@ describe('preamble-region-patch (#2389)', () => {
       }
     `
     const { clientJs } = compileWith(new TestAdapter(), source)
-    expect(clientJs).not.toContain('patchSlotRange')
+    expect(clientJs).not.toContain("kind: 'markup'")
   })
 })

package/src/__tests__/profile-cond-binding-ids.test.ts

@@ -60,8 +60,9 @@ describe('conditional binding-effect ids (#1795 Phase 1)', () => {
     const on = clientJs(true)
     // Branch reactive attribute effect (createDisposableEffect with the class write).
     expect(on).toMatch(/setAttribute\('class'[\s\S]*?}, "Disclosure#binding:s\d+"\)\)/)
-    // Branch reactive text effect (__bfText path).
-    expect(on).toMatch(/__bfText\([\s\S]*?}, "Disclosure#binding:s\d+"\)\)/)
+    // Branch reactive text effect (claimed 'markup' slot writer, slot
+    // unification A3).
+    expect(on).toMatch(/__bfw_\w+\([\s\S]*?}, "Disclosure#binding:s\d+"\)\)/)
   })
 
   test('buildIdIndex resolves conditional / attribute / text binding ids to source loc', () => {

package/src/__tests__/profile-loop-binding-ids.test.ts

@@ -50,9 +50,10 @@ describe('loop-child binding-effect ids (#1795 Phase 2)', () => {
 
   test('profile on: loop-child text effects carry #binding ids', () => {
     const on = clientJs(true)
-    // Both `{it.t}` and `{it.n}` text effects.
-    expect(on).toMatch(/__rt_s\d+\.textContent = String\(it\(\)\.t\) }, "List#binding:s\d+"\)/)
-    expect(on).toMatch(/__rt_s\d+\.textContent = String\(it\(\)\.n\) }, "List#binding:s\d+"\)/)
+    // Both `{it.t}` and `{it.n}` text effects write through the row's
+    // claimed 'text' slot writer (slot unification A3).
+    expect(on).toMatch(/__bfw_\w+\('s\d+', String\(it\(\)\.t\)\) }, "List#binding:s\d+"\)/)
+    expect(on).toMatch(/__bfw_\w+\('s\d+', String\(it\(\)\.n\)\) }, "List#binding:s\d+"\)/)
   })
 
   test('profile on: the loop-child attribute effect carries a #binding id', () => {

package/src/__tests__/profile-nested-binding-ids.test.ts

@@ -112,12 +112,17 @@ describe('nested loop binding ids (#1795 Phase 3)', () => {
   test('loop-child conditional insert() and its branch text carry ids', () => {
     const on = clientJs(nestedSource, 'Nested', true)
     // The branch-arm text (`{r.label}` inside the conditional's true arm) —
-    // __bfText (not a naive `.textContent = String(...)`) so a Child-position
-    // expression whose value is a live Node splices by identity instead of
-    // stringifying (#2347).
-    expect(on).toMatch(/__rt_s\d+ = __bfText\(__rt_s\d+, r\(\)\.label\) }, "Nested#binding:s\d+"\)/)
+    // a claimed 'markup' slot writer (slot unification A3), built fresh in
+    // the branch's own bindEvents, so a Child-position expression whose
+    // value is a live Node splices by identity instead of stringifying
+    // (#2347) — the same contract `__bfText` used to provide. Wrapped in
+    // `escapeTextOrNode` (A3 follow-up): a string value must be escaped
+    // before this 'markup' writer's `innerHTML =` insertion, matching what
+    // the initial SSR/CSR template already does for the same expression;
+    // a live Node passes through untouched.
+    expect(on).toMatch(/__bfw_\w+\('s\d+', escapeTextOrNode\(r\(\)\.label\)\) }, "Nested#binding:s\d+"\)/)
     // The inner loop's child text (`{t}`).
-    expect(on).toMatch(/String\(t\(\)\) }, "Nested#binding:s\d+"\)/)
+    expect(on).toMatch(/String\(t\(\)\)\) }, "Nested#binding:s\d+"\)/)
   })
 
   test('branch-scoped loop (loop inside a conditional) attributes its mapArray', () => {
@@ -132,7 +137,7 @@ describe('nested loop binding ids (#1795 Phase 3)', () => {
     const emitted = assertNoCoverageGap(staticLoopSource, 'StaticLoop')
     expect(emitted.length).toBeGreaterThanOrEqual(1)
     const on = clientJs(staticLoopSource, 'StaticLoop', true)
-    expect(on).toMatch(/textContent = String\(n\(\)\) }, "StaticLoop#binding:s\d+"\)/)
+    expect(on).toMatch(/__bfw_\w+\('s\d+', String\(n\(\)\)\) }, "StaticLoop#binding:s\d+"\)/)
   })
 
   test('component loop attributes its mapArray', () => {

package/src/__tests__/reactive-attrs-in-map.test.ts

@@ -68,7 +68,7 @@ describe('reactive attributes inside .map() callbacks', () => {
     expect(clientJs!.content).toContain('disabled')
   })
 
-  test('dynamic array: reactive className handled by reconcileElements re-render (no extra effect needed)', () => {
+  test('dynamic array: reactive className handled by mapArray re-render (no extra effect needed)', () => {
     const source = `
       'use client'
 
@@ -91,7 +91,7 @@ describe('reactive attributes inside .map() callbacks', () => {
 
     const clientJs = result.files.find(f => f.type === 'clientJs')
     expect(clientJs).toBeDefined()
-    // Dynamic arrays use reconcileElements which re-creates items on signal change
+    // Dynamic arrays use mapArray which re-creates items on signal change
     expect(clientJs!.content).toContain('mapArray')
   })
 
@@ -228,9 +228,11 @@ describe('reactive attributes inside .map() callbacks', () => {
     const result = compileJSX(source, 'L.tsx', { adapter })
     expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
     const js = result.files.find(f => f.type === 'clientJs')!.content
-    // Both effects must still be present.
+    // Both effects must still be present. The text effect writes through a
+    // claimed 'text' slot writer now (slot unification A3), not a bare
+    // `.textContent =` assignment.
     expect(js).toContain("setAttribute('class'")
-    expect(js).toMatch(/textContent\s*=\s*String\(item\.name\)/)
+    expect(js).toMatch(/__bfw_\w+\('s\d+', String\(item\.name\)\)/)
     // But there must be exactly one `items.forEach` call (not two).
     const forEachMatches = js.match(/items\.forEach\(/g) ?? []
     expect(forEachMatches.length).toBe(1)

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

@@ -95,7 +95,12 @@ describe('#1247 — static-loop CSR self-heal', () => {
       }
     `
     const clientJs = getClientJs(source, 'PropList.tsx')
-    expect(clientJs).toMatch(/\bmapArray\s*\(/)
+    // Either reconciler shape satisfies the point of this test — the loop must
+    // go through the keyed `mapArray` family, not the static `forEach` path.
+    // A keyed, single-root, conditional-free row over a prop array is
+    // lazy-row-eligible (spec/slot-unification.md §9.4), so it emits
+    // `mapArrayLazy`; widen (don't narrow) the assertion.
+    expect(clientJs).toMatch(/\bmapArray(Lazy)?\s*\(/)
     expect(clientJs).not.toMatch(/\.forEach\s*\(/)
   })
 

package/src/__tests__/template-closure.test.ts

@@ -203,7 +203,7 @@ describe('#1128 — template body never reaches init-scope identifiers', () => {
 
     expect(tpl).not.toMatch(/\bitems\b/)
     // Bare `undefined.map(...)` would throw; substitute `[]` so the
-    // template renders an empty list and reconcileList populates it.
+    // template renders an empty list and mapArray populates it.
     expect(tpl).toMatch(/\$\{\[\]\.map\(/)
   })
 

package/src/compiler.ts

@@ -16,6 +16,7 @@ import { analyzeComponent, listComponentFunctions, createProgramForFile, needsTy
 import { jsxToIR } from './jsx-to-ir.ts'
 import { stripClientBuiltinImports } from './builtins.ts'
 import { generateClientJs, generateClientJsWithSourceMap, analyzeClientNeeds } from './ir-to-client-js/index.ts'
+import { decideClientOnlyElision } from './ir-to-client-js/client-only-elision.ts'
 import { emitModuleLevelDeclarations } from './ir-to-client-js/emit-module-level.ts'
 import { RUNTIME_MODULE, detectUsedImports as detectUsedImportsFromCode } from './ir-to-client-js/imports.ts'
 import { setActiveComponentScope, computeFileScope } from './ir-to-client-js/component-scope.ts'
@@ -140,6 +141,10 @@ function compileMultipleComponents(
     componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR)
     checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors)
 
+    // Slot unification Step B — see the single-component path's identical
+    // call for why this must run before adapter.generate/generateClientJs.
+    decideClientOnlyElision(componentIR.root)
+
     if (options.cssLayerPrefix) {
       applyCssLayerPrefix(componentIR, options.cssLayerPrefix)
     }
@@ -619,6 +624,12 @@ export function compileJSX(
   componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR)
   checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors)
 
+  // Slot unification Step B (`spec/slot-unification.md` §5 Step B): decide
+  // marker elision ONCE, mutating `componentIR.root` in place, before either
+  // `adapter.generate` or `generateClientJs` run below — both must see the
+  // SAME `markerless`/`elidedPath` flags on the SAME IR nodes.
+  decideClientOnlyElision(componentIR.root)
+
   // Cross-file @client signal sources: identify which import sources
   // need `.client.js` path rewriting in the client bundle.
   if (ctx.importedClientSignalNames.size > 0) {

package/src/index.ts

@@ -65,6 +65,7 @@ export { createProgramForCorpus, type SharedProgramOptions } from './shared-prog
 
 // JSX to IR transformer
 export { jsxToIR } from './jsx-to-ir.ts'
+export { decideClientOnlyElision } from './ir-to-client-js/client-only-elision.ts'
 
 // Module exports generation (compiler layer)
 export { generateModuleExports, extractFunctionParams, formatParamWithType, findReachableNames } from './module-exports.ts'