@barefootjs/jsx 0.29.0 → 0.30.0

package/dist/ir-to-client-js/collect-elements.d.ts

@@ -99,32 +99,12 @@ export declare function collectInnerLoops(nodes: IRNode[], siblingOffsets: Map<I
  * so text effects and conditional pushes gate correctly).
  */
 export declare function collectElements(node: IRNode, ctx: ClientJsContext, siblingOffsets: Map<IRLoop, IRNode[]>, insideConditional?: boolean): void;
+export declare function collectLoopChildBindings(children: readonly IRNode[], ctx: ClientJsContext, siblingOffsets: Map<IRLoop, IRNode[]>, loopParam: string, loopParamBindings: readonly import('../types.ts').LoopParamBinding[] | undefined, 
 /**
- * Collect reactive conditionals from loop children.
- * These are conditional nodes with a slotId that have reactive conditions,
- * needing insert() calls for fine-grained conditional switching.
- *
- * Lives in collect-elements.ts (not reactivity.ts) because it composes
- * `collectInnerLoops` and `irToHtmlTemplate` to build per-branch metadata
- * — a branch-summary concern rather than a reactivity-classification one.
- * Placement here eliminates the former lazy-`require()` cycle between
- * reactivity.ts and collect-elements.ts.
- */
-/**
- * Unified per-item bindings collector for a loop body (#1244 §B).
- *
- * Replaces the four pre-#1244 site-local collectors
- * (`collectLoopChildEventsWithNesting` + `collectLoopChildReactiveAttrs`
- * + `collectLoopChildReactiveTexts` + `collectLoopChildConditionals`)
- * with one function that returns the full `LoopChildBindings` struct
- * including refs. Every loop variant (`TopLevelLoop`, `BranchLoop`,
- * `NestedLoop`) goes through this entry point so a new per-item concept
- * is added in one place instead of replicated across three.
- *
- * Sibling offsets are required for `collectLoopChildConditionals` to
- * resolve child slot ids inside nested loops; the rest of the per-item
- * collectors don't read them but pass them through for symmetry.
+ * 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.
  */
-export declare function collectLoopChildBindings(children: readonly IRNode[], ctx: ClientJsContext, siblingOffsets: Map<IRLoop, IRNode[]>, loopParam: string, loopParamBindings: readonly import('../types.ts').LoopParamBinding[] | undefined): LoopChildBindings;
+preambleNames?: ReadonlySet<string>): LoopChildBindings;
 export declare function collectLoopChildConditionals(node: IRNode, ctx: ClientJsContext, siblingOffsets: Map<IRLoop, IRNode[]>, loopParam?: string, loopParamBindings?: readonly import('../types.ts').LoopParamBinding[]): LoopChildConditional[];
 //# sourceMappingURL=collect-elements.d.ts.map

package/dist/ir-to-client-js/collect-elements.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect-elements.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/collect-elements.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAoC,KAAK,MAAM,EAAmC,MAAM,aAAa,CAAA;AACzH,OAAO,KAAK,EAAE,eAAe,EAA+H,iBAAiB,EAA0B,oBAAoB,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAyGvQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA0C7E;AAyBD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,EAAE,wBAIpC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,cAAc,CAAC,EAAE,MAAM,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE,wBAAwB,GACjC,UAAU,EAAE,CAyId;AAqKD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,iBAAiB,UAAQ,GACxB,IAAI,CAmSN;AAuYD;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GAAG,SAAS,GAC/E,iBAAiB,CAenB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,CAAC,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GACpE,oBAAoB,EAAE,CA4DxB"}
+{"version":3,"file":"collect-elements.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/collect-elements.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAoC,KAAK,MAAM,EAAmC,MAAM,aAAa,CAAA;AACzH,OAAO,KAAK,EAAE,eAAe,EAA+H,iBAAiB,EAA0B,oBAAoB,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAyGvQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA0C7E;AAyBD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,EAAE,wBAIpC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,cAAc,CAAC,EAAE,MAAM,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE,wBAAwB,GACjC,UAAU,EAAE,CA2Id;AAqKD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,iBAAiB,UAAQ,GACxB,IAAI,CAqSN;AAicD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GAAG,SAAS;AAChF;;;;GAIG;AACH,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAClC,iBAAiB,CAenB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,CAAC,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GACpE,oBAAoB,EAAE,CA4DxB"}

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

@@ -32,6 +32,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. */
 export interface LazyRowTextBinding {
@@ -45,6 +52,36 @@ 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 {
     /** Distinct attr slot ids, in declaration order — `entry.refs[0..n-1]`. */
@@ -72,8 +109,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 {
     loop: TopLevelLoop | BranchLoop;

package/dist/ir-to-client-js/control-flow/plan/build-lazy-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-lazy-row.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-lazy-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG/D,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC/E,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAA;AAElC,4CAA4C;AAC5C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,yEAAyE;IACzE,iBAAiB,EAAE,MAAM,CAAA;IACzB,IAAI,EAAE,QAAQ,CAAA;IACd,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,iBAAiB,EAAE,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;IAClB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACpC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACpC,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;;OAQG;IACH,aAAa,EAAE,OAAO,CAAA;IACtB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,yDAAyD;IACzD,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,YAAY,GAAG,UAAU,CAAA;IAC/B,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAA;IACnB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,QAAQ,EAAE,OAAO,GAAG,cAAc,CAAA;IAClC,eAAe,EAAE,OAAO,CAAA;IACxB,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,gBAAgB,GAAG,SAAS,CAAA;CACpC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,eAAe,GAAG,IAAI,CAE/E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG;IACrD,IAAI,EAAE,eAAe,GAAG,IAAI,CAAA;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;CAC7B,CAuHA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,gBAAgB,CAyB5E"}
+{"version":3,"file":"build-lazy-row.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-lazy-row.ts"],"names":[],"mappings":"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"}

package/dist/ir-to-client-js/control-flow/plan/build-reactive-effects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,YAAY,EAEZ,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAazD,OAAO,KAAK,EAGV,mBAAmB,EAEpB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;IACvC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;IACvC,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,CAAA;IACzD,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC/C,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,sEAAsE;AACtE,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,wBAAwB,GAC7B,mBAAmB,CA8DrB;AAsCD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,YAAY,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,mBAAmB,CASnH"}
+{"version":3,"file":"build-reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,YAAY,EAEZ,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAazD,OAAO,KAAK,EAGV,mBAAmB,EAEpB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;IACvC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;IACvC,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,CAAA;IACzD,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC/C,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,sEAAsE;AACtE,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,wBAAwB,GAC7B,mBAAmB,CA+DrB;AAsCD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,YAAY,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,mBAAmB,CASnH"}

package/dist/ir-to-client-js/control-flow/plan/lazy-conditional.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Is a row's reactive conditional drivable from the LOOP-level apply bodies? —
+ * `spec/slot-unification.md` §9.5, the "row contains a reactive conditional"
+ * widening.
+ *
+ * ## Why it was refused wholesale
+ *
+ * The eager emission calls `insert(__el, 'sN', () => cond, trueArm, falseArm)`
+ * once per row. `insert` creates **one `createEffect` per call**, plus it probes
+ * both branch templates at runtime to decide element-vs-fragment form, resolves
+ * a search region, and manages per-branch `bindEvents` cleanup. Calling it from
+ * a lazy row would reinstate exactly the per-row reactive resource the lazy row
+ * graph exists to remove — so the gate refused any row with a conditional at
+ * all.
+ *
+ * ## What this accepts, and why that is the whole job
+ *
+ * For the narrow case where **both arms are wiring-free static elements**,
+ * everything `insert` does collapses to one operation: replace the
+ * `[bf-c="sN"]` element with the other arm's markup when the condition flips.
+ * No `bindEvents`, no branch cleanup, no auto-focus, no `__bfSlot` live-node
+ * splicing — those all exist for arms that own something, and these arms own
+ * nothing.
+ *
+ * That case needs no runtime helper. Both arms are compile-time constants, so
+ * each is parsed ONCE per loop into a hoisted `<template>` and cloned per swap,
+ * the same trick the row template already uses. What is left per row is a
+ * boolean, a dedup slot, and a `replaceWith` — which the existing
+ * `applyItem`/`applyOuter` bodies can carry directly.
+ *
+ * ## The four things that must be proven
+ *
+ *  1. **Both arms are wiring-free.** Every `LoopChildBranchSummary` collection
+ *     must be empty. A single reactive text inside an arm means the arm's
+ *     content has to track the item, which needs wiring this shape has no place
+ *     for.
+ *  2. **Both arms are ELEMENT conditionals.** The caller passes each arm through
+ *     `addCondAttrToTemplate` — the same door the eager emission uses — which
+ *     injects `bf-c="<slotId>"` on a single root element and otherwise wraps the
+ *     arm in `<!--bf-cond-start:id-->` markers. So the two forms are told apart
+ *     by reading its output, not by re-deciding here. A FRAGMENT conditional
+ *     spans a sibling range with no single node to replace, which is why
+ *     `insert` carries a second code path for it.
+ *  3. **Both arms' HTML is static.** The arm strings are emitted inside a
+ *     template literal, so an interpolation survives as `${…}`. Anything
+ *     containing one is refused — it would have to be re-evaluated per row,
+ *     defeating the hoist. (A literal `${` in authored TEXT would also refuse
+ *     here; that is the safe direction — a false refusal costs the eager
+ *     fallback, a false accept would ship a frozen arm.)
+ *  4. **The condition does not read the loop INDEX.** `applyItem` and
+ *     `applyOuter` have no index parameter, the same reason
+ *     `ClassifiedLazyBinding.referencesIndex` refuses a binding.
+ *
+ * Everything refused carries a specific reason, which `lazyRowEligibility`
+ * passes through unchanged.
+ */
+import type { LoopChildConditional } from '../../types.ts';
+/** The prepared arm markup the caller hands in, and this module vets. */
+export interface PreparedArms {
+    /**
+     * Loop-param wrapped and passed through `addCondAttrToTemplate`, i.e. exactly
+     * the strings the eager path would emit. Vetting the PREPARED form is the
+     * point: the raw `IRLoop` arm HTML carries no `bf-c` at all, so an
+     * element-vs-fragment decision made on it would be guesswork.
+     */
+    whenTrueHtml: string;
+    whenFalseHtml: string;
+}
+/** A row conditional the loop-level apply bodies can drive. */
+export interface LazyConditionalFacts {
+    slotId: string;
+    /** Condition expression, NOT yet loop-param wrapped (the caller wraps). */
+    condition: string;
+    /** Arm markup, static by construction — hoisted and cloned per swap. */
+    whenTrueHtml: string;
+    whenFalseHtml: string;
+}
+export type LazyConditionalAnalysis = {
+    lazySafe: true;
+    facts: LazyConditionalFacts;
+} | {
+    lazySafe: false;
+    reason: string;
+};
+/**
+ * Decide whether `cond` can be driven from the loop-level apply bodies.
+ *
+ * `indexParam` is the loop's index parameter name as the emitter uses it
+ * (`elem.index || '__idx'`); a condition reading it is refused.
+ */
+export declare function analyzeLazyConditional(cond: LoopChildConditional, indexParam: string, arms: PreparedArms): LazyConditionalAnalysis;
+//# sourceMappingURL=lazy-conditional.d.ts.map

package/dist/ir-to-client-js/control-flow/plan/lazy-conditional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-conditional.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/lazy-conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,KAAK,EAA0B,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAElF,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,+DAA+D;AAC/D,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;IACjB,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,MAAM,uBAAuB,GAC/B;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,oBAAoB,CAAA;CAAE,GAC/C;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAgBvC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,YAAY,GACjB,uBAAuB,CAyCzB"}

package/dist/ir-to-client-js/control-flow/plan/lazy-preamble.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Is a `.map()` callback preamble safe to run inside a LAZY row's apply
+ * bodies? — `spec/slot-unification.md` §9.5, the "row has a map-callback
+ * preamble" widening.
+ *
+ * ## Why the old rule was "any preamble at all"
+ *
+ * The eager emission runs the preamble ONCE per row, inside `renderItem`.
+ * The lazy emission has no per-row body — a row's writes are split across
+ * `createRow` / `applyItem` / `applyOuter`, each a separate function called
+ * at a different time. To let a binding read a preamble-declared local, the
+ * preamble's statements have to be re-executed at the top of every body that
+ * needs them. Two things follow, and both have to be PROVEN, not assumed:
+ *
+ *  1. **Re-execution must be observationally free.** Running the statements
+ *     three times instead of once is only sound if they have no effects and
+ *     allocate nothing whose identity is load-bearing. A preamble declaring a
+ *     signal (`const [x, setX] = createSignal(0)`) would mint a NEW signal on
+ *     every apply — the row would silently lose its state.
+ *  2. **No reactive binding may read a preamble local.** A binding's
+ *     dependency set is its own free identifiers; a preamble local hides
+ *     whatever the preamble read (`const cls = selected() === row.id ? …`),
+ *     so classifying `cls` on its own name would put the binding in
+ *     `applyItem` only and the row would never react to `selected()`.
+ *
+ *     That case is REFUSED rather than modelled, because it is currently
+ *     unreachable and paying for unreachable machinery is how a gate rots: a
+ *     preamble local read in CHILD position becomes a `preambleRegions` entry
+ *     (`IRLoop.preambleRegions`, #2389) which the gate already refuses on its
+ *     own, and one read in ATTRIBUTE position is not classified as reactive at
+ *     all, so it is interpolated into the row template and never becomes a
+ *     `reactiveAttrs` binding. `lazyRowEligibility` therefore refuses any
+ *     binding whose free identifiers touch `declaredNames`, and that refusal
+ *     is what keeps this sound if either of those two facts ever changes.
+ *
+ * ## The proof this module accepts
+ *
+ * Deliberately narrow, and structural — no regex, per the repo rule. A
+ * preamble qualifies only when it is a sequence of `const` declarations whose
+ * initializers cannot do anything:
+ *
+ *  - Every statement is a `const` `VariableStatement`. A `let` can be
+ *    reassigned by a later statement, a `function`/`class` declaration is a
+ *    fresh object per run, and any other statement kind (an `if`, a bare
+ *    call, a `for`) is either an effect or control flow this analysis does
+ *    not model.
+ *  - Every declaration has an initializer, and that initializer contains no
+ *    `new`, tagged template, assignment, `++`/`--`, `await`, `yield`,
+ *    `delete`, or function/arrow/class expression.
+ *  - **Calls are refused with ONE exception: a zero-argument call to a
+ *    component signal or memo getter.** That exception is the whole point —
+ *    `const cls = selected() === row.id ? 'on' : 'off'` is the shape the
+ *    krausest bench writes, and a signal read is pure, deterministic, and
+ *    already the unit this design primes and subscribes to. Every other call
+ *    stays refused: `createSignal` is a call, `arr.push(x)` is a call,
+ *    `Math.random()` is a call whose value would differ between `createRow`
+ *    and `applyItem`, and an ordinary-looking local can hide a reactive
+ *    accessor behind one (`isSelected(row.id)` — see `classifyLazyBinding`'s
+ *    note) which this emitter cannot prime.
+ *
+ *    The signal read is sound in all three bodies because of where they run:
+ *    `createRow` and `applyItem` are wrapped in `untrack()` by `mapArrayLazy`,
+ *    so a read there subscribes nothing, and `applyOuter` IS the loop-level
+ *    effect that is supposed to subscribe. A preamble-declared local therefore
+ *    behaves exactly like a binding expression that read the same signal
+ *    directly.
+ *  - No `jsx` segment. A JSX leaf in the preamble means the row accumulates
+ *    markup, which is `preambleRegions` territory (refused separately).
+ *  - No `builderNames`. Same shape as above, pinned explicitly so the reason
+ *    names it rather than surfacing as a confusing "contains a call".
+ *  - The preamble does not read the loop's INDEX parameter. `applyItem` and
+ *    `applyOuter` have no index to give it — the same reason
+ *    `ClassifiedLazyBinding.referencesIndex` refuses a binding.
+ *
+ * Member access is deliberately NOT banned even though a getter could in
+ * principle run code: a binding expression like `class={row.cls}` is already
+ * re-evaluated on every apply by design, so a call-free preamble is exactly
+ * the same risk class as the emission this feature extends. Banning member
+ * access would reject every useful preamble and buy no real guarantee.
+ *
+ * Everything refused carries a specific reason — `lazyRowEligibility` passes
+ * it straight through, so a unit test naming the shape gets a diagnosable
+ * failure instead of a silent fallback to eager emission.
+ */
+import { type MapCallbackPreamble } from '../../../types.ts';
+/** What the gate and the binding classifier need to know about a preamble. */
+export interface LazyPreambleFacts {
+    /**
+     * Names the preamble declares. A binding naming one of these is reading a
+     * ROW-LOCAL value, not an outer one — and the name SHADOWS any
+     * component-scope signal/const of the same name, which is why
+     * `classifyLazyBinding` substitutes rather than falling through to the
+     * component scope.
+     */
+    declaredNames: ReadonlySet<string>;
+    /**
+     * What the preamble itself reads — its free identifiers, minus the names it
+     * declares. This is the SUBSTITUTION set: a binding that names a preamble
+     * local inherits these as its own dependencies, because that is literally
+     * what the value depends on.
+     *
+     * Returned as raw names, unclassified, on purpose. Deciding which are row
+     * locals, which are primable getters, and which are opaque needs the loop's
+     * `rowLocalNames` / `indexParam` / `LazyRowScopeInfo`, none of which this
+     * module has — and re-deriving that judgement here would be a second copy
+     * of `classifyLazyBinding`'s rules, free to drift from the one the emitter
+     * actually primes against. So the names go back unjudged and run through
+     * the SAME loop a binding's own identifiers do.
+     */
+    freeNames: ReadonlySet<string>;
+}
+export type LazyPreambleAnalysis = {
+    lazySafe: true;
+    facts: LazyPreambleFacts;
+} | {
+    lazySafe: false;
+    reason: string;
+};
+/** No preamble at all — nothing to prove, nothing to substitute. */
+export declare const NO_PREAMBLE: LazyPreambleAnalysis;
+/**
+ * Decide whether `preamble` may be re-executed inside a lazy row's apply
+ * bodies, and if so what it declares and reads.
+ *
+ * `indexParam` is the loop's index parameter name as the emitter uses it
+ * (`elem.index || '__idx'`); a preamble reading it is refused.
+ *
+ * `primableNames` are the component's signal getters and memos — the only
+ * callees a preamble initializer may invoke (see the module docstring). Pass
+ * the same names `LazyRowScopeInfo` carries, so "primable here" and "primable
+ * in `classifyLazyBinding`" cannot drift.
+ */
+export declare function analyzeLazyPreamble(preamble: MapCallbackPreamble | undefined, indexParam: string, primableNames: ReadonlySet<string>): LazyPreambleAnalysis;
+//# sourceMappingURL=lazy-preamble.d.ts.map

package/dist/ir-to-client-js/control-flow/plan/lazy-preamble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-preamble.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/lazy-preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAGH,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAGlF,8EAA8E;AAC9E,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAClC;;;;;;;;;;;;;OAaG;IACH,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAC/B;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAC5C;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC,oEAAoE;AACpE,eAAO,MAAM,WAAW,EAAE,oBAGzB,CAAA;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EACzC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,oBAAoB,CAkEtB"}

package/dist/ir-to-client-js/control-flow/plan/lazy-row-eligibility.d.ts

@@ -16,15 +16,21 @@
  * "widen later" decision, never a correctness compromise:
  *
  *  1. **Shape** (§9.4 "plain loop-row shape"): non-anchored, non-flatMap,
- *     single-root, keyed, conditional-free, ref-free, no nested components
- *     or inner loops.
- *  2. **No preamble.** A `.map()` callback preamble declares row-local
- *     bindings (and can declare row-local signals/memos, which need per-row
- *     reactivity by definition). Proving "declares no signal/memo" is not
- *     cheap here, and every preamble-declared local would land in a
- *     binding's free-identifier set as an unresolvable name anyway — so the
- *     rule is the cheap conservative one: **any** `mapPreambleWrapped` or
- *     any `preambleRegions` entry makes the loop ineligible.
+ *     single-root, keyed, ref-free, no nested components or inner loops. A
+ *     reactive CONDITIONAL is allowed when `analyzeLazyConditional`
+ *     (`lazy-conditional.ts`) proves both arms are wiring-free static elements,
+ *     which reduces the per-row `insert()` effect to a `replaceWith` the apply
+ *     bodies can carry; anything else refuses with that analysis's reason.
+ *  2. **A preamble must be provably re-runnable.** The lazy emission has no
+ *     single per-row body, so a preamble-declared local only exists if the
+ *     preamble's statements are re-executed at the top of each apply body
+ *     that reads one. `analyzeLazyPreamble` (`lazy-preamble.ts`) proves that
+ *     structurally — `const` declarations whose initializers do nothing but
+ *     read the item and zero-arg signal getters — and hands back the declared
+ *     names. The gate consumes its verdict as a pre-computed
+ *     `mapPreambleRefusal` string so this function stays pure data-in/data-out.
+ *     A binding that READS a declared local still refuses (see the per-binding
+ *     gate), and so does any `preambleRegions` entry (§9.5, a separate row).
  *  3. **Every reactive outer dependency must be primable.** `mapArrayLazy`
  *     creates ONE loop-level effect for `applyOuter`; that effect subscribes
  *     only to what its body reads, and its body must read the outer signals
@@ -62,6 +68,7 @@
  *     loop-level effect would make every binding on every row share one
  *     `#binding:<slotId>` id.
  */
+import type { LazyPreambleFacts } from './lazy-preamble.ts';
 /** Facts about one component signal needed by the §9.3(2) source gate. */
 export interface LazyRowSignalFacts {
     /**
@@ -127,6 +134,13 @@ export interface ClassifiedLazyBinding {
     opaqueOuterNames: readonly string[];
     /** References the loop's index parameter — `applyItem`/`applyOuter` have no index. */
     referencesIndex: boolean;
+    /**
+     * Names a preamble-declared local, so every apply body this binding is
+     * emitted into must re-run the preamble first. Tracked per binding rather
+     * than per loop so `applyOuter` does not pay for a preamble only
+     * `applyItem`'s bindings read (`stringify/lazy-row.ts`).
+     */
+    readsPreamble: boolean;
 }
 /** §9.4 shape facts, read off the loop plan / IR by the caller. */
 export interface LazyRowShapeFacts {
@@ -137,12 +151,24 @@ export interface LazyRowShapeFacts {
     bodyIsMultiRoot: boolean;
     /** `LoopCore.key != null` — index-keyed loops are ineligible in v1 (§9.4). */
     hasExplicitKey: boolean;
-    conditionalCount: number;
+    /**
+     * `analyzeLazyConditional`'s refusal reason for the FIRST row conditional it
+     * rejects, or `null` when the row has none or all of them can be driven from
+     * the apply bodies (`lazy-conditional.ts`). A string here is emitted verbatim
+     * as the gate's reason.
+     */
+    conditionalRefusal: string | null;
     childRefCount: number;
     nestedComponentCount: number;
     innerLoopCount: number;
     hasChildComponent: boolean;
-    hasMapPreamble: boolean;
+    /**
+     * `analyzeLazyPreamble`'s refusal reason, or `null` when the row has no
+     * preamble or has one that is provably safe to re-run in the apply bodies
+     * (`lazy-preamble.ts`). A string here is emitted verbatim as the gate's
+     * reason — the analysis, not this function, knows what was wrong.
+     */
+    mapPreambleRefusal: string | null;
     preambleRegionCount: number;
     /** A destructured loop param with no `paramBindings` (snapshot unwrap). */
     hasParamUnwrap: boolean;
@@ -190,6 +216,13 @@ export declare function lazyRowEligibility(args: LazyRowEligibilityArgs): LazyRo
  * subscribe (see module docstring, restriction 3). So the fail-safe direction
  * is preserved (maximally conservative classification) while the emission
  * refuses loudly instead of shipping a dead effect.
+ *
+ * **Preamble locals are flagged, not resolved.** A name the preamble declares
+ * hides whatever the preamble read, so classifying it against the component
+ * scope would name the wrong dependency (and would silently treat a shadowed
+ * signal as the outer one). `readsPreamble` records the fact and
+ * `lazyRowEligibility` refuses the loop — see `lazy-preamble.ts` for why that
+ * case is currently unreachable and why the refusal is still the right shape.
  */
 export declare function classifyLazyBinding(args: {
     kind: 'attr' | 'text';
@@ -199,5 +232,7 @@ export declare function classifyLazyBinding(args: {
     rowLocalNames: ReadonlySet<string>;
     indexParam: string;
     scope: LazyRowScopeInfo;
+    /** Proven-safe preamble facts, or the empty set pair when there is none. */
+    preamble?: LazyPreambleFacts;
 }): ClassifiedLazyBinding;
 //# sourceMappingURL=lazy-row-eligibility.d.ts.map

package/dist/ir-to-client-js/control-flow/plan/lazy-row-eligibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy-row-eligibility.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lazy-row-eligibility.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts"],"names":[],"mappings":"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"}

package/dist/ir-to-client-js/control-flow/plan/reactive-effects.d.ts

@@ -17,6 +17,13 @@ export interface ReactiveAttrEffect {
     wrappedExpression: string;
     /** Pre-copied attr metadata used by emitAttrUpdate. */
     meta: AttrMeta;
+    /**
+     * `wrappedExpression` reads a `.map()` callback preamble local (#2447
+     * follow-up), so the emitter must run the preamble ahead of this write —
+     * the local is not otherwise in scope in the update body, and its value
+     * is what makes the attribute reactive at all.
+     */
+    readsPreamble?: boolean;
 }
 /** Reactive attrs grouped by child slot (one qsa lookup per slot). */
 export interface ReactiveAttrSlot {

package/dist/ir-to-client-js/control-flow/plan/reactive-effects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAA;IACzB,uDAAuD;IACvD,IAAI,EAAE,QAAQ,CAAA;CACf;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;CACrC;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAA;IACd,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAA;IACxB,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,CAAA;IAC5B,wDAAwD;IACxD,qBAAqB,EAAE,MAAM,CAAA;IAC7B,WAAW,EAAE,gBAAgB,CAAA;IAC7B,YAAY,EAAE,gBAAgB,CAAA;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAA;IACtC,gFAAgF;IAChF,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACzC,YAAY,EAAE,SAAS,qBAAqB,EAAE,CAAA;IAC9C;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B"}
+{"version":3,"file":"reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAA;IACzB,uDAAuD;IACvD,IAAI,EAAE,QAAQ,CAAA;IACd;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;CACrC;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAA;IACd,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAA;IACxB,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,CAAA;IAC5B,wDAAwD;IACxD,qBAAqB,EAAE,MAAM,CAAA;IAC7B,WAAW,EAAE,gBAAgB,CAAA;IAC7B,YAAY,EAAE,gBAAgB,CAAA;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAA;IACtC,gFAAgF;IAChF,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACzC,YAAY,EAAE,SAAS,qBAAqB,EAAE,CAAA;IAC9C;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B"}

package/dist/ir-to-client-js/control-flow/stringify/lazy-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy-row.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/lazy-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAKH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAQ/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAsB,MAAM,2BAA2B,CAAA;AAExG,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,yEAAyE;IACzE,cAAc,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,aAAa,CAAC,EAAE,iBAAiB,CAAA;IACjC,OAAO,EAAE,eAAe,CAAA;CACzB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAuKtF;AAiGD;0EAC0E;AAC1E,iBAAS,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3C;AAqFD;;;;;;GAMG;AACH,iBAAS,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAsBtE;AAED,kDAAkD;AAClD,eAAO,MAAM,kBAAkB;;;CAAkC,CAAA"}
+{"version":3,"file":"lazy-row.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/lazy-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAKH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAQ/D,OAAO,KAAK,EACV,kBAAkB,EAElB,eAAe,EAEhB,MAAM,2BAA2B,CAAA;AAElC,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,yEAAyE;IACzE,cAAc,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,aAAa,CAAC,EAAE,iBAAiB,CAAA;IACjC,OAAO,EAAE,eAAe,CAAA;CACzB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAmLtF;AA8KD;0EAC0E;AAC1E,iBAAS,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3C;AAyFD;;;;;;GAMG;AACH,iBAAS,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAsBtE;AAED,kDAAkD;AAClD,eAAO,MAAM,kBAAkB;;;CAAkC,CAAA"}

package/dist/ir-to-client-js/csr-substitute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csr-substitute.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/csr-substitute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;IAC3B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC3C,4EAA4E;IAC5E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAmB7D;AAmMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGtF;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAaxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAUjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAkBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,MAAM,CAsBR"}
+{"version":3,"file":"csr-substitute.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/csr-substitute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;IAC3B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC3C,4EAA4E;IAC5E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAmB7D;AAmMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGtF;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAaxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAUjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAkBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,MAAM,CA2BR"}

package/dist/ir-to-client-js/html-template.d.ts

@@ -135,7 +135,7 @@ export declare function flatMapCallbackHasKeyedLeaf(cb: Pick<FlatMapCallback, 's
 export declare function renderFlatMapProjectionClientBody(inner: Extract<IRNode, {
     type: 'loop';
 }>, restSpreadNames?: Set<string>): string;
-export declare function irToHtmlTemplate(node: IRNode, restSpreadNames?: Set<string>, loopDepth?: number, loopParams?: ReadonlyArray<string | LoopParamSpec>, branchSlotsVar?: string, insideLoop?: boolean, inHoistedChildren?: boolean): string;
+export declare function irToHtmlTemplate(node: IRNode, restSpreadNames?: Set<string>, loopDepth?: number, loopParams?: ReadonlyArray<string | LoopParamSpec>, branchSlotsVar?: string, inHoistedChildren?: boolean): string;
 /**
  * Slots a top-level (`mapArray`-driven) loop body proves safe to hoist into a
  * shared, once-per-loop template (perf: avoid per-row `document.createElement
@@ -284,7 +284,6 @@ export interface TemplateOptions {
      * `compute-inlinability` (#1277).
      */
     csrEnv?: CsrEnv;
-    insideLoop?: boolean;
     loopDepth?: number;
     /**
      * Names bound by the ENCLOSING loops' callback params (item / index /
@@ -364,7 +363,7 @@ export declare function canGenerateStaticTemplate(node: IRNode, propNames: Set<s
  * @param inlinableConstants - Map of constant names to their resolved CSR values
  * @param ctx - ClientJsContext supplying signals/memos for `csrSubstitute`
  */
-export declare function generateCsrTemplate(node: IRNode, inlinableConstants: Map<string, string> | undefined, ctx: ClientJsContext, insideLoop?: boolean, restSpreadNames?: Set<string>, propsObjectName?: string | null, unsafeLocalNames?: Set<string>, deferredChildSlots?: ReadonlySet<string>): string;
+export declare function generateCsrTemplate(node: IRNode, inlinableConstants: Map<string, string> | undefined, ctx: ClientJsContext, restSpreadNames?: Set<string>, propsObjectName?: string | null, unsafeLocalNames?: Set<string>, deferredChildSlots?: ReadonlySet<string>): string;
 /**
  * Walk the component IR and collect the slot ids of DIRECT child
  * components whose render must be deferred to init because at least one

package/dist/ir-to-client-js/html-template.d.ts.map

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

package/dist/ir-to-client-js/plan/declaration-emit.d.ts

@@ -25,6 +25,12 @@ export interface SignalEmitPlan {
     getter: string;
     /** Setter identifier — `null` for read-only signals. */
     setter: string | null;
+    /**
+     * Source used the getter-elided form (`const [, setX] = ...`). `getter`
+     * holds the synthesized internal name (see `SignalInfo.getterElided`);
+     * stringify reproduces the source's hole instead of emitting it.
+     */
+    getterElided?: boolean;
     /**
      * Fully-resolved initial value expression. Prop rewrites
      * (`<propsName>.X` → `_p.X`) and `?? <default>` insertions for controlled