@barefootjs/jsx 0.28.1 → 0.30.0

package/src/analyzer.ts

@@ -1201,10 +1201,21 @@ function collectSignal(node: ts.VariableDeclaration, ctx: AnalyzerContext): void
   const callExpr = node.initializer as ts.CallExpression
 
   const elements = pattern.elements
+  // Getter-elided form: `const [, setActive] = createSignal(0)`. The first
+  // element is a hole (ts.OmittedExpression), not a BindingElement.
+  // Rejecting it here used to drop the whole declaration from the emitted
+  // init while the setter stayed referenced by handlers — a guaranteed
+  // ReferenceError (adapter-tests scope-gate, #2468 sweep). Accept it,
+  // synthesize an internal getter name for the IR (never referenced by any
+  // expression, so substitution/SSR consumers see an unused entry), and
+  // mark `getterElided` so emit reproduces the source's `[, setter]` shape.
+  const getterElided = elements.length === 2 && ts.isOmittedExpression(elements[0])
   if (
     elements.length < 1 || elements.length > 2 ||
-    !ts.isBindingElement(elements[0]) ||
-    !ts.isIdentifier(elements[0].name)
+    (!getterElided && (
+      !ts.isBindingElement(elements[0]) ||
+      !ts.isIdentifier(elements[0].name)
+    ))
   ) {
     return
   }
@@ -1216,10 +1227,11 @@ function collectSignal(node: ts.VariableDeclaration, ctx: AnalyzerContext): void
     return
   }
 
-  const getter = elements[0].name.text
   const setter = elements.length === 2 && ts.isBindingElement(elements[1]) && ts.isIdentifier(elements[1].name)
     ? elements[1].name.text
     : null
+  if (getterElided && !setter) return
+  const getter = getterElided ? `__bfGet_${setter}` : (elements[0] as ts.BindingElement & { name: ts.Identifier }).name.text
   const initialValue = callExpr.arguments[0] ? ctx.getJS(callExpr.arguments[0]) : ''
   const typedInitialValue = callExpr.arguments[0] ? callExpr.arguments[0].getText(ctx.sourceFile) : undefined
 
@@ -1257,6 +1269,7 @@ function collectSignal(node: ts.VariableDeclaration, ctx: AnalyzerContext): void
   ctx.signals.push({
     getter,
     setter,
+    getterElided: getterElided || undefined,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : undefined,
     templateInitialValue,
@@ -1577,9 +1590,26 @@ function collectMemo(node: ts.VariableDeclaration, ctx: AnalyzerContext): void {
   const parsedBlockComplete =
     parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : undefined
 
+  // Destructured-arg components only — the memo twin of the signal
+  // `templateInitialValue` rewrite (#2265) a few hundred lines up: a memo
+  // body referencing a bare destructured prop (`createMemo(() => value *
+  // 10)` with `{ value }: { value: number }`) is inlined into the CSR
+  // `template:` arrow by `buildSignalMemoEnv`, and that arrow runs at
+  // module scope — it is not a closure over `initXxx`'s `const value =
+  // _p.value` extraction, so the bare ref must become `_p.value`
+  // (adapter-tests scope-gate, #2468 sweep).
+  let templateComputation: string | undefined
+  if (!ctx.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx.propsParams.map(p => p.name))
+    if (propNames.size > 0) {
+      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames)
+    }
+  }
+
   ctx.memos.push({
     name,
     computation,
+    templateComputation,
     parsedBlock,
     parsedBlockComplete,
     typedComputation: typedComputation !== computation ? typedComputation : undefined,

package/src/index.ts

@@ -90,6 +90,7 @@ export { rewriteImportsForTemplate } from './adapters/template-imports.ts'
 export { emitParsedExpr, groupBinaryOperand, isStringTypedOperand, isStringConcatBinary } from './adapters/parsed-expr-emitter.ts'
 export type { ParsedExprEmitter, HigherOrderMethod, ArrayMethod, SortMethod, LiteralType } from './adapters/parsed-expr-emitter.ts'
 export { collectLoopBoundNames } from './adapters/loop-bound-names.ts'
+export { derivesScopeFromSlot } from './adapters/child-scope.ts'
 export { evaluateSignalInit, tryEvaluateSignalInit, type SignalInitEvalResult } from './signal-init-eval.ts'
 export { evaluateStaticLiteral, isFullyStaticLiteral, resolveStaticLoopSource } from './static-literal.ts'
 export { importsSearchParams, searchParamsLocalNames, envSignalLocalNames, envSignalReaderFor, ENV_SIGNAL_READERS, queryHrefLocalNames, formatDateLocalNames, matchSearchParamsMethodCall } from './adapters/env-signal.ts'

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

@@ -328,10 +328,12 @@ export function collectInnerLoops(
         //     `NestedLoop` because event delegation handles them through
         //     the parent's bindings instead.
         const bindings: LoopChildBindings = emptyLoopChildBindings()
+        // Hoisted: one Set per loop, not one per child (Copilot review).
+        const innerPreambleNames = preambleNamesOf(n)
         if (ctx) {
           for (const child of n.children) {
             bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings))
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings))
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, false, innerPreambleNames))
             bindings.refs.push(...collectLoopChildRefs(child))
           }
         }
@@ -669,7 +671,7 @@ export function collectElements(
       const childHandlers: string[] = []
       const bindings = projectionInner
         ? emptyLoopChildBindings()
-        : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings)
+        : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l))
       if (!projectionInner) {
         for (const child of l.children) {
           childHandlers.push(...collectEventHandlersFromIR(child))
@@ -708,10 +710,12 @@ export function collectElements(
         // Loop-param refs use the raw destructured binding (no loopParams
         // passed), matching the plain-element path's `staticItemTemplate`.
         if (l.isStaticArray && l.children[0]) {
-          // `insideLoop=true` so the component-emit drops the parent's slot
-          // suffix — each iteration owns a distinct scope identified by
-          // `data-key`, mirroring the SSR template's renderChild emit.
-          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, undefined, undefined, /* insideLoop */ true)
+          // `l.children[0]` is the loop's row-root component — already
+          // tagged `loopItemRoot` in the IR, so `derivesScopeFromSlot`
+          // drops the parent's slot suffix automatically. Each iteration
+          // owns a distinct scope identified by `data-key`, mirroring the
+          // SSR template's renderChild emit.
+          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, undefined, undefined)
         }
       } else if (l.children[0] && !projectionInner) {
         // Pass loopParams so expressions are wrapped at generation time,
@@ -728,8 +732,8 @@ export function collectElements(
         // accessor wrap so the CSR materialize fallback (#1247) can clone
         // items inside the forEach body without rewriting the template.
         if (l.isStaticArray) {
-          // Plain-element body: leave `insideLoop=false` so any nested
-          // component nodes keep their parent-slot context in the
+          // Plain-element body: nested component nodes are never tagged
+          // `loopItemRoot`, so they keep their parent-slot context in the
           // per-iteration renderChild call. Per #1249, the
           // `outer-nested` static-array-child-init plan addresses
           // children by the (bf-h, bf-m) pair against the enclosing
@@ -1139,7 +1143,7 @@ function collectBranchLoops(
       // which caused reactive reads inside simple loop bodies to silently
       // no-op for existing items.
       const branchBindings = ctx && !projectionInner
-        ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings)
+        ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n))
         : emptyLoopChildBindings()
 
       loops.push({
@@ -1296,12 +1300,49 @@ function collectBranchConditionals(
  * resolve child slot ids inside nested loops; the rest of the per-item
  * collectors don't read them but pass them through for symmetry.
  */
+/**
+ * The names a loop's `.map()` callback preamble declares, or `undefined` when
+ * there are none to consider — the input to the attribute classifier's
+ * preamble-local check (#2447 follow-up). `undefined` rather than an empty set
+ * so the classifier's fast path stays a single `!== undefined` for the
+ * overwhelmingly common preamble-free loop.
+ *
+ * A STATIC-ARRAY loop returns `undefined` even when it has a preamble, and
+ * this is load-bearing rather than an optimisation. Its items are emitted
+ * through `static-array-child-init` — a `forEach` over the SSR-rendered
+ * children, with no per-row body and therefore no preamble in scope. Wiring an
+ * attribute there would emit `setAttribute('class', active ? … : …)` against a
+ * free variable: a ReferenceError at init that takes the whole component's
+ * hydration with it, including any nested child. (Caught exactly that way —
+ * the gallery nav shells are static arrays whose rows read
+ * `const active = item.key === currentRoute`, and the badge components mounted
+ * inside them stopped appearing.)
+ *
+ * Nothing is lost by declining: a static array's items are rendered once at
+ * SSR and never recreated from a signal, so there is no same-key update for a
+ * patch to be missing from. The same reasoning gates `markPreambleAttrSlots`
+ * and `preambleRegions` in Phase 1, and the two gates must agree — a slot
+ * granted without wiring, or wiring without a slot, is a silent hole either
+ * way.
+ */
+function preambleNamesOf(loop: IRLoop): ReadonlySet<string> | undefined {
+  if (loop.isStaticArray) return undefined
+  const declared = loop.preamble?.declaredNames
+  return declared && declared.length > 0 ? new Set(declared) : undefined
+}
+
 export function collectLoopChildBindings(
   children: readonly IRNode[],
   ctx: ClientJsContext,
   siblingOffsets: Map<IRLoop, IRNode[]>,
   loopParam: string,
   loopParamBindings: readonly import('../types.ts').LoopParamBinding[] | undefined,
+  /**
+   * Names the loop's `.map()` callback preamble declares, so an attribute
+   * reading one is classified reactive (#2447 follow-up) — see
+   * `collectLoopChildReactiveAttrs`. Omitted for a loop with no preamble.
+   */
+  preambleNames?: ReadonlySet<string>,
 ): LoopChildBindings {
   const bindings = emptyLoopChildBindings()
   for (const child of children) {
@@ -1311,7 +1352,7 @@ export function collectLoopChildBindings(
     // `collectLoopChildConditionals`, which gives each its own insert() +
     // arm-scoped attrs/texts (`LoopChildBranchSummary.reactiveAttrs` /
     // `.reactiveTexts`) — descending into them here too would double-bind.
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true))
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true, preambleNames))
     bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings, true))
     bindings.refs.push(...collectLoopChildRefs(child))
     bindings.conditionals.push(...collectLoopChildConditionals(child, ctx, siblingOffsets, loopParam, loopParamBindings))

package/src/ir-to-client-js/control-flow/plan/build-branch-loop.ts

@@ -58,7 +58,7 @@ export function buildBranchLoopPlan(
   const mapPreambleWrapped = loop.preamble
     ? renderPreamble(loop.preamble, {
         transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined, true),
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined),
       })
     : ''
   const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings)

package/src/ir-to-client-js/control-flow/plan/build-composite-loop.ts

@@ -48,7 +48,7 @@ export function buildTopLevelCompositePlan(elem: TopLevelLoop, profileComponentN
     mapPreambleWrapped: elem.preamble
       ? renderPreamble(elem.preamble, {
           transformJs: wrap,
-          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true),
+          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined),
         })
       : '',
     template: elem.template,
@@ -108,7 +108,7 @@ export function buildBranchCompositePlan(loop: BranchLoop, cv: string, profileCo
     mapPreambleWrapped: loop.preamble
       ? renderPreamble(loop.preamble, {
           transformJs: wrap,
-          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined, true),
+          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined),
         })
       : '',
     template: loop.template,

package/src/ir-to-client-js/control-flow/plan/build-event-delegation.ts

@@ -44,7 +44,7 @@ export function buildDynamicLoopDelegationPlan(
       // which throws since `t` is a plain object in this scope.
       mapPreamble: elem.preamble
         ? renderPreamble(elem.preamble, {
-            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true),
+            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined),
           })
         : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? [],
@@ -76,7 +76,7 @@ export function buildBranchLoopDelegationPlan(
       // loopParams spec — leaf refs must stay in plain-object form here.
       mapPreamble: loop.preamble
         ? renderPreamble(loop.preamble, {
-            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true),
+            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined),
           })
         : null,
       mapPreambleDeclaredNames: loop.preamble?.declaredNames ?? [],
@@ -109,7 +109,7 @@ export function buildStaticArrayDelegationPlan(
       // loopParams spec — leaf refs must stay in plain-object form here.
       mapPreamble: elem.preamble
         ? renderPreamble(elem.preamble, {
-            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true),
+            renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined),
           })
         : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? [],

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

@@ -243,7 +243,7 @@ function buildReactiveEmit(
       : [{ param: inner.param, bindings: inner.paramBindings }]
     preludeStatements.push(renderPreamble(inner.preamble, {
       transformJs: (t) => wrapInner(wrapOuter(t)),
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, leafLoopParams, undefined, true),
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, leafLoopParams, undefined),
     }))
   }
 
@@ -286,7 +286,7 @@ function buildStaticEmit(inner: NestedLoop, level: DepthLevel, uidSuffix: string
   // of the js segments above).
   if (inner.preamble) {
     preludeStatements.push(renderPreamble(inner.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true),
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined),
     }))
   }
   return {

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

@@ -20,8 +20,11 @@
 import { freeIdentifiers, parseExpression } from '../../../expression-parser.ts'
 import { pickAttrMeta, type AttrMeta } from '../../../types.ts'
 import { extractFreeIdentifiersFromText } from '../../csr-substitute.ts'
+import { addCondAttrToTemplate } from '../../html-template.ts'
 import { wrapLoopParamAsAccessor, PROPS_PARAM } from '../../utils.ts'
 import type { BranchLoop, ClientJsContext, TopLevelLoop } from '../../types.ts'
+import { analyzeLazyConditional, type LazyConditionalFacts } from './lazy-conditional.ts'
+import { analyzeLazyPreamble } from './lazy-preamble.ts'
 import {
   classifyLazyBinding,
   lazyRowEligibility,
@@ -44,6 +47,13 @@ export interface LazyRowAttrBinding {
   ordinal: number
   readsItem: boolean
   readsOuter: boolean
+  /**
+   * Reads a `.map()` preamble local, so every apply body this binding is
+   * emitted into must re-run the preamble first (#2447 follow-up). Per
+   * binding, not per loop, so `applyOuter` does not pay for a preamble only
+   * `applyItem`'s bindings read.
+   */
+  readsPreamble: boolean
 }
 
 /** One reactive text (content slot) of a lazy row. */
@@ -58,6 +68,37 @@ export interface LazyRowTextBinding {
    * (`LazyRowPlanData.textNeedsRead`).
    */
   readsOuter: boolean
+  /**
+   * Reads a `.map()` preamble local, so every apply body this binding is
+   * emitted into must re-run the preamble first (#2447 follow-up).
+   */
+  readsPreamble: boolean
+}
+
+/** One row conditional driven from the loop-level apply bodies (§9.5). */
+export interface LazyRowConditionalBinding {
+  slotId: string
+  /** Already wrapped via `wrapLoopParamAsAccessor` — reads `<param>()`. */
+  wrappedCondition: string
+  whenTrueHtml: string
+  whenFalseHtml: string
+  /**
+   * Index into `entry.refs` holding the `[bf-c]` element. Always claimed ON
+   * DEMAND — `createRow` never seeds it, because the row it just cloned already
+   * rendered the correct arm and has no swap to perform.
+   */
+  refIndex: number
+  /** Index into `entry.last` holding this conditional's dedup boolean. */
+  ordinal: number
+  readsItem: boolean
+  readsOuter: boolean
+  /**
+   * Reads a `.map()` preamble local, so every apply body this binding is
+   * emitted into must re-run the preamble first (#2447 follow-up). Per
+   * binding, not per loop, so `applyOuter` does not pay for a preamble only
+   * `applyItem`'s bindings read.
+   */
+  readsPreamble: boolean
 }
 
 export interface LazyRowPlanData {
@@ -86,8 +127,35 @@ export interface LazyRowPlanData {
    * nothing per row).
    */
   outerPrimeGetters: readonly string[]
-  /** True when at least one binding is outer-involving. */
-  hasOuter: boolean
+  /**
+   * The row's `.map()` callback preamble as already-wrapped JS statements
+   * (`mapPreambleWrapped`), or `''` when the row has none — proven safe to run
+   * by `analyzeLazyPreamble` (§9.5 widening).
+   *
+   * `createRow` always runs it, and specifically before the clone: the
+   * non-hoisted per-row template can interpolate values the preamble declares.
+   *
+   * `applyItem` / `applyOuter` run it only when a binding they own reads a
+   * declared local (`itemNeedsPreamble` / `outerNeedsPreamble`) — which is
+   * possible as of the #2447 follow-up, where an attribute reading one became
+   * a reactive binding instead of frozen template text. Re-running is sound
+   * because `analyzeLazyPreamble` proved the statements are `const`
+   * declarations whose initializers only read the item and zero-arg signal
+   * getters, and the binding's DEPENDENCIES are the preamble's own free
+   * identifiers (substituted in `classifyLazyBinding`), so `applyOuter`
+   * primes what the preamble reads rather than the opaque local name.
+   */
+  preambleStatements: string
+  /** `applyItem` has a binding that reads a preamble local (#2447 follow-up). */
+  itemNeedsPreamble: boolean
+  /** `applyOuter` has one. Separate from the above so neither body pays for the other's. */
+  outerNeedsPreamble: boolean
+  /**
+   * Row conditionals driven from the apply bodies (§9.5, `lazy-conditional.ts`).
+   * Empty for most loops. Each arm is a static element, so the emitter hoists
+   * both parsed once per loop and clones on a flip.
+   */
+  conditionals: readonly LazyRowConditionalBinding[]
 }
 
 export interface BuildLazyRowArgs {
@@ -126,6 +194,28 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
   const rowLocalNames = new Set<string>([loop.param])
   for (const b of loop.paramBindings ?? []) rowLocalNames.add(b.name)
 
+  // §9.5 preamble widening: prove the preamble is safe to re-run in the apply
+  // bodies BEFORE classifying, because a binding that reads a declared local
+  // inherits the preamble's dependencies rather than its own literal names.
+  const primableNames = new Set<string>([...scope.signals.keys(), ...scope.memos])
+  const preambleAnalysis = analyzeLazyPreamble(loop.preamble, args.indexParam, primableNames)
+
+  // §9.5 conditional widening: a row conditional whose arms are wiring-free
+  // static elements is driven from the apply bodies instead of a per-row
+  // `insert()` effect. The FIRST refusal wins, so the gate names one shape.
+  const rawConditionals = loop.bindings.conditionals ?? []
+  const condFacts: LazyConditionalFacts[] = []
+  let conditionalRefusal: string | null = null
+  for (const cond of rawConditionals) {
+    const verdict = analyzeLazyConditional(cond, args.indexParam, {
+      whenTrueHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
+      whenFalseHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
+    })
+    if (!verdict.lazySafe) { conditionalRefusal = verdict.reason; break }
+    condFacts.push(verdict.facts)
+  }
+  const preambleFacts = preambleAnalysis.lazySafe ? preambleAnalysis.facts : undefined
+
   // --- classify every binding -------------------------------------------
   const classified: ClassifiedLazyBinding[] = []
   const attrClass = new Map<number, ClassifiedLazyBinding>()
@@ -137,6 +227,7 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
       rowLocalNames,
       indexParam: args.indexParam,
       scope,
+      preamble: preambleFacts,
     })
     attrClass.set(i, c)
     classified.push(c)
@@ -150,11 +241,30 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
       rowLocalNames,
       indexParam: args.indexParam,
       scope,
+      preamble: preambleFacts,
     })
     textClass.set(i, c)
     classified.push(c)
   })
 
+  const condClass = new Map<number, ClassifiedLazyBinding>()
+  condFacts.forEach((c, i) => {
+    // Classified like any other binding: a condition reading an outer signal
+    // must land in `applyOuter` AND get that signal onto the prime list, or the
+    // loop-level effect would never subscribe to it.
+    const k = classifyLazyBinding({
+      kind: 'attr',
+      slotId: c.slotId,
+      free: rawConditionals[i].conditionFreeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args.indexParam,
+      scope,
+      preamble: preambleFacts,
+    })
+    condClass.set(i, k)
+    classified.push(k)
+  })
+
   // --- §9.4 gate ---------------------------------------------------------
   const shape: LazyRowShapeFacts = {
     callSite: args.callSite,
@@ -162,12 +272,12 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
     anchored: args.anchored,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     hasExplicitKey: loop.key != null,
-    conditionalCount: loop.bindings.conditionals?.length ?? 0,
+    conditionalRefusal,
     childRefCount: loop.bindings.refs?.length ?? 0,
     nestedComponentCount: loop.nestedComponents?.length ?? 0,
     innerLoopCount: loop.innerLoops?.length ?? 0,
     hasChildComponent: 'childComponent' in loop && loop.childComponent != null,
-    hasMapPreamble: args.mapPreambleWrapped.length > 0,
+    mapPreambleRefusal: preambleAnalysis.lazySafe ? null : preambleAnalysis.reason,
     preambleRegionCount: args.preambleRegionCount,
     hasParamUnwrap: args.paramUnwrap.length > 0,
   }
@@ -198,6 +308,7 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
       ordinal: ordinal++,
       readsItem: c.readsItem,
       readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble,
     }
   })
   const texts: LazyRowTextBinding[] = loop.bindings.reactiveTexts.map((text, i) => {
@@ -212,6 +323,7 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
       // a list keeps exactly the classifier's answer.
       readsItem: c.readsItem || !c.readsOuter,
       readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble,
     }
   })
 
@@ -222,6 +334,29 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
     }
   }
 
+  // Conditional refs live PAST the door, and are claimed on demand — the row
+  // `createRow` just cloned already rendered the correct arm, so there is
+  // nothing for it to seed or swap (see `LazyRowConditionalBinding.refIndex`).
+  const condRefBase = attrSlotIds.length + (texts.length > 0 ? 1 : 0)
+  const conditionals: LazyRowConditionalBinding[] = condFacts.map((c, i) => {
+    const klass = condClass.get(i)!
+    return {
+      slotId: c.slotId,
+      wrappedCondition: wrap(c.condition),
+      whenTrueHtml: c.whenTrueHtml,
+      whenFalseHtml: c.whenFalseHtml,
+      refIndex: condRefBase + i,
+      ordinal: ordinal++,
+      // A condition reading neither the item nor a reactive outer name still
+      // has to be applied somewhere; `applyItem` is the harmless choice (the
+      // dedup makes a repeat a no-op), matching how a text that classified as
+      // neither is handled above.
+      readsItem: klass.readsItem || !klass.readsOuter,
+      readsOuter: klass.readsOuter,
+      readsPreamble: klass.readsPreamble,
+    }
+  })
+
   return {
     plan: {
       attrSlotIds,
@@ -231,7 +366,14 @@ export function decideLazyRow(args: BuildLazyRowArgs): {
       textNeedsRead: texts.some(t => t.readsOuter),
       lastCount: ordinal,
       outerPrimeGetters,
-      hasOuter: attrs.some(a => a.readsOuter) || texts.some(t => t.readsOuter),
+      preambleStatements: args.mapPreambleWrapped,
+      // Which apply bodies must re-run the preamble — computed from the FINAL
+      // binding lists, not the raw classification, so a text/conditional that
+      // classified as neither item- nor outer-driven (and was therefore forced
+      // into `applyItem` above) is counted in the body it actually lands in.
+      itemNeedsPreamble: [...attrs, ...texts, ...conditionals].some(b => b.readsItem && b.readsPreamble),
+      outerNeedsPreamble: [...attrs, ...texts, ...conditionals].some(b => b.readsOuter && b.readsPreamble),
+      conditionals,
     },
     decision,
   }

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

@@ -144,7 +144,7 @@ export function buildPlainLoopPlan(
   const mapPreambleWrapped = elem.preamble
     ? renderPreamble(elem.preamble, {
         transformJs: wrap,
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true),
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined),
       })
     : ''
   const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings)
@@ -269,7 +269,7 @@ function buildStaticLoopMaterialize(
     itemTemplate: elem.staticItemTemplate,
     mapPreamble: elem.preamble
       ? renderPreamble(elem.preamble, {
-          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true),
+          renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined),
         })
       : '',
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,

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

@@ -82,6 +82,7 @@ export function buildReactiveEffectsPlan(
         attrName: attr.attrName,
         wrappedExpression: wrap(attr.expression),
         meta: pickAttrMeta(attr),
+        ...(attr.readsPreamble && { readsPreamble: true }),
       })),
     })
   }