@barefootjs/jsx 0.34.0 → 0.35.0

package/src/__tests__/lazy-conditional.test.ts

@@ -51,13 +51,19 @@ const armsOf = (c: LoopChildConditional) => ({
 describe('analyzeLazyConditional — accepted', () => {
   test('two wiring-free static element arms', () => {
     const c = cond()
-    const r = analyzeLazyConditional(c, '__idx', armsOf(c))
+    const r = analyzeLazyConditional(c, armsOf(c))
     expect(r.lazySafe).toBe(true)
     if (r.lazySafe) {
       expect(r.facts.whenTrueHtml).toContain('bf-c="s0"')
       expect(r.facts.condition).toBe('row.done')
     }
   })
+
+  test('a condition reading the loop index is accepted (#2859 follow-up) — the caller classifies it like any other binding', () => {
+    const c = cond({ conditionFreeIdentifiers: new Set(['row', '__idx']) })
+    const r = analyzeLazyConditional(c, armsOf(c))
+    expect(r.lazySafe).toBe(true)
+  })
 })
 
 describe('analyzeLazyConditional — refusals', () => {
@@ -73,7 +79,7 @@ describe('analyzeLazyConditional — refusals', () => {
   for (const [name, over, reason] of wiring) {
     test(`the true arm owns ${name}`, () => {
       const c = cond({ whenTrue: bare(over) })
-      const r = analyzeLazyConditional(c, '__idx', armsOf(c))
+      const r = analyzeLazyConditional(c, armsOf(c))
       expect(r.lazySafe).toBe(false)
       if (!r.lazySafe) expect(r.reason).toMatch(reason)
     })
@@ -81,14 +87,14 @@ describe('analyzeLazyConditional — refusals', () => {
 
   test('the FALSE arm is checked too, not just the true one', () => {
     const c = cond({ whenFalse: bare({ events: [{} as never] }) })
-    const r = analyzeLazyConditional(c, '__idx', armsOf(c))
+    const r = analyzeLazyConditional(c, armsOf(c))
     expect(r.lazySafe).toBe(false)
     if (!r.lazySafe) expect(r.reason).toMatch(/its false arm owns events/)
   })
 
   test('a fragment conditional has no single node to replace', () => {
     const c = cond()
-    const r = analyzeLazyConditional(c, '__idx', {
+    const r = analyzeLazyConditional(c, {
       whenTrueHtml: asFragment('text only'),
       whenFalseHtml: asElement(c.whenFalseHtml),
     })
@@ -98,24 +104,18 @@ describe('analyzeLazyConditional — refusals', () => {
 
   test('an arm that interpolates a value cannot be hoisted once per loop', () => {
     const c = cond({ whenTrueHtml: '<span>${row().label}</span>' })
-    const r = analyzeLazyConditional(c, '__idx', armsOf(c))
+    const r = analyzeLazyConditional(c, armsOf(c))
     expect(r.lazySafe).toBe(false)
     if (!r.lazySafe) expect(r.reason).toMatch(/interpolates a value/)
   })
 
   test('a condition with no analyzable identifier set refuses rather than assumes', () => {
     const c = cond({ conditionFreeIdentifiers: undefined })
-    const r = analyzeLazyConditional(c, '__idx', armsOf(c))
+    const r = analyzeLazyConditional(c, armsOf(c))
     expect(r.lazySafe).toBe(false)
     if (!r.lazySafe) expect(r.reason).toMatch(/no analyzable identifier set/)
   })
 
-  test('a condition reading the loop index refuses — the apply bodies have none', () => {
-    const c = cond({ conditionFreeIdentifiers: new Set(['row', '__idx']) })
-    const r = analyzeLazyConditional(c, '__idx', armsOf(c))
-    expect(r.lazySafe).toBe(false)
-    if (!r.lazySafe) expect(r.reason).toMatch(/reads the loop index parameter '__idx'/)
-  })
 })
 
 // --- emission ---------------------------------------------------------------
@@ -175,6 +175,46 @@ describe('lazy row emission — wiring-free row conditional', () => {
   })
 })
 
+describe('lazy row emission — a conditional reading the loop index (#2859 follow-up)', () => {
+  // Mixed item+index condition — a PURE index-only reactive condition/attr is
+  // a separate, pre-existing, broader gap (the analyzer never classifies an
+  // expression that reads ONLY the loop index as reactive AT ALL, in either
+  // the eager or lazy path — filed separately, not this widening's job to
+  // fix). `row.done` is what makes the analyzer treat this condition as
+  // reactive in the first place; `i % 2 === 0` then rides along, which is
+  // exactly what this widening needs to prove.
+  const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Row = { id: number; label: string; done: boolean }
+export function CondRowsIndex(props: { rows: Row[] }) {
+  const [rows, setRows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map((row, i) => (
+        <li key={row.id}>{(row.done || i % 2 === 0) ? <span class="even">even</span> : <em class="odd">odd</em>}</li>
+      ))}
+    </ul>
+  )
+}
+`
+  const js = clientJs(source, 'CondRowsIndex.tsx')
+
+  test('the loop is still lazy — the index reference no longer forces eager', () => {
+    expect(js).toContain('mapArrayLazy(')
+  })
+
+  test('the condition is emitted into applyItem, reading the live entry.index', () => {
+    const applyItem = js.slice(js.indexOf('applyItem:'), js.indexOf("}, 'l0')"))
+    expect(applyItem).toMatch(/const i = __e\.index/)
+    expect(applyItem).toContain('i % 2 === 0')
+  })
+
+  test('the plan is marked indexDriven so a pure reorder re-evaluates it', () => {
+    expect(js).toMatch(/indexDriven:\s*true/)
+  })
+})
+
 describe('lazy row emission — conditionals that keep the eager path', () => {
   const cases: Array<[string, string]> = [
     ['an arm with an event', '{row.done ? <button onClick={() => {}}>x</button> : <em>open</em>}'],

package/src/__tests__/lazy-preamble.test.ts

@@ -33,11 +33,11 @@ const SIGNALS: ReadonlySet<string> = new Set(['selected', 'filter'])
 
 describe('analyzeLazyPreamble — accepted', () => {
   test('no preamble at all', () => {
-    expect(analyzeLazyPreamble(undefined, '__idx', SIGNALS).lazySafe).toBe(true)
+    expect(analyzeLazyPreamble(undefined, SIGNALS).lazySafe).toBe(true)
   })
 
   test('const declarations reading only the item', () => {
-    const r = analyzeLazyPreamble(preamble("const full = `${row.a} ${row.b}`;", ['full']), '__idx', SIGNALS)
+    const r = analyzeLazyPreamble(preamble("const full = `${row.a} ${row.b}`;", ['full']), SIGNALS)
     expect(r.lazySafe).toBe(true)
     if (r.lazySafe) expect([...r.facts.declaredNames]).toEqual(['full'])
   })
@@ -45,17 +45,22 @@ describe('analyzeLazyPreamble — accepted', () => {
   test('a zero-arg signal read is allowed — the krausest shape', () => {
     const r = analyzeLazyPreamble(
       preamble("const cls = selected() === row.id ? 'danger' : '';", ['cls']),
-      '__idx',
       SIGNALS,
     )
     expect(r.lazySafe).toBe(true)
   })
 
   test('a destructuring const contributes every bound name, not the property keys', () => {
-    const r = analyzeLazyPreamble(preamble('const { a, b: [c] } = row;', ['a', 'c']), '__idx', SIGNALS)
+    const r = analyzeLazyPreamble(preamble('const { a, b: [c] } = row;', ['a', 'c']), SIGNALS)
     expect(r.lazySafe).toBe(true)
     if (r.lazySafe) expect([...r.facts.declaredNames].sort()).toEqual(['a', 'c'])
   })
+
+  test('a preamble reading the loop index is accepted (#2859 follow-up) — the name survives into freeNames', () => {
+    const r = analyzeLazyPreamble(preamble('const n = __idx + 1;', ['n']), SIGNALS)
+    expect(r.lazySafe).toBe(true)
+    if (r.lazySafe) expect(r.facts.freeNames.has('__idx')).toBe(true)
+  })
 })
 
 describe('analyzeLazyPreamble — refusals', () => {
@@ -112,16 +117,11 @@ describe('analyzeLazyPreamble — refusals', () => {
       preamble('const selected = row.sel;', ['selected']),
       /shadows the signal\/memo getter 'selected'/,
     ],
-    [
-      'a preamble reading the loop index',
-      preamble('const n = __idx + 1;', ['n']),
-      /reads the loop index parameter '__idx'/,
-    ],
   ]
 
   for (const [name, p, reason] of cases) {
     test(name, () => {
-      const r = analyzeLazyPreamble(p, '__idx', SIGNALS)
+      const r = analyzeLazyPreamble(p, SIGNALS)
       expect(r.lazySafe).toBe(false)
       if (!r.lazySafe) expect(r.reason).toMatch(reason)
     })
@@ -134,7 +134,7 @@ describe('analyzeLazyPreamble — refusals', () => {
       declaredNames: [],
       builderNames: [],
     }
-    const r = analyzeLazyPreamble(p, '__idx', SIGNALS)
+    const r = analyzeLazyPreamble(p, SIGNALS)
     expect(r.lazySafe).toBe(false)
     if (!r.lazySafe) expect(r.reason).toMatch(/JSX leaf/)
   })

package/src/__tests__/lazy-row-eligibility.test.ts

@@ -152,12 +152,17 @@ describe('lazyRowEligibility — profile mode', () => {
 })
 
 describe('lazyRowEligibility — binding refusals', () => {
-  test('a binding referencing the loop index parameter is refused', () => {
+  // #2859 follow-up, LIFTED: a binding referencing the loop index no longer
+  // sinks the loop. `classifyLazyBinding` forces `readsItem: true` for it
+  // (the row's position is delivered on `entry.index` exactly like the item
+  // is on `entry.item`), so the row stays eligible and the binding lands in
+  // `applyItem`. Inverted from the refusal it replaces so a gate that starts
+  // refusing again fails here by name.
+  test('a binding referencing the loop index parameter is ELIGIBLE (index tracked via entry.index)', () => {
     const decision = lazyRowEligibility(args({
       bindings: [{ ...itemBinding(), referencesIndex: true }],
     }))
-    expect(decision.eligible).toBe(false)
-    expect((decision as { reason: string }).reason).toMatch(/index parameter/)
+    expect(decision.eligible).toBe(true)
   })
 
   // §9.3a, LIFTED: an outer name the emitter cannot prime no longer sinks

package/src/__tests__/loop-child-reactive-attr-const-shadow.test.ts

@@ -36,6 +36,23 @@
  * `collectLoopChildBindings` / `collectLoopChildConditionals` /
  * `summarizeLoopChildBranch` / `collectLoopChildReactiveAttrs` /
  * `collectLoopChildReactiveTexts` into `buildLoopRowScope`.
+ *
+ * #2859: `i` is now ALSO rewritten to `i()` (`wrapLoopParamAsAccessor`,
+ * `ir-to-client-js/utils.ts`) on the EAGER path — `mapArray` hands
+ * `renderItem` an index ACCESSOR (mirroring the item accessor) and pushes
+ * each row's current position through it on every same-key reconcile, so
+ * a row surviving a reorder keeps reading its live index instead of the
+ * value frozen at creation. The #2595 fix above only prevented the
+ * module-const shadow; it still left `i` reading a plain, never-updated
+ * closure variable.
+ *
+ * #2859 follow-on (lazy-row widening): this exact shape has no ref/child
+ * component/inner loop, so it is now LAZY-eligible — the index reference
+ * no longer forces eager on its own. On the lazy path there is no `i()`
+ * accessor call at all: `applyItem` binds `const i = __e.index` (a plain
+ * value read off the reconciler-tracked entry) and the attribute reads
+ * that bare `i`, which is exactly as live across a reorder as the eager
+ * accessor was.
  */
 
 import { describe, test, expect } from 'bun:test'
@@ -99,9 +116,14 @@ describe('loop-child reactive attr vs a loop INDEX param shadowing a module cons
       }
     `)
 
-    // The per-item attribute effect must read the row's OWN index
-    // closure variable — never the outer module const's baked literal.
-    expect(js).toContain("const __v = i;")
+    // The per-item attribute effect must read the row's OWN, LIVE index
+    // (#2859 follow-on: `entry.index`, tracked by the lazy-row reconciler
+    // the same way it tracks `entry.item`) — never the outer module
+    // const's baked literal, and never a frozen closure variable that
+    // would go stale after a reorder.
+    expect(js).toContain('const i = __e.index')
+    expect(js).toContain('const __x = i')
     expect(js).not.toContain("const __v = 'MODULE_CONST';")
+    expect(js).not.toContain("const __x = 'MODULE_CONST'")
   })
 })

package/src/__tests__/loop-item-conditional-codegen.test.ts

@@ -71,9 +71,11 @@ describe('#1665 — keyless whole-item conditional emits valid JS (BF023)', () =
     const { js, errorCodes } = clientJsFor('sel() === t.id && <li>{t.id}</li>', /* withKey */ false)
     expect(errorCodes).toContain(ErrorCodes.MISSING_KEY_IN_LIST)
     // No empty template-literal interpolation, and the anchor falls back to the
-    // iteration index so the comment value is well-formed.
+    // iteration index so the comment value is well-formed. `__idx` is bound to
+    // an index ACCESSOR at runtime (#2859), so the fallback calls it like
+    // every other reference to the loop's index parameter.
     expect(js).not.toContain('${}')
-    expect(js).toContain('bf-loop-i:${__idx}')
+    expect(js).toContain('bf-loop-i:${__idx()}')
     // The whole client module must parse.
     const body = js.replace(/^import[^\n]*\n/gm, '').replace(/^export /gm, '')
     expect(() => new Function(body)).not.toThrow()

package/src/__tests__/map-arbitrary-body.test.ts

@@ -60,7 +60,7 @@ describe('.map() array-builder body — JS-runtime verbatim (Stage 3 / D4)', ()
     // Byte-level parity is pinned by the map-array-builder-escaping fixture.
     const r = compile(arrayBuilder, false)
     const cj = r.files.find(f => f.type === 'clientJs')!.content
-    expect(cj).toMatch(/out\.push\(`<td>\$\{escapeText\(\(c\)\)\}<\/td>`\)/)
+    expect(cj).toMatch(/out\.push\(`<td>\$\{escapeText\(c\)\}<\/td>`\)/)
   })
 
   test('the element-array child {out} is joined into the row', () => {

package/src/__tests__/nested-loop-index-param.test.ts

@@ -63,7 +63,11 @@ describe('nested .map() index param referenced in key/text/attr (#2218)', () =>
     // The renderItem body binds the alias before using it.
     expect(content).toContain('const i = __innerIdx')
     const aliasIdx = content.indexOf('const i = __innerIdx')
-    const setAttrIdx = content.indexOf(`setAttribute('data-key-1', String(i))`)
+    // `i` is bound to an index ACCESSOR at runtime (#2859) — `mapArray` hands
+    // every renderItem an index accessor (mirroring the item accessor) and
+    // pushes the row's current position through it on reorder, so `i()` reads
+    // the live value instead of a plain number frozen at row creation.
+    const setAttrIdx = content.indexOf(`setAttribute('data-key-1', String(i()))`)
     expect(aliasIdx).toBeGreaterThanOrEqual(0)
     expect(setAttrIdx).toBeGreaterThan(aliasIdx)
     // The alias must land before the clone IIFE too — the cloned template's
@@ -156,7 +160,12 @@ describe('nested .map() index param referenced in key/text/attr (#2218)', () =>
     `)
 
     expect(content).toContain('const i = __innerIdx')
-    expect(content).toContain('setClicked(i)')
+    // A direct (non-delegated) listener on a nested-loop row reads the row's
+    // LIVE index accessor (#2859) — unlike the top-level delegated click
+    // dispatcher (`event-delegation-index-param.test.ts`), this handler is
+    // attached once at row creation, so without this it would keep firing
+    // with the index the row was first created at after a same-key reorder.
+    expect(content).toContain('setClicked(i())')
   })
 
   test('byte-stability: index declared but never referenced emits no alias', () => {
@@ -278,7 +287,9 @@ describe('nested .map() index param referenced in key/text/attr (#2218)', () =>
     expect(content).toContain('(item, i) => String(i)')
     expect(content).toContain('const i = __bidx')
     const aliasIdx = content.indexOf('const i = __bidx')
-    const setAttrIdx = content.indexOf(`setAttribute('data-key-1', String(i))`)
+    // `i` reads the live index accessor (#2859) — see the sibling assertion
+    // in the 'key={i}' test above.
+    const setAttrIdx = content.indexOf(`setAttribute('data-key-1', String(i()))`)
     expect(aliasIdx).toBeGreaterThanOrEqual(0)
     expect(setAttrIdx).toBeGreaterThan(aliasIdx)
   })

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

@@ -394,8 +394,10 @@ describe('reactive attributes inside a nested .map() body (#135)', () => {
     // The helper call must appear inside a createEffect alongside the
     // 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]*?__bfw_\w+\('s\d+', String\(labelAt\(pi\)\)\)/)
+    // effect missing (the exact regression here). `pi` reads the row's
+    // live index accessor (#2859), so `labelAt(pi())` also stays correct
+    // if this innermost loop's rows ever survive a same-key reorder.
+    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?__bfw_\w+\('s\d+', String\(labelAt\(pi\(\)\)\)\)/)
     expect(content).toContain("setAttribute('class'")
   })
 })

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

@@ -266,17 +266,20 @@ describe('reactive attributes inside .map() callbacks', () => {
     expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
 
     const clientJs = result.files.find(f => f.type === 'clientJs')!.content
-    // The per-item style binding must be wired through a createEffect that
-    // re-reads the helper and writes the style attribute, so it tracks the
-    // `items()` signal and updates after hydration. Pin the helper call
-    // *inside* the createEffect alongside the style write — `widthAt(` also
+    // The per-item style binding must be wired reactively — re-reading the
+    // helper and writing the style attribute, so it tracks the `items()`
+    // signal and updates after hydration, rather than being baked into the
+    // item template once. This row has no ref/child component/inner loop,
+    // so it is lazy-eligible (#2859 follow-on): `widthAt(i)` reads the
+    // index (forcing `applyItem`) and closes over `items()` opaquely
+    // (forcing `applyOuter` too, via the re-subscribe seam), so BOTH apply
+    // bodies re-evaluate it, not a `createEffect`. Pin the helper call
+    // *inside* `applyItem` alongside the style write — `widthAt(` also
     // appears in the static template clone, so asserting it independently
-    // could pass even if the effect was missing (the exact regression here).
-    // The index resolves to the loop's renderItem index param, in scope
-    // inside the factory.
-    expect(clientJs).toMatch(
-      /createEffect\(\(\)\s*=>\s*\{[\s\S]*?widthAt\([\s\S]*?setAttribute\('style'/,
-    )
+    // could pass even if the reactive wiring were missing (the exact
+    // regression here).
+    const applyItem = clientJs.slice(clientJs.indexOf('applyItem:'), clientJs.indexOf('applyOuter:'))
+    expect(applyItem).toMatch(/widthAt\([\s\S]*?setAttribute\('style'/)
   })
 
   test('keyed loop: `key` prop is not emitted as a reactive DOM attribute', () => {

package/src/__tests__/rewrite-destructured-props.test.ts

@@ -124,3 +124,40 @@ export { Comp }
     expect(js).toContain("items.map((tag) => tag.a).join(',') + _p.tag")
   })
 })
+
+// #2828 follow-up (pullfrog review on #2853): `collectBranchLocalPropRefsViaSubstitution`
+// (jsx-to-ir.ts) is a second, independent AST walk that decides whether a
+// branch-local variable's TRANSITIVE prop dependency gets unioned into a
+// reactive expression's rewrite — same "is this a value reference" question
+// #2828 fixed in `collectAstPropRefs`, but this walk had its own,
+// un-fixed `isShorthand` exclusion. A branch-local whose own initializer
+// reads a prop, referenced via object-literal shorthand inside a REACTIVE
+// expression, had its prop dependency silently dropped: the emitted
+// module-scope hydrate template lambda kept a bare, unprefixed reference
+// to the prop name instead of `_p.<prop>`.
+describe('branch-local transitive prop-dep via shorthand reference (#2828 follow-up)', () => {
+  test('a branch-local read from a prop, referenced via shorthand, still resolves to _p.<prop> in the hydrate template', () => {
+    const source = `
+"use client"
+import { createSignal } from '@barefootjs/client'
+export function Comp({ tag }: { tag: string }) {
+  const [n] = createSignal(0)
+  if (n() > 0) {
+    const local = tag
+    return <div data-x={JSON.stringify({ local }) + n()}>{n()}</div>
+  }
+  return <div>none</div>
+}
+`
+    const js = compileClientJs(source)
+    // Pre-fix: the hydrate template's module-scope lambda kept a bare
+    // `tag` reference (no binding at that scope -- ReferenceError at pure
+    // CSR mount). Post-fix: it resolves through `_p.tag` like every other
+    // prop reference. (The surrounding `{ (_p.tag) }` shape -- the branch-
+    // local substitution dropping the shorthand's own key -- is a
+    // separate, pre-existing defect tracked independently; this test pins
+    // only the prop-dependency question #2828's follow-up fixed.)
+    expect(js).not.toContain('{ (tag) }')
+    expect(js).toContain('{ (_p.tag) }')
+  })
+})

package/src/__tests__/safe-html-splice-door.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Direct unit tests for `spliceChildValue`'s arm order (#2795 follow-up).
+ *
+ * The door's arm order changed during the #2795 migration:
+ * `node.joinArrayChild` is now checked BEFORE `cx.branchSlotsVar`. Before,
+ * `irToHtmlTemplate` wrapped an array in `__bfSlot` first and joined after —
+ * for an element-array child (`{out}`, built by an arbitrary `.map()`
+ * preamble) rendered INSIDE a conditional branch, that would have handed
+ * `__bfSlot` the whole array-join expression, which stringifies an array
+ * argument via `String(...)`-style coercion internally rather than joining
+ * compiled-leaf HTML — corrupting already-escaped leaf markup. Joining first
+ * (the current order) hands `__bfSlot` a single already-assembled HTML
+ * string instead.
+ *
+ * PR #2858 shipped this reorder without a test exercising the co-occurrence
+ * (join-array-child AND branch-slot at once) — this file is that test,
+ * added directly against the door function rather than a full JSX compile,
+ * since the arm order is entirely `spliceChildValue`'s own concern.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { spliceChildValue } from '../ir-to-client-js/safe-html'
+
+describe('spliceChildValue arm order', () => {
+  test('joinArrayChild wins over branchSlotsVar — the array is joined, not handed to __bfSlot', () => {
+    const result = spliceChildValue(
+      { expr: 'out', slotId: null, joinArrayChild: true },
+      'out',
+      { branchSlotsVar: 'slots' },
+    )
+    expect(result).toBe(`Array.isArray(out) ? out.join('') : (out ?? '')`)
+    expect(result).not.toContain('__bfSlot')
+  })
+
+  test('branchSlotsVar alone (no joinArrayChild) still routes through __bfSlot', () => {
+    const result = spliceChildValue(
+      { expr: 'value', slotId: null, joinArrayChild: false },
+      'value',
+      { branchSlotsVar: 'slots' },
+    )
+    expect(result).toBe('__bfSlot(value, slots)')
+  })
+
+  test('neither joinArrayChild nor branchSlotsVar nor slotId nor children — plain escapeText default', () => {
+    const result = spliceChildValue(
+      { expr: 'label', slotId: null, joinArrayChild: false },
+      'label',
+      {},
+    )
+    expect(result).toBe('escapeText(label)')
+  })
+
+  test('a markup-claimed slotId still escapes-or-unwraps even with joinArrayChild absent', () => {
+    const result = spliceChildValue(
+      { expr: 'title', slotId: 's0', joinArrayChild: false },
+      '(title)',
+      { markupSlotIds: new Set(['s0']) },
+    )
+    expect(result).toBe('escapeTextOrMarkup((title))')
+  })
+})

package/src/__tests__/ssr-defaults.test.ts

@@ -499,6 +499,65 @@ describe('extractSsrDefaults', () => {
     // it does not abort the whole computation.
     expect(defaults?.x).toEqual({ value: [1, null] })
   })
+
+  // #2813 (pullfrog nitpick on the PR fixing it): a bare local-const alias
+  // of a signal getter must be seeded under its OWN name too, alongside
+  // the getter's — a template-stash adapter's `.map()` loop over
+  // `items__alias()` looks up the stash entry by that name, which the
+  // getter-name-only seeding above never creates.
+  test('a bare local-const alias of a signal getter is seeded under the alias name too', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [items] = createSignal([1, 2, 3])
+        const items__alias = items
+        return <ul>{items__alias().map(n => <li key={n}>{n}</li>)}</ul>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.items).toEqual({ value: [1, 2, 3] })
+    expect(defaults?.items__alias).toEqual({ value: [1, 2, 3] })
+  })
+
+  test('a multi-hop local-const alias chain resolves through every link', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [items] = createSignal([1, 2, 3])
+        const hop1 = items
+        const hop2 = hop1
+        return <ul>{hop2().map(n => <li key={n}>{n}</li>)}</ul>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.items).toEqual({ value: [1, 2, 3] })
+    expect(defaults?.hop1).toEqual({ value: [1, 2, 3] })
+    expect(defaults?.hop2).toEqual({ value: [1, 2, 3] })
+  })
+
+  test('a getter alias shares the ORIGIN entry object, including a self-derivation-collision propName shape', () => {
+    // The origin signal's OWN name collides with the prop its initializer
+    // derives from (#2669), so its entry is a propName-carrying prop
+    // entry, not a plain `{ value }` — the alias must share that exact
+    // shape (same object reference), not re-derive a plain value entry.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label] = createSignal(props.label ?? 'Default')
+        const labelAlias = label
+        return <p>{labelAlias()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+    expect(defaults?.labelAlias).toBe(defaults?.label)
+  })
 })
 
 // TS twin of the Ruby/Python/PHP/Perl/Rust `derive*FromDefaults` runtime

package/src/analyzer.ts

@@ -1998,6 +1998,9 @@ const CLIENT_EXPORTS = new Set([
   'forwardProps', 'unwrap', '__slot',
   'createContext', 'useContext', 'provideContext',
   'createPortal', 'isSSRPortal', 'findSiblingSlot', 'cleanupPortalPlaceholder',
+  // Floating-element position tracking (#2848) — same runtime-only shape
+  // as the portal entries above.
+  'trackPosition',
   // Request-scoped environment signal factory (router v0.5) — `createSignal`-
   // shaped, recognised structurally (#2057) so its getter is just a signal
   // getter; the compiler lowers the reader value per adapter via the signal's
@@ -4221,6 +4224,7 @@ export const BROWSER_ONLY_CLIENT_APIS = new Set([
   'isSSRPortal',
   'findSiblingSlot',
   'cleanupPortalPlaceholder',
+  'trackPosition',
 ])
 
 function importsBrowserOnlyClientApi(ctx: AnalyzerContext): boolean {

package/src/index.ts

@@ -11,10 +11,16 @@ export type { CompileResult, CompileOptions, CompileOptionsWithAdapter, FileOutp
 // SSR template-variable defaults (manifest seeds for stash-based adapters)
 export { extractSsrDefaults, deriveStashFromDefaults } from './ssr-defaults.ts'
 
-// Shared props-destructure binding + alias-map helpers (#2524)
-export { propsDestructureBinding, buildPropAliasMap, isIdentifierName } from './props-binding.ts'
+// Shared props-destructure binding + alias-map helpers (#2524, #2788)
+export { propsDestructureBinding, buildPropAliasMap, isIdentifierName, resolveBodyDestructuredPropAliases } from './props-binding.ts'
 export type { SsrDefault } from './ssr-defaults.ts'
 
+// Bare local-const alias-hop resolution for a signal/memo getter name
+// (`const items__alias = items`) — #2778's CSR-template fix, reused (not
+// re-walked) by SSR-side alias resolution (#2813: DSL stash seeding,
+// Go's zero-arg-call field routing).
+export { resolveGetterAliases, collectAliasableGetterNames } from './ir-to-client-js/csr-substitute.ts'
+
 // Import-alias resolution (#2777 client-JS registry key; #2822 SSR cross-template
 // call names) — a local alias -> declared/exported name map built from
 // `ir.metadata.imports`. DSL adapters build this once per compile and look up

package/src/ir-to-client-js/collect-elements.ts

@@ -309,7 +309,7 @@ export function collectInnerLoops(
         // Forward destructured bindings (#951) so inner-loop template
         // references to the destructured locals are rewritten.
         const loopParamsForTemplate = outerLoopParam
-          ? [outerLoopParam, { param: n.param, bindings: n.paramBindings }]
+          ? [outerLoopParam, { param: n.param, bindings: n.paramBindings, index: n.index }]
           : undefined
         const template = n.children.map(c => irToPlaceholderTemplate(c, undefined, emitDepth, loopParamsForTemplate)).join('')
         // Check if array expression references the outer loop param
@@ -755,6 +755,18 @@ export function collectElements(
         // avoiding post-hoc regex wrapping that corrupts literal attribute values.
         // Forward destructured bindings (#951) so references like `cfg.color`
         // in the emitted template literal are rewritten to `__bfItem()[1].color`.
+        // NOT `index: l.index` here (#2859 follow-up): this exact template
+        // string is reused verbatim by the LAZY row plan when this loop is
+        // lazy-eligible (`LazyRowPlanData`'s clone source, and — via
+        // `mapPreambleWrapped` — its `preambleStatements`) — `mapArrayLazy`'s
+        // `createRow(entry, index)` still hands the row a plain NUMBER
+        // (map-array-lazy.ts is untouched by #2859), so baking `i()` in here
+        // would call a number. Lazy-row eligibility only refuses a REACTIVE
+        // binding that references the index — a non-reactive use like a
+        // `data-key` built from the index is not gated the same way, so this
+        // can't assume "lazy-eligible ⇒ no index in the template" either.
+        // `buildPlainLoopPlan`/`buildBranchLoopPlan` apply the index wrap
+        // themselves, AFTER lazy eligibility is decided, only when it's `null`.
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }]
         template = useElementReconciliation
           ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec)
@@ -1165,6 +1177,10 @@ function collectBranchLoops(
       // keeping the template consistent with reactive effect expressions that
       // use `param()` to read the current item value.
       let childTemplate: string
+      // NOT `index: n.index` here — see the identical note on `loopParamSpec`
+      // above; `BranchLoop.template` is reused verbatim by the lazy row plan
+      // too (`callSite: 'branch-plain'`), and `buildBranchLoopPlan` applies
+      // the index wrap itself once lazy eligibility is known (#2859 follow-up).
       const branchLoopParamSpec = [{ param: n.param, bindings: n.paramBindings }]
       if (projectionInner) {
         childTemplate = '' // descriptor renderItem builds from d.h, not a row template
@@ -1478,7 +1494,7 @@ export function collectLoopChildConditionals(
       if (!readsPreamble && classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === 'none') return
 
       const loopParamsForCond = loopParam
-        ? [{ param: loopParam, bindings: loopParamBindings }]
+        ? [{ param: loopParam, bindings: loopParamBindings, index: loopIndex }]
         : undefined
       // `__slots` matches the closure variable emitted by
       // `stringifyLoopChildConditional` — Child-position interpolations