@barefootjs/jsx 0.34.0 → 0.35.1

package/src/ir-to-client-js/control-flow/stringify/inner-loop.ts

@@ -1,8 +1,12 @@
 /**
  * Stringify `InnerLoopsPlan` into source lines.
  *
- * Two emission shapes (mode-discriminated, byte-identical to the legacy
- * `emitInnerLoopSetup`):
+ * One emission shape (#2865 — the former second "static forEach,
+ * setup-only" shape for a nested loop whose array didn't reference the
+ * outer item was removed: it answered "does the array mention the outer
+ * item" instead of "is this reactive at all", so it silently froze any
+ * other reactivity — a signal, a memo, a prop, a preamble local — the
+ * inner array or its rows depended on):
  *
  *   reactive — full mapArray:
  *     <indent>// Reactive inner loop: <arraySrc>
@@ -17,23 +21,11 @@
  *     <indent>  per-item conditionals: insert() over __innerEl<uid> (#2706)
  *     <indent>  return __innerEl<uid>
  *     <indent>}) }
- *
- *   static — forEach setup-only:
- *     <indent>// Initialize <arraySrc> loop components and events
- *     <indent>{ const __ic<uid> = <containerExpr>
- *     <indent>if (__ic<uid> && <arrayExpr>) <arrayExpr>.forEach((<param>, __innerIdx<uid>) => {
- *     <indent>  const __innerEl<uid> = __ic<uid>.children[__innerIdx<uid>]
- *     <indent>  if (!__innerEl<uid>) return
- *     <indent>  <preludeStatements*>   // raw preamble (#1064)
- *     <indent>  __innerEl<uid>.setAttribute('<keyAttr>', String(<rawKey>))?
- *     <indent>  emitComponentAndEventSetup(...)
- *     <indent>  recurse on childLevels
- *     <indent>}) }
  */
 
 import { keyAttrName, mapArrayKeyArgs, profileBindingId, varSlotId } from '../../utils.ts'
 import { emitComponentAndEventSetup } from '../shared.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../../emit-reactive.ts'
 import { emitMultiRootTemplateCloneLines, namespaceWrapForTemplate } from './template-parse.ts'
 import { emitLoopChildRefs } from './loop.ts'
 import { claimPlanLiteral, claimWriterVarName, type ClaimSlotSpec } from './claim-plan.ts'
@@ -50,18 +42,13 @@ export function stringifyInnerLoops(
   pc?: string,
 ): void {
   for (const inner of plan) {
-    if (inner.emit.mode === 'reactive') {
-      emitReactive(lines, inner, indent, pc)
-    } else {
-      emitStatic(lines, inner, indent, pc)
-    }
+    emitReactive(lines, inner, indent, pc)
   }
 }
 
 function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc: string | undefined): void {
   const uid = inner.uidSuffix
   const emit = inner.emit
-  if (emit.mode !== 'reactive') return // narrow
 
   lines.push(`${indent}// Reactive inner loop: ${inner.arraySrc}`)
   lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`)
@@ -108,6 +95,8 @@ function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc:
       [...emit.events],
       inner.outerLoopParam,
       inner.outerLoopParamBindings,
+      false,
+      inner.outerLoopIndex,
     )
   }
   if (inner.childLevels.length > 0) {
@@ -132,11 +121,13 @@ function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc:
       lines.push(`${indent}  createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)})`)
     }
   }
+  if (emit.reactiveAttrs.length > 0) lines.push(`${indent}  ${DEDUP_STORE_DECL}`)
+  let attrOrdinal = 0
   for (const attr of emit.reactiveAttrs) {
     const targetVar = `__ta_${attr.slotId.replace(/[^a-zA-Z0-9]/g, '_')}`
     lines.push(`${indent}  { const ${targetVar} = qsa(__innerEl${uid}, '[bf="${attr.slotId}"]')`)
     lines.push(`${indent}  if (${targetVar}) createEffect(() => {`)
-    for (const stmt of emitAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta)) {
+    for (const stmt of emitDedupedAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta, attrOrdinal++)) {
       lines.push(`${indent}    ${stmt}`)
     }
     lines.push(`${indent}  }${profileBindingId(pc, attr.slotId)}) }`)
@@ -146,7 +137,13 @@ function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc:
   // ternary. Mirrors `stringifyBranchInnerLoops`'s identical call for a
   // branch-scoped inner loop's own conditionals.
   if (emit.conditionals.length > 0) {
-    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc)
+    // This inner loop's own preamble (`preludeStatements` above) is not a
+    // single re-runnable string like the outer row's `mapPreambleWrapped`,
+    // so there is nothing correct to thread here — `readsPreamble &&
+    // mapPreambleWrapped`'s guard downstream makes this `undefined` a
+    // no-op, exactly as before this fix (inner-loop preambles are out of
+    // scope — see PR notes on #2596 follow-up).
+    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc, undefined)
   }
   // Imperative ref callbacks fire on every renderItem invocation, which
   // means every mount: SSR hydration, initial CSR creation, and same-key
@@ -163,46 +160,3 @@ function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc:
   // instead of the default `data-key`.
   lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!emit.wrappedKey, inner.keyDepth)}) }`)
 }
-
-function emitStatic(lines: string[], inner: InnerLoopPlan, indent: string, pc: string | undefined): void {
-  const uid = inner.uidSuffix
-  const emit = inner.emit
-  if (emit.mode !== 'static') return
-
-  lines.push(`${indent}// Initialize ${inner.arraySrc} loop components and events`)
-  lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`)
-  // Guard: inner array may be undefined when inside a conditional branch.
-  lines.push(`${indent}if (__ic${uid} && ${inner.arrayExpr}) ${inner.arrayExpr}.forEach((${inner.param}, __innerIdx${uid}) => {`)
-  lines.push(`${indent}  const __innerEl${uid} = __ic${uid}.children[__innerIdx${uid}]`)
-  lines.push(`${indent}  if (!__innerEl${uid}) return`)
-  // Body-entry statements: inner-`.map()` preamble locals (raw, since the
-  // forEach param is the literal item — #1064). Emitted before component
-  // and event setup so their prop getters / handlers resolve the locals.
-  for (const stmt of emit.preludeStatements) {
-    lines.push(`${indent}  ${stmt}`)
-  }
-  if (emit.rawKey) {
-    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${emit.rawKey}))`)
-  }
-  emitComponentAndEventSetup(
-    lines,
-    `${indent}  `,
-    `__innerEl${uid}`,
-    [...emit.components],
-    [...emit.events],
-    inner.outerLoopParam,
-    inner.outerLoopParamBindings,
-  )
-  if (inner.childLevels.length > 0) {
-    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc)
-  }
-  // Imperative ref callbacks for static inner loops — fire once per
-  // forEach iteration (#1244). Static arrays don't reactively re-iterate,
-  // so this is effectively a one-shot per item.
-  emitLoopChildRefs(lines, emit.childRefs, {
-    indent: `${indent}  `,
-    elVar: `__innerEl${uid}`,
-    bodyIsMultiRoot: false,
-  })
-  lines.push(`${indent}}) }`)
-}

package/src/ir-to-client-js/control-flow/stringify/insert.ts

@@ -29,7 +29,7 @@
  */
 
 import { emitRefCall, varSlotId } from '../../utils.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../../emit-reactive.ts'
 import type { InsertPlan, InsertArm, ArmBody, ScopeRef } from '../plan/types.ts'
 import { stringifyBranchLoops } from './branch-loop.ts'
 import { emitListenerLine } from './event-listener.ts'
@@ -163,10 +163,12 @@ function emitArmBody(
     const v = varSlotId(slotId)
     const elVar = `__ra_${v}`
     lines.push(`${indent}{ const ${elVar} = qsa(__branchScope, '[bf="${slotId}"]')`)
+    lines.push(`${indent}${DEDUP_STORE_DECL}`)
     lines.push(`${indent}if (${elVar}) {`)
+    let ordinal = 0
     for (const attr of attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`)
-      for (const stmt of emitAttrUpdate(elVar, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(elVar, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`${indent}    ${stmt}`)
       }
       lines.push(`${indent}  }${bindingBfId(slotId)}))`)

package/src/ir-to-client-js/control-flow/stringify/lazy-row.ts

@@ -60,7 +60,7 @@
  */
 
 import { isBooleanAttr } from '../../../html-constants.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
+import { emitDedupedAttrUpdate, dedupGuard } from '../../emit-reactive.ts'
 import { toHtmlAttrName } from '../../utils.ts'
 import type { SkeletonSlotPaths } from '../../html-template.ts'
 import { claimPlanLiteral, type ClaimSlotSpec } from './claim-plan.ts'
@@ -191,6 +191,11 @@ export function stringifyLazyRowLoop(lines: string[], o: StringifyLazyRowOptions
   // --- createRow ---------------------------------------------------------
   const b1 = `${indent}  `
   const b2 = `${indent}    `
+  // Tells the runtime to also call `applyItem` on a pure reorder (#2859
+  // follow-up) — see `LazyRowPlan.indexDriven`'s docstring. Omitted (not just
+  // `false`) for every loop that never reads the index, byte-stable with
+  // this widening's predecessor.
+  if (lazyRow.readsIndex) lines.push(`${b1}indexDriven: true,`)
   lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`)
   // Always bound, even with no reactive bindings: the non-hoisted clone
   // interpolates the per-row template, which reads the param for at least
@@ -225,6 +230,9 @@ export function stringifyLazyRowLoop(lines: string[], o: StringifyLazyRowOptions
   } else {
     lines.push(`${b1}applyItem: (__e) => {`)
     lines.push(`${b2}const ${paramHead} = () => __e.item`)
+    // The row's current position (#2859 follow-up) — only when some binding
+    // here actually reads it, so every other loop's applyItem is unchanged.
+    if (lazyRow.readsIndex) lines.push(`${b2}const ${o.indexParam} = __e.index`)
     lines.push(`${b2}const __r = __e.refs ?? (__e.refs = [])`)
     lines.push(`${b2}const __l = __e.last ?? (__e.last = [])`)
     // Re-run the preamble only when a binding in THIS body reads a local it
@@ -255,6 +263,8 @@ export function stringifyLazyRowLoop(lines: string[], o: StringifyLazyRowOptions
     for (const g of lazyRow.outerPrimeGetters) lines.push(`${b2}${g}()`)
     lines.push(`${b2}for (const __e of __es) {`)
     lines.push(`${b3}const ${paramHead} = () => __e.item`)
+    // Same as `applyItem` — the row's current position (#2859 follow-up).
+    if (lazyRow.readsIndex) lines.push(`${b3}const ${o.indexParam} = __e.index`)
     lines.push(`${b3}const __r = __e.refs ?? (__e.refs = [])`)
     lines.push(`${b3}const __l = __e.last ?? (__e.last = [])`)
     // Per ENTRY, not once for the batch: the preamble reads the item, so its
@@ -448,11 +458,13 @@ function emitConditional(
   lines.push(`${ind}} }`)
 }
 
-/** `entry.last`-backed dedup test. `in` (not a truthiness check) so a
- *  legitimately `undefined` value still records and still writes once. */
-function dedupGuard(ordinal: number): string {
-  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`
-}
+// `dedupGuard` (the `entry.last`-backed dedup test) and the actual guarded
+// write now live in `emit-reactive.ts` as `emitDedupedAttrUpdate` (#2869) —
+// shared with every eager reactive-attr emission site. This module's only
+// remaining substrate-specific piece is WHERE `__l` comes from: the
+// reconciler's `entry.last` (see the per-mode `applyItem`/`applyOuter`
+// callers below), not a closure-local `const __l = []`, because those are
+// separate invocations with no shared closure of their own to own it.
 
 function emitAttrBinding(
   lines: string[],
@@ -464,21 +476,16 @@ function emitAttrBinding(
   // plain read. An ADOPTED row starts with an EMPTY `refs` array and each
   // binding claims its OWN slot on first use — see `elementAccess`.
   const target = mode === 'create' ? `__r[${a.refIndex}]` : elementAccess(a)
-  lines.push(`${ind}{ const __t = ${target}`)
-  lines.push(`${ind}if (__t) {`)
-  lines.push(`${ind}  const __x = ${a.wrappedExpression}`)
   const guard = mode === 'create'
     ? null
     : mode === 'item'
       ? dedupGuard(a.ordinal)
       : `__seed ? (${seedDiffersExpr('__t', a)}) : (${dedupGuard(a.ordinal)})`
-  const writeIndent = guard ? `${ind}    ` : `${ind}  `
-  if (guard) lines.push(`${ind}  if (${guard}) {`)
-  for (const stmt of emitAttrUpdate('__t', a.attrName, '__x', a.meta)) {
-    lines.push(`${writeIndent}${stmt}`)
+  lines.push(`${ind}{ const __t = ${target}`)
+  lines.push(`${ind}if (__t) {`)
+  for (const stmt of emitDedupedAttrUpdate('__t', a.attrName, a.wrappedExpression, a.meta, a.ordinal, guard)) {
+    lines.push(`${ind}  ${stmt}`)
   }
-  if (guard) lines.push(`${ind}  }`)
-  lines.push(`${ind}  __l[${a.ordinal}] = __x`)
   lines.push(`${ind}} }`)
 }
 

package/src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts

@@ -13,7 +13,7 @@
 
 import { varSlotId, DATA_BF_PH, keyAttrName, mapArrayKeyArgs, profileBindingId } from '../../utils.ts'
 import { emitComponentAndEventSetup } from '../shared.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../../emit-reactive.ts'
 import { namespaceWrapForTemplate } from './template-parse.ts'
 import { emitListenerLine } from './event-listener.ts'
 import { nameForRegistryRef } from '../../component-scope.ts'
@@ -46,15 +46,25 @@ export function stringifyBranchReactiveAttrs(
   lines: string[],
   plan: readonly ReactiveAttrSlot[],
   indent: string,
-  pc?: string,
+  pc: string | undefined,
+  /** The row's preamble re-run statement, when this scope has one (#2596/#2447) — see `conditionGetterExpr`'s docstring for the shared contract. */
+  mapPreambleWrapped: string | undefined,
 ): void {
   for (const slot of plan) {
     const varName = `__ra_${varSlotId(slot.slotId)}`
     lines.push(`${indent}{ const ${varName} = qsa(__branchScope, '[bf="${slot.slotId}"]')`)
+    lines.push(`${indent}${DEDUP_STORE_DECL}`)
     lines.push(`${indent}if (${varName}) {`)
+    let ordinal = 0
     for (const attr of slot.attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`)
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      // One effect per attr, so an attr reading a preamble local needs the
+      // declarations inside ITS OWN effect — same rule, same line, as
+      // `emitAttrSlotsGranular` (reactive-effects.ts, #2447 follow-up).
+      if (attr.readsPreamble && mapPreambleWrapped) {
+        lines.push(`${indent}    ${mapPreambleWrapped}`)
+      }
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`)
       }
       lines.push(`${indent}  }${profileBindingId(pc, slot.slotId)}))`)
@@ -156,6 +166,8 @@ export function stringifyBranchInnerLoops(
         [...inner.legacyEvents],
         inner.outerLoopParam,
         inner.outerLoopParamBindings,
+        false,
+        inner.outerLoopIndex,
       )
     }
     const conditionalTexts = inner.reactiveTexts.filter(t => t.insideConditional)
@@ -177,7 +189,13 @@ export function stringifyBranchInnerLoops(
       }
     }
     if (inner.nestedConditionals.length > 0) {
-      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc)
+      // An inner loop's own conditionals are classified against the INNER
+      // loop's preamble names, not the outer row's — `BranchInnerLoop`
+      // carries no re-runnable preamble string for that scope, so there is
+      // nothing correct to inject here. The `readsPreamble && mapPreambleWrapped`
+      // guard downstream makes this `undefined` a no-op, exactly as before
+      // this fix (inner-loop preambles are out of scope — see PR notes).
+      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc, undefined)
     }
     lines.push(`${indent}  return __bel${uid}`)
     // #2753 Shape B: see the identical comment in `inner-loop.ts` —
@@ -198,33 +216,55 @@ export function stringifyLoopChildConditionals(
   lines: string[],
   conditionals: readonly LoopChildConditionalPlan[],
   indent: string,
-  pc?: string,
+  pc: string | undefined,
+  /** The row's preamble re-run statement, when this scope has one (#2596/#2447). */
+  mapPreambleWrapped: string | undefined,
 ): void {
   for (const cond of conditionals) {
-    stringifyLoopChildConditional(lines, cond, indent, pc)
+    stringifyLoopChildConditional(lines, cond, indent, pc, mapPreambleWrapped)
   }
 }
 
+/**
+ * The `() => cond` getter handed to `insert()`. A condition flagged
+ * `readsPreamble` (#2596) re-runs the row preamble INSIDE the getter —
+ * `insert()` re-invokes this closure on every dependency change to decide
+ * the branch, and a preamble local is a plain per-row `const`, not a signal
+ * `insert()` can see through on its own. ONE implementation for both the
+ * outer (`emitOuterConditional`, reactive-effects.ts) and nested
+ * (`stringifyLoopChildConditional`, here) levels so the two can't drift.
+ */
+export function conditionGetterExpr(
+  wrappedCondition: string,
+  readsPreamble: boolean | undefined,
+  mapPreambleWrapped: string | undefined,
+): string {
+  return readsPreamble && mapPreambleWrapped
+    ? `() => { ${mapPreambleWrapped}; return (${wrappedCondition}) }`
+    : `() => ${wrappedCondition}`
+}
+
 function stringifyLoopChildConditional(
   lines: string[],
   cond: LoopChildConditionalPlan,
   indent: string,
   pc: string | undefined,
+  mapPreambleWrapped: string | undefined,
 ): void {
   const armIndent = `${indent}    `
   // Body-form arrows wire `__bfSlot` captures into the runtime so live
   // `Node` returns from Child-position interpolations are spliced into
   // the parsed fragment instead of being stringified by the surrounding
   // template literal (#1213).
-  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`)
+  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', ${conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped)}, {`)
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`)
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`)
-  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc)
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped)
   lines.push(`${indent}  }`)
   lines.push(`${indent}}, {`)
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`)
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`)
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc)
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped)
   lines.push(`${indent}  }`)
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`)
 }
@@ -242,6 +282,8 @@ export function stringifyLoopChildArm(
   arm: LoopChildArmPlan,
   armIndent: string,
   pc: string | undefined,
+  /** The row's preamble re-run statement, when this scope has one (#2596/#2447) — forwarded to this arm's own reactive attrs and nested conditionals. */
+  mapPreambleWrapped: string | undefined,
 ): void {
   stringifyBranchEventBindings(lines, arm.events, armIndent)
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent)
@@ -257,7 +299,7 @@ export function stringifyLoopChildArm(
   if (!hasDisposables) return
 
   lines.push(`${armIndent}const __disposers = []`)
-  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc)
+  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc, mapPreambleWrapped)
 
   // Nested conditionals: each inner `insert()` is wrapped in its own
   // disposable effect so disposing THIS entry cascades to whatever
@@ -265,7 +307,7 @@ export function stringifyLoopChildArm(
   // conditional's nested-conditional handling in stringify/insert.ts).
   for (const cond of arm.nestedConditionals) {
     lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => {`)
-    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc)
+    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc, mapPreambleWrapped)
     lines.push(`${armIndent}}))`)
   }
 

package/src/ir-to-client-js/control-flow/stringify/loop.ts

@@ -30,7 +30,7 @@
  */
 
 import { emitRefCall, varSlotId, profileBindingId } from '../../utils.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../../emit-reactive.ts'
 import { stringifyReactiveEffects } from './reactive-effects.ts'
 import { emitTemplateCloneInline, emitLoopItemElementSetup, emitHoistedTemplateDecl, hoistedCloneExpr, namespaceWrapForTemplate, multiRootNamespaceWrapForTemplate, wrapHtmlForNamespace } from './template-parse.ts'
 import { buildSkeletonPathPlan, type SkeletonPathPlan } from './skeleton-paths.ts'
@@ -452,13 +452,15 @@ export function stringifyStaticLoop(lines: string[], plan: StaticLoopPlan): void
     lines.push(`      }`)
   }
   lines.push(`      if (__iterEl) {`)
+  if (attrsBySlot.length > 0) lines.push(`        ${DEDUP_STORE_DECL}`)
+  let ordinal = 0
   for (const [slotId, attrs] of attrsBySlot) {
     const varName = `__t_${varSlotId(slotId)}`
     lines.push(`        const ${varName} = qsa(__iterEl, '[bf="${slotId}"]')`)
     lines.push(`        if (${varName}) {`)
     for (const attr of attrs) {
       lines.push(`          createEffect(() => {`)
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`            ${stmt}`)
       }
       lines.push(`          }${profileBindingId(pc, slotId)})`)

package/src/ir-to-client-js/control-flow/stringify/reactive-effects.ts

@@ -32,8 +32,8 @@
  */
 
 import { varSlotId, profileBindingId } from '../../utils.ts'
-import { emitAttrUpdate } from '../../emit-reactive.ts'
-import { stringifyLoopChildArm } from './loop-child-arm.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../../emit-reactive.ts'
+import { stringifyLoopChildArm, conditionGetterExpr } from './loop-child-arm.ts'
 import { claimPlanLiteral, claimWriterVarName, type ClaimSlotSpec } from './claim-plan.ts'
 import type {
   NestedConditionalPlan,
@@ -103,7 +103,11 @@ export interface StringifyReactiveEffectsOptions {
    * The loop callback's pre-return preamble (already wrapped with the loop
    * param accessor), re-run once per row-effect tick — BEFORE any preamble
    * region read — so `preambleRegions`' `valueExpr`s see freshly recomputed
-   * locals. Only meaningful alongside `preambleRegions`.
+   * locals. Also consumed by every OTHER `readsPreamble` site in this row's
+   * scope: row-level attrs (`emitAttrSlotsGranular`/`emitConsolidatedRowEffect`),
+   * outer condition getters (`emitOuterConditional`), and — forwarded
+   * through `stringifyLoopChildArm` (#2596 follow-up) — that row's branch
+   * arms' own reactive attrs and nested condition getters.
    */
   mapPreambleWrapped?: string
 }
@@ -160,7 +164,9 @@ function emitAttrSlotsGranular(
     const varName = `__ra_${varSlotId(slot.slotId)}`
     const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot)
     lines.push(`${indent}{ const ${varName} = ${lookupExpr}`)
+    lines.push(`${indent}${DEDUP_STORE_DECL}`)
     lines.push(`${indent}if (${varName}) {`)
+    let ordinal = 0
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`)
       // Profile mode keeps one effect per attr, so an attr reading a preamble
@@ -171,7 +177,7 @@ function emitAttrSlotsGranular(
       if (attr.readsPreamble && mapPreambleWrapped) {
         lines.push(`${indent}    ${mapPreambleWrapped}`)
       }
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`)
       }
       lines.push(`${indent}  }${bindingBfId(slot.slotId)})`)
@@ -233,11 +239,14 @@ function attrLookupExpr(
  * dispatches per-slot on `kind`), so a row pays for at most one `lazySlots`
  * closure + one claim `Map` instead of one per category.
  *
- * Every attr's write statements are wrapped in their own `{ }` block (not
- * just each slot's) — `emitAttrUpdate`'s 'value'-attr shape emits a bare
- * `const __val = …` with no block of its own, and merging multiple attrs
- * into one function body (previously each had its own arrow-function scope)
- * would let two 'value' attrs in the same row effect collide on `__val`.
+ * Every attr write goes through `emitDedupedAttrUpdate` (#2869): a
+ * self-contained `{ }` block (so two 'value' attrs in the same row effect
+ * can't collide on `emitAttrUpdate`'s bare `const __val`) behind a
+ * previous-value guard on the row's ONE `__l` store, ordinals sequential
+ * across every slot in the row. Without the guard, fusing bindings into one
+ * effect meant a change to ANY binding rewrote ALL of them on every rerun —
+ * `untrack()` on one binding's read couldn't stop a sibling binding's
+ * legitimate change from re-triggering this effect and re-writing it anyway.
  */
 function emitConsolidatedRowEffect(
   lines: string[],
@@ -258,6 +267,11 @@ function emitConsolidatedRowEffect(
     const varName = `__ra_${varSlotId(slot.slotId)}`
     lines.push(`${indent}const ${varName} = ${attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot)}`)
   }
+  // Row-wide dedup store (#2869) — one `__l`, shared by every attr write
+  // below via a sequential ordinal, so a sibling binding's legitimate
+  // rerun of this shared effect can't force an unchanged binding to
+  // rewrite too.
+  if (attrSlots.length > 0) lines.push(`${indent}${DEDUP_STORE_DECL}`)
 
   // 2. ONE claimed-slot writer covering outer texts (kind 'text') and
   //    preamble regions (kind 'markup') — mixed-kind plans are supported by
@@ -293,15 +307,14 @@ function emitConsolidatedRowEffect(
   if (mapPreambleWrapped && (preambleRegions.length > 0 || attrsReadPreamble(attrSlots))) {
     lines.push(`${indent}  ${mapPreambleWrapped}`)
   }
+  let ordinal = 0
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`
     lines.push(`${indent}  if (${varName}) {`)
     for (const attr of slot.attrs) {
-      lines.push(`${indent}    {`)
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
-        lines.push(`${indent}      ${stmt}`)
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
+        lines.push(`${indent}    ${stmt}`)
       }
-      lines.push(`${indent}    }`)
     }
     lines.push(`${indent}  }`)
   }
@@ -354,18 +367,16 @@ function emitOuterConditional(
   // scope here (it's a plain per-row `const`, not a signal `insert()` can see
   // through on its own). Same treatment as `readsPreamble` attrs
   // (`emitAttrUpdate`'s callers) get ahead of their own write.
-  const conditionGetter = cond.readsPreamble && mapPreambleWrapped
-    ? `() => { ${mapPreambleWrapped}; return (${cond.wrappedCondition}) }`
-    : `() => ${cond.wrappedCondition}`
+  const conditionGetter = conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped)
   lines.push(`${indent}insert(${elVar}, '${cond.slotId}', ${conditionGetter}, {`)
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`)
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`)
-  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc)
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped)
   lines.push(`${indent}  }`)
   lines.push(`${indent}}, {`)
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`)
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`)
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc)
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped)
   lines.push(`${indent}  }`)
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`)
 }

package/src/ir-to-client-js/csr-substitute.ts

@@ -486,6 +486,35 @@ export function resolveGetterAliases(
   return aliases
 }
 
+/**
+ * Which names in `signals`/`memos` are eligible ALIAS-HOP TARGETS for
+ * `resolveGetterAliases`'s `isGetter` predicate — a non-module,
+ * non-env-reader signal getter, or a non-module memo name. Env-signal
+ * getters are excluded because they resolve through their own
+ * request-scoped binding (an adapter's `searchParamsFieldRef`-style
+ * lookup or equivalent), never a seeded/`out`-keyed value an alias could
+ * usefully point at.
+ *
+ * Shared by every `resolveGetterAliases` call site (#2813's `ssr-defaults.ts`
+ * seeding and the Go adapter's `rootFieldRef` field-routing) so the
+ * eligibility rule can't silently drift between them — the "one decision,
+ * two implementations" defect class CLAUDE.md calls out (pullfrog review
+ * on #2854).
+ */
+export function collectAliasableGetterNames(
+  signals: readonly SignalInfo[],
+  memos: readonly MemoInfo[],
+): Set<string> {
+  const getterNames = new Set<string>()
+  for (const sig of signals) {
+    if (sig.getter && !sig.isModule && !sig.envReader) getterNames.add(sig.getter)
+  }
+  for (const memo of memos) {
+    if (!memo.isModule) getterNames.add(memo.name)
+  }
+  return getterNames
+}
+
 /**
  * Build the CSR substitution env from the live `ClientJsContext`.
  *