@barefootjs/jsx 0.35.1 → 0.35.3

package/dist/ir-to-client-js/plan/build-static-array-child-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/build-static-array-child-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAA4B,MAAM,aAAa,CAAA;AAoB5E,OAAO,KAAK,EAQV,yBAAyB,EAC1B,MAAM,8BAA8B,CAAA;AAErC,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,eAAe,GACnB,yBAAyB,CAsC3B"}
+{"version":3,"file":"build-static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/build-static-array-child-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAmD,MAAM,aAAa,CAAA;AAoBnG,OAAO,KAAK,EAQV,yBAAyB,EAC1B,MAAM,8BAA8B,CAAA;AAErC,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,eAAe,GACnB,yBAAyB,CA4D3B"}

package/dist/ir-to-client-js/plan/static-array-child-init.d.ts

@@ -7,7 +7,9 @@
  *   - `outer-nested`       — depth 0 の `nestedComponents`。outer forEach で
  *                            `__iterEl.querySelector(...)` 経由で initChild。
  *   - `inner-loop-nested`  — depth > 0 の `nestedComponents`。outer + inner
- *                            forEach の二重ループで initChild。
+ *                            forEach の二重ループで initChild。同じ二重ループで
+ *                            プレーン要素の ref / reactive text / reactive attr
+ *                            も配線する (#2798、depth 1 のみ)。
  *   - `component-rooted-inner-loop`
  *                          — outer の loop item root が **child component**
  *                            (`loop.childComponent`) で、その JSX children に
@@ -23,6 +25,8 @@
  * shapes were determined by inline branching on the IR.
  */
 import type { PreludeStatements } from '../control-flow/plan/inner-loop.ts';
+import type { LoopChildRefBinding } from '../control-flow/plan/loop.ts';
+import type { LoopChildReactiveAttr, LoopChildReactiveText } from '../types.ts';
 /** Pre-built `{ name: value, ... }` props object expression. */
 export type PropsExpr = string;
 /** A single child-component initialiser inside an inner-loop body. */
@@ -137,6 +141,20 @@ export interface InnerLoopNestedInitPlan {
     depth: number;
     /** Per-component initialisers emitted inside the inner forEach body. */
     comps: readonly InnerLoopComp[];
+    /**
+     * Reactive attrs on plain elements inside this inner loop's body,
+     * grouped by child slot id (#2798 — a static outer array's nested
+     * `.map()` over plain elements used to wire up NOTHING: no refs, no
+     * reactive text/attr effects, since the whole `elem.innerLoops` pass
+     * only ever ran for depth-N CHILD COMPONENTS). Only populated for a
+     * depth-1 inner loop under a plain-element-rooted outer item — see
+     * `buildStaticArrayChildInitsPlan`'s docstring.
+     */
+    attrsBySlot: ReadonlyArray<readonly [string, readonly LoopChildReactiveAttr[]]>;
+    /** Reactive text interpolations inside this inner loop's body (#2798). */
+    texts: readonly LoopChildReactiveText[];
+    /** Imperative ref callbacks on elements inside this inner loop's body (#2798). */
+    refs: readonly LoopChildRefBinding[];
 }
 /**
  * Plan for an inner `.map()` of components living inside a **component-rooted**

package/dist/ir-to-client-js/plan/static-array-child-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/static-array-child-init.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/static-array-child-init.ts"],"names":[],"mappings":"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"}

package/dist/ir-to-client-js/stringify/static-array-child-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/stringify/static-array-child-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAMV,yBAAyB,EAC1B,MAAM,oCAAoC,CAAA;AAG3C,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,yBAAyB,GAC/B,IAAI,CAIN"}
+{"version":3,"file":"static-array-child-init.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/stringify/static-array-child-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAMV,yBAAyB,EAC1B,MAAM,oCAAoC,CAAA;AAO3C,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,yBAAyB,GAC/B,IAAI,CAIN"}

package/dist/jsx-to-ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,KAAK,MAAM,EAgCZ,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,eAAe,EAA0E,MAAM,uBAAuB,CAAA;AAkhCpI,wBAAgB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAOhE"}
+{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,KAAK,MAAM,EAgCZ,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,eAAe,EAA0E,MAAM,uBAAuB,CAAA;AAmhCpI,wBAAgB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAOhE"}

package/dist/prop-rewrite.d.ts

@@ -33,6 +33,32 @@ import ts from 'typescript';
  * #1425).
  */
 export declare function collectAstPropRefs(node: ts.Node, propNames: Set<string>, out: Set<string>): void;
+/**
+ * Scope-aware rewrite: parse `text` as an expression, walk it with the
+ * binding stack, and splice `replacementFor(name)` onto exactly the
+ * identifier references that are (a) in `names` and (b) not shadowed by
+ * a binding inside the text. Shorthand properties expand
+ * (`{ org }` → `{ org: <replacement> }`) so the result stays
+ * syntactically valid — this is the one place in the compiler that
+ * correctly distinguishes a value reference from an object-literal key
+ * / property-access name / shorthand property / binding name, so every
+ * caller doing this class of substitution (prop refs, #1425 branch-local
+ * refs, …) should route through this rather than growing its own
+ * regex-based text splice (#2856 — a second, regex-based substitution
+ * mechanism doesn't know shorthand is simultaneously a key and a value,
+ * and drops the key).
+ *
+ * With `allowStatements`, a `text` that fails to parse as a bare
+ * expression is retried as a standalone statement list (no wrapping
+ * parens) — for callers whose raw-captured text isn't guaranteed to be
+ * expression-shaped (e.g. a `.map()`-callback preamble statement).
+ *
+ * Returns null when `text` doesn't parse cleanly under either attempt —
+ * the caller falls back to its own legacy mechanism.
+ */
+export declare function rewriteScopedValueRefs(text: string, names: ReadonlySet<string>, replacementFor: (name: string) => string, opts?: {
+    allowStatements?: boolean;
+}): string | null;
 /**
  * Apply the targeted regex rewrite for one or more prop names on a
  * type-stripped expression text. Idempotent under `_p.X` (negative

package/dist/prop-rewrite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prop-rewrite.d.ts","sourceRoot":"","sources":["../src/prop-rewrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAoF3B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GACf,IAAI,CAMN;AA8DD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC1B,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAChE,MAAM,CAqBR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAChE,MAAM,GAAG,SAAS,CAcpB"}
+{"version":3,"file":"prop-rewrite.d.ts","sourceRoot":"","sources":["../src/prop-rewrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AA6F3B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GACf,IAAI,CAMN;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACxC,IAAI,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GACnC,MAAM,GAAG,IAAI,CAmCf;AA6BD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC1B,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAChE,MAAM,CAqBR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAChE,MAAM,GAAG,SAAS,CAcpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.35.1"
+    "@barefootjs/shared": "0.35.3"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

package/src/__tests__/binding-scope-ratchet.test.ts

@@ -124,7 +124,7 @@ const ALLOWLIST: Record<string, Partial<Record<Pattern, number>>> = {
     // passthrough, called only from `generateNewPropsFunction`'s
     // `emitStaticChildInstances`), `computeDerivedConstFields` and
     // `isStringExpr` (same `generateNewPropsFunction` constructor-context
-    // bucket), and `resolveModuleNumericConst` (guarded in place by
+    // bucket), and `resolveModuleConstAsGo` (guarded in place by
     // `isCurrentLoopItem`/`isOuterLoopParam`, both already `this.scope.lookup`-
     // backed) — 3 are shape-1 (no live scope in the ctor-generation prepass)
     // and 1 is already scope-guarded. The 5th, `renderLoop`'s loop-array

package/src/__tests__/branch-local-in-attr-position.test.ts

@@ -305,19 +305,28 @@ describe('branch-local at element-attribute position (#1414)', () => {
     expect(hydrate).toContain('foo bar')
   })
 
-  test('branch-local substitution skips string literals and `$`-prefixed identifiers', () => {
+  test('branch-local substitution skips string-literal text and correctly resolves a `$`-prefixed identifier', () => {
     // The substitution machinery used to scan with `text.replace(/\b
     // (name1|name2)\b/g, ...)`, which would (a) rewrite occurrences
     // of the name inside string literals into invalid JS and
     // (b) mis-match `\b` between `$` and a word char, splitting an
     // identifier like `$kind` and rewriting just its `kind` tail.
-    // The fix routes both substitution passes through
-    // `replaceInExprContexts` (skips opaque tokens — strings, regex,
-    // template bodies, comments) and replaces `\b` with `[\w$]`
-    // lookarounds so the boundary check treats `$` as part of an
-    // identifier. This test pins both invariants by declaring a
-    // branch-local whose name collides with a token inside a string
-    // literal *and* with the tail of a `$`-prefixed identifier.
+    // The regex-scanner fallback (`replaceInExprContexts`, still used
+    // when text doesn't parse as an expression/statement list) fixes
+    // both by skipping opaque tokens — strings, regex, template
+    // bodies, comments — and replacing `\b` with `[\w$]` lookarounds.
+    // But it treats an entire template literal as one opaque token,
+    // so it can't reach a branch-local reference INSIDE a `${...}`
+    // hole either — `$kind` used to survive as a literal, undeclared
+    // identifier in the emitted output (a latent ReferenceError, the
+    // same failure class as #2856). The AST-based
+    // `rewriteScopedValueRefs` (#2856) parses the template literal
+    // properly and resolves the hole like any other expression
+    // position, while still leaving the cooked text (`label:kind=`)
+    // alone since it's not an identifier. This test pins a branch-local
+    // whose name collides with a token inside a string literal *and*
+    // with the tail of a `$`-prefixed identifier used inside a
+    // template-literal hole.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -345,9 +354,12 @@ describe('branch-local at element-attribute position (#1414)', () => {
     // verbatim — pre-fix, the `kind` inside the template-literal head
     // would have been rewritten into `('plain')`, mangling the string.
     expect(clientJs).toContain('label:kind=')
-    // The `$kind` identifier must stay intact — pre-fix, `\\bkind\\b`
-    // would have split `$kind` into `$` + `kind` and rewritten just
-    // the `kind` tail.
-    expect(clientJs).toContain('$kind')
+    // The `$kind` identifier (distinct from the branch-local `kind`)
+    // must resolve to its own branch-local value, not leak through
+    // unresolved (which would be a ReferenceError at hydrate — no
+    // `$kind` binding exists in the emitted module scope) and not have
+    // its `kind` tail mistakenly matched by the `kind` substitution.
+    expect(clientJs).not.toMatch(/[^(]\$kind\b/)
+    expect(clientJs).toContain("label:kind=${('dollar')}")
   })
 })

package/src/__tests__/client-only-date-lowering.test.ts

@@ -22,10 +22,38 @@
  * about would fire BF021 and never reach the reactive-emission sites this
  * suite is about.
  */
-import { describe, test, expect } from 'bun:test'
+import { describe, test, expect, beforeAll } from 'bun:test'
 import { compileJSX } from '../index'
 import { TestAdapter } from '../adapters/test-adapter'
 import { ErrorCodes } from '../errors'
+import { getLoweringPlugins } from '../lowering-registry'
+import { BUILTIN_LOWERING_PLUGINS } from '../builtin-lowering-plugins'
+
+// #2831 — the persistent, CI-only "test (jsx-2)" flake on this suite's own
+// assertions traced to `date-lowering.test.ts`'s per-test `afterEach`
+// filtering the built-in `'date'` plugin out of the SHARED, module-level
+// `lowering-registry.ts` registry (fixed: dbaba32, "date-lowering.test.ts
+// leaked the built-in 'date' plugin out of the shared registry"). `bun
+// test` runs every file in one process with no guaranteed file order, so a
+// leak in one file's registry manipulation silently starves every
+// LATER-running file that depends on a built-in plugin — this suite's own
+// `datePlugin`/`toLocaleDatePlugin` dependency was the victim. A future
+// leak of the same shape would again fail here as a confusing "lowering
+// wasn't applied" assertion with no clue why. This guard converts that
+// into a named, up-front failure instead.
+beforeAll(() => {
+  const registered = new Set(getLoweringPlugins().map((p) => p.name))
+  const missing = BUILTIN_LOWERING_PLUGINS.map((p) => p.name).filter((name) => !registered.has(name))
+  if (missing.length > 0) {
+    throw new Error(
+      `Built-in lowering plugin(s) missing from the shared registry before this suite ran: ${missing.join(', ')}. ` +
+        `This suite's assertions depend on them being registered — a SIBLING test file most likely reset or ` +
+        `filtered the shared \`lowering-registry.ts\` registry without restoring it (the #2831 bug class: use ` +
+        `\`beforeAll\`/\`afterAll\` snapshot-and-restore around a describe block, never a per-test \`afterEach\` ` +
+        `filter, when touching this shared, module-level registry).`,
+    )
+  }
+})
 
 function compile(src: string) {
   const result = compileJSX(src.trimStart(), 'T.tsx', { adapter: new TestAdapter() })

package/src/__tests__/issue-2798-static-nested-loop-bindings.test.ts

@@ -0,0 +1,127 @@
+/**
+ * #2798: a static (non-signal) array's `.map()` faithfully invokes a
+ * `ref` callback, and reactively updates a signal-derived text, on the
+ * TOP-LEVEL row (`buildStaticLoopPlan`'s `childRefs`/`texts`). But a
+ * nested `.map()` INSIDE a static outer row's item — a plain element,
+ * not a child component — reached `elem.innerLoops` processing only
+ * when it had matching depth-N CHILD COMPONENTS
+ * (`buildStaticArrayChildInitsPlan`'s `innerComps.length === 0`
+ * skip). A plain-element inner loop under a static outer array had
+ * NOTHING wired: no ref invocation, no reactive-text/attr effect — the
+ * whole row was silently frozen at its SSR-baked value.
+ *
+ * (The issue's own repro — a TOP-LEVEL static loop with a `ref` — was
+ * already fixed by the time this was investigated; that shape is
+ * pinned here too as regression armor against the issue's own
+ * misdiagnosis being reintroduced.)
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../index'
+import { HonoAdapter } from '../../../adapter-hono/src/adapter/index'
+
+function compileClientJs(source: string): string {
+  const result = compileJSX(source, 'test.tsx', { adapter: new HonoAdapter() })
+  expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  const clientJs = result.files.find(f => f.type === 'clientJs')
+  if (!clientJs) throw new Error('No client JS emitted')
+  return clientJs.content
+}
+
+describe('static array ref/reactive bindings (#2798)', () => {
+  test('top-level static loop still invokes a ref on each row (regression armor)', () => {
+    const source = `
+'use client'
+export function StaticRefCase() {
+  const items = [{ id: 1 }, { id: 2 }]
+  const trackMount = (el: Element) => { el.setAttribute('data-tracked', '1') }
+  return (
+    <ul>
+      {items.map(item => (
+        <li key={item.id} ref={trackMount}>{item.id}</li>
+      ))}
+    </ul>
+  )
+}
+`
+    const js = compileClientJs(source)
+    expect(js).toContain('(trackMount)(')
+  })
+
+  test('a static outer loop with a nested .map() invokes the inner ref on each row', () => {
+    const source = `
+'use client'
+export function StaticNestedRefCase() {
+  const items = [{ id: 1, children: [{ id: 11 }, { id: 12 }] }]
+  const trackMount = (el: Element) => { el.setAttribute('data-tracked', '1') }
+  return (
+    <ul>
+      {items.map(item => (
+        <li key={item.id}>
+          {item.children.map(child => (
+            <span key={child.id} ref={trackMount}>{child.id}</span>
+          ))}
+        </li>
+      ))}
+    </ul>
+  )
+}
+`
+    const js = compileClientJs(source)
+    // Double forEach (outer item, inner child), with the ref invoked
+    // inside the inner one.
+    expect(js).toContain('items.forEach((item, __idx) => {')
+    expect(js).toContain('item.children.forEach((child, __innerIdx) => {')
+    expect(js).toContain('(trackMount)(')
+  })
+
+  test('a static outer loop with a nested .map() reactively updates a signal-derived inner text', () => {
+    const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function StaticNestedSignalCase() {
+  const items = [{ id: 1, children: [{ id: 11 }, { id: 12 }] }]
+  const [count] = createSignal(0)
+  return (
+    <ul>
+      {items.map(item => (
+        <li key={item.id}>
+          {item.children.map(child => (
+            <span key={child.id}>{child.id}:{count()}</span>
+          ))}
+        </li>
+      ))}
+    </ul>
+  )
+}
+`
+    const js = compileClientJs(source)
+    // Pre-fix, this text was frozen at its SSR-baked value — no
+    // `createEffect` at all inside the inner forEach body.
+    expect(js).toMatch(/createEffect\(\(\) => \{ __bfw_\w+\('s\d+', String\(count\(\)\)\) \}\)/)
+  })
+
+  test('a static outer loop with a nested .map() wires a reactive attr on the inner element', () => {
+    const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function StaticNestedAttrCase() {
+  const items = [{ id: 1, children: [{ id: 11 }, { id: 12 }] }]
+  const [sel] = createSignal(11)
+  return (
+    <ul>
+      {items.map(item => (
+        <li key={item.id}>
+          {item.children.map(child => (
+            <span key={child.id} data-active={child.id === sel()}>{child.id}</span>
+          ))}
+        </li>
+      ))}
+    </ul>
+  )
+}
+`
+    const js = compileClientJs(source)
+    expect(js).toContain('data-active')
+    expect(js).toMatch(/createEffect\(\(\) => \{/)
+  })
+})

package/src/__tests__/issue-2856-branch-local-shorthand.test.ts

@@ -0,0 +1,86 @@
+/**
+ * #2856: `replaceBranchLocalRefs` (jsx-to-ir.ts) used to substitute a
+ * branch-local's occurrences via a plain regex token scanner
+ * (`replaceInExprContexts`), which has no notion of AST position. An
+ * object-literal shorthand property (`{ local }`, simultaneously the
+ * key and the value) got its substitution wrapped in parens with the
+ * key silently dropped — `{ (_p.tag) }` — invalid JS that broke the
+ * whole client bundle's parse at runtime with no compile-time
+ * diagnostic.
+ *
+ * The fix routes both call sites through `rewriteScopedValueRefs`
+ * (`prop-rewrite.ts`), the same AST-based, scope-aware walk that
+ * already handled this exact key/value duality for destructured props
+ * (#2828/#2853). These tests pin the general mechanism directly
+ * (`rewriteScopedValueRefs`) — shorthand expansion, and the three
+ * sibling positions a naive scanner conflates with a value reference:
+ * a member-access name, an explicit object-literal key, and a name
+ * shadowed by an inner binding. An end-to-end compiler regression for
+ * the issue's own repro lives in
+ * `rewrite-destructured-props.test.ts` ("branch-local transitive
+ * prop-dep via shorthand reference").
+ */
+import { describe, test, expect } from 'bun:test'
+import { rewriteScopedValueRefs } from '../prop-rewrite.ts'
+
+describe('rewriteScopedValueRefs (#2856)', () => {
+  test('expands an object-literal shorthand property to `name: value`', () => {
+    const out = rewriteScopedValueRefs('{ local }', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBe('{ local: (_p.tag) }')
+  })
+
+  test('does not touch a member-access name that merely shares the branch-local name', () => {
+    const out = rewriteScopedValueRefs('obj.local', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBe('obj.local')
+  })
+
+  test('does not touch an explicit object-literal key', () => {
+    const out = rewriteScopedValueRefs('{ local: 1 }', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBe('{ local: 1 }')
+  })
+
+  test('does not substitute a name shadowed by an inner arrow parameter', () => {
+    const out = rewriteScopedValueRefs('[1, 2, 3].map((local) => local)', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBe('[1, 2, 3].map((local) => local)')
+  })
+
+  test('substitutes a real value reference alongside an unrelated shadowed one', () => {
+    const out = rewriteScopedValueRefs(
+      'local + [1, 2, 3].map((local) => local).join(",")',
+      new Set(['local']),
+      () => '(_p.tag)',
+    )
+    expect(out).toBe('(_p.tag) + [1, 2, 3].map((local) => local).join(",")')
+  })
+
+  test('does not touch a destructuring declaration\'s source key (pullfrog review, #2889)', () => {
+    // `{ local: renamed } = obj` -- `local` here is the SOURCE key of a
+    // renamed destructuring binding, not a value reference. Distinct from
+    // the shorthand case above: a renamed destructuring pattern has BOTH
+    // `propertyName` (the source key) and `name` (the local binding), and
+    // only the latter was excluded pre-fix.
+    const out = rewriteScopedValueRefs(
+      '(el) => { const { local: renamed } = obj; use(renamed) }',
+      new Set(['local']),
+      () => '(_p.tag)',
+    )
+    expect(out).toBe('(el) => { const { local: renamed } = obj; use(renamed) }')
+  })
+
+  test('resolves inside a template-literal interpolation hole, leaving the cooked text alone', () => {
+    const out = rewriteScopedValueRefs('`label:local=${local}`', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBe('`label:local=${(_p.tag)}`')
+  })
+
+  test('returns null for text that does not parse as an expression when allowStatements is not set', () => {
+    const out = rewriteScopedValueRefs('const x = local', new Set(['local']), () => '(_p.tag)')
+    expect(out).toBeNull()
+  })
+
+  test('with allowStatements, resolves a value reference in statement-shaped text', () => {
+    const out = rewriteScopedValueRefs('const x = local', new Set(['local']), () => '(_p.tag)', {
+      allowStatements: true,
+    })
+    expect(out).toBe('const x = (_p.tag)')
+  })
+})

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

@@ -1,4 +1,5 @@
 import { describe, test, expect } from 'bun:test'
+import ts from 'typescript'
 import { compileJSX } from '../index'
 import { HonoAdapter } from '../../../adapter-hono/src/adapter/index'
 
@@ -153,11 +154,15 @@ export function Comp({ tag }: { tag: string }) {
     // 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.)
+    // prop reference, and the shorthand key survives the substitution
+    // (#2856 -- the branch-local substitution used to drop it, emitting
+    // the invalid `{ (_p.tag) }`).
     expect(js).not.toContain('{ (tag) }')
-    expect(js).toContain('{ (_p.tag) }')
+    expect(js).not.toContain('{ (_p.tag) }')
+    expect(js).toContain('{ local: (_p.tag) }')
+    // The emitted client JS must actually parse.
+    const sf = ts.createSourceFile('__test.ts', js, ts.ScriptTarget.Latest, true)
+    const diagnostics = (sf as unknown as { parseDiagnostics?: unknown[] }).parseDiagnostics
+    expect(diagnostics ?? []).toHaveLength(0)
   })
 })

package/src/ir-to-client-js/plan/build-static-array-child-init.ts

@@ -18,7 +18,7 @@
  */
 
 import type { IRLoopChildComponent, MapCallbackPreamble } from '../../types.ts'
-import type { ClientJsContext, NestedLoop, TopLevelLoop } from '../types.ts'
+import type { ClientJsContext, LoopChildReactiveAttr, NestedLoop, TopLevelLoop } from '../types.ts'
 import { quotePropName, varSlotId, attrValueToString, buildLoopChildIndexExpr } from '../utils.ts'
 import { jsxChildrenPropGetterExpr, renderPreamble, irToHtmlTemplate } from '../html-template.ts'
 
@@ -34,7 +34,7 @@ function staticPreludeStatements(preamble: MapCallbackPreamble | undefined): str
       })]
     : []
 }
-import { buildCompSelector } from '../control-flow/shared.ts'
+import { buildCompSelector, buildStaticChildRefBindings } from '../control-flow/shared.ts'
 
 /** The inline prop shape carried on `IRLoopChildComponent.props`. */
 type LoopChildCompProp = IRLoopChildComponent['props'][number]
@@ -66,25 +66,47 @@ export function buildStaticArrayChildInitsPlan(
         if (comp.loopDepth) continue // handled in inner-loop pass
         plans.push(buildOuterNestedPlan(elem, comp))
       }
+    }
+
+    if (!elem.innerLoops) continue
 
-      if (elem.innerLoops) {
-        for (const innerLoop of elem.innerLoops) {
-          const innerComps = elem.nestedComponents.filter(c =>
-            (c.loopDepth ?? 0) === innerLoop.depth && c.innerLoopArray === innerLoop.array,
-          )
-          if (innerComps.length === 0) continue
-          // Component-rooted outer item (#1725): the inner `.map()` lives
-          // inside the child component's JSX children. The element-offset
-          // addressing of `inner-loop-nested` can't reach a fragment-rooted
-          // passthrough's flattened items, so use the document-order zip
-          // shape instead.
-          plans.push(
-            elem.childComponent
-              ? buildComponentRootedInnerLoopPlan(elem, innerLoop, innerComps)
-              : buildInnerLoopNestedPlan(elem, innerLoop, innerComps),
-          )
-        }
+    for (const innerLoop of elem.innerLoops) {
+      const innerComps = (elem.nestedComponents ?? []).filter(c =>
+        (c.loopDepth ?? 0) === innerLoop.depth && c.innerLoopArray === innerLoop.array,
+      )
+
+      if (elem.childComponent) {
+        // Component-rooted outer item (#1725): the inner `.map()` lives
+        // inside the child component's JSX children. The element-offset
+        // addressing of `inner-loop-nested` can't reach a fragment-rooted
+        // passthrough's flattened items, so use the document-order zip
+        // shape instead. (Plain-element bindings on a component-rooted
+        // inner loop aren't addressed by this shape either — out of scope
+        // here, same as this shape's existing filter/sort limitation.)
+        if (innerComps.length === 0) continue
+        plans.push(buildComponentRootedInnerLoopPlan(elem, innerLoop, innerComps))
+        continue
       }
+
+      // Plain-element-rooted outer item: `inner-loop-nested`'s element-offset
+      // addressing also wires up a plain element's own reactive attrs/texts/
+      // refs inside the inner loop (#2798) — previously this whole pass only
+      // ever ran for depth-N CHILD COMPONENTS (gated behind
+      // `elem.nestedComponents.length > 0` with an `innerComps.length === 0`
+      // skip), so a static outer array's nested `.map()` over plain elements
+      // wired up NOTHING: no ref invocation, no reactive text/attr effect,
+      // even though the outer row's OWN bindings at this same depth-0 level
+      // are faithfully wired (`buildStaticLoopPlan`'s `childRefs`/`texts`/
+      // `attrsBySlot`). Scoped to depth 1 — `NestedLoop` has no parent link
+      // to thread a second offset through for depth ≥ 2, and the inner
+      // array expression there reads the depth-1 param, so a flat emission
+      // would `ReferenceError`; deeper nesting stays a known limitation.
+      if (innerLoop.depth !== 1) continue
+      const hasPlainBindings = innerLoop.bindings.refs.length > 0
+        || innerLoop.bindings.reactiveTexts.length > 0
+        || innerLoop.bindings.reactiveAttrs.length > 0
+      if (innerComps.length === 0 && !hasPlainBindings) continue
+      plans.push(buildInnerLoopNestedPlan(elem, innerLoop, innerComps))
     }
   }
 
@@ -147,6 +169,21 @@ function buildInnerLoopNestedPlan(
     propsExpr: buildStaticPropsExpr(comp.props),
   }))
 
+  // Plain-element bindings (#2798) — grouped/passed the same way
+  // `buildStaticLoopPlan` handles the OUTER row's own bindings: `forEach`
+  // binds the param as the raw item value, so texts/attrs stay unwrapped
+  // (no signal-accessor rewrite) and refs go through
+  // `buildStaticChildRefBindings`, not `buildChildRefBindings`.
+  const attrsBySlotMap = new Map<string, LoopChildReactiveAttr[]>()
+  for (const attr of innerLoop.bindings.reactiveAttrs) {
+    let bucket = attrsBySlotMap.get(attr.childSlotId)
+    if (!bucket) {
+      bucket = []
+      attrsBySlotMap.set(attr.childSlotId, bucket)
+    }
+    bucket.push(attr)
+  }
+
   return {
     kind: 'inner-loop-nested',
     containerVar: `_${varSlotId(elem.slotId)}`,
@@ -163,6 +200,9 @@ function buildInnerLoopNestedPlan(
     innerPreludeStatements: staticPreludeStatements(innerLoop.preamble),
     depth: innerLoop.depth,
     comps,
+    attrsBySlot: [...attrsBySlotMap].map(([slotId, attrs]) => [slotId, attrs] as const),
+    texts: innerLoop.bindings.reactiveTexts,
+    refs: buildStaticChildRefBindings(innerLoop.bindings.refs),
   }
 }
 

package/src/ir-to-client-js/plan/static-array-child-init.ts

@@ -7,7 +7,9 @@
  *   - `outer-nested`       — depth 0 の `nestedComponents`。outer forEach で
  *                            `__iterEl.querySelector(...)` 経由で initChild。
  *   - `inner-loop-nested`  — depth > 0 の `nestedComponents`。outer + inner
- *                            forEach の二重ループで initChild。
+ *                            forEach の二重ループで initChild。同じ二重ループで
+ *                            プレーン要素の ref / reactive text / reactive attr
+ *                            も配線する (#2798、depth 1 のみ)。
  *   - `component-rooted-inner-loop`
  *                          — outer の loop item root が **child component**
  *                            (`loop.childComponent`) で、その JSX children に
@@ -24,6 +26,8 @@
  */
 
 import type { PreludeStatements } from '../control-flow/plan/inner-loop.ts'
+import type { LoopChildRefBinding } from '../control-flow/plan/loop.ts'
+import type { LoopChildReactiveAttr, LoopChildReactiveText } from '../types.ts'
 
 /** Pre-built `{ name: value, ... }` props object expression. */
 export type PropsExpr = string
@@ -143,6 +147,20 @@ export interface InnerLoopNestedInitPlan {
   depth: number
   /** Per-component initialisers emitted inside the inner forEach body. */
   comps: readonly InnerLoopComp[]
+  /**
+   * Reactive attrs on plain elements inside this inner loop's body,
+   * grouped by child slot id (#2798 — a static outer array's nested
+   * `.map()` over plain elements used to wire up NOTHING: no refs, no
+   * reactive text/attr effects, since the whole `elem.innerLoops` pass
+   * only ever ran for depth-N CHILD COMPONENTS). Only populated for a
+   * depth-1 inner loop under a plain-element-rooted outer item — see
+   * `buildStaticArrayChildInitsPlan`'s docstring.
+   */
+  attrsBySlot: ReadonlyArray<readonly [string, readonly LoopChildReactiveAttr[]]>
+  /** Reactive text interpolations inside this inner loop's body (#2798). */
+  texts: readonly LoopChildReactiveText[]
+  /** Imperative ref callbacks on elements inside this inner loop's body (#2798). */
+  refs: readonly LoopChildRefBinding[]
 }
 
 /**