@barefootjs/jsx 0.26.4 → 0.28.0

package/dist/ir-to-client-js/client-only-elision.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Slot unification Step B (`spec/slot-unification.md` §3(b), §5 "Step B —
+ * marker elision"): decide, EXACTLY ONCE and BEFORE either `adapter.generate`
+ * (SSR) or `generateClientJs` (CSR) run, which `/* @client *\/` text slots
+ * can drop their `<!--bf:sN-->…<!--/-->` marker pair entirely from both
+ * outputs. Every consumer (all nine SSR adapters' `renderExpression`, and
+ * the CSR emitters in `html-template.ts`) reads the single
+ * `IRExpression.markerless` flag this pass writes — nobody re-derives the
+ * decision, per CLAUDE.md's "Never add compiler options/hooks for
+ * tool-specific output rewriting" spirit: one door in, everyone reads it.
+ *
+ * Scope — deliberately the NARROWEST slice of §3(b)'s elision rule that is
+ * fully sound today, not the general case:
+ *
+ *   Only `expr.clientOnly && expr.slotId` expressions OUTSIDE any loop or
+ *   conditional branch (i.e. reachable from the component's own render tree
+ *   by walking only `element`/`text`/`expression`/`fragment` nodes).
+ *
+ * Why THIS slice and not ordinary reactive text slots (loop rows,
+ * conditional branches): every other kind of slot's SSR-rendered width is
+ * DATA-DEPENDENT — an ordinary `{item.name}` may render empty or non-empty
+ * per request, so a LATER sibling's absolute child-index path would only be
+ * valid for the specific width THIS request happened to produce, not for
+ * every request the compiled function ever serves. `/* @client *\/`
+ * expressions are the one case free of that problem: SSR can never evaluate
+ * client-only JS (the whole point of the escape valve), so its rendered
+ * width is deterministically ZERO on every request, for every adapter, with
+ * no data dependence at all. That determinism is what makes computing a
+ * real, reusable, hydration-safe path sound here without also solving the
+ * general "does an earlier sibling's width vary by request" problem.
+ *
+ * Path safety within that scope — the part that generalizes A3's
+ * `computeSkeletonSlotPaths` (`html-template.ts`) rather than reinventing
+ * it: paths are root-relative child-index chains, exactly like that
+ * function's, walked in document order with the SAME "once we hit something
+ * whose contributed width isn't a compile-time constant, every remaining
+ * sibling AND everything nested inside it loses eligibility" rule (nested
+ * content reached only through an uncertain-index sibling would resolve an
+ * absolute path through that uncertain index — silently wrong, not loud, so
+ * it must never be attempted). Concretely, walking a children list left to
+ * right:
+ *   - a static `element` always contributes exactly one node — recurse into
+ *     its own children as an independent, freshly-indexed scope (its own
+ *     internal accounting can't leak out, and nothing external can poison
+ *     it either, since the element itself is a fixed anchor regardless of
+ *     what's inside it);
+ *   - static `text` contributes a node per HTML-parser text-run-merging
+ *     rules (adjacent text/expression children collapse into ONE Text
+ *     node — mirrors `computeSkeletonSlotPaths`'s `pendingText` tracking);
+ *   - a `clientOnly` expression with a slotId is the one ELIGIBLE case,
+ *     PROVIDED it is not itself part of a merged text run (rule (i) — the
+ *     `/* @client *\/` slot must not be immediately adjacent, once markers
+ *     are gone, to loose text or another expression, or the HTML parser
+ *     would merge them into one Text node with no way to tell which
+ *     content is which). Once one is elided, this level (and everything
+ *     nested inside any later sibling) is marked ineligible for the
+ *     remainder of the walk at this level — see the "freeze" note below;
+ *   - any other `expression` (a real reactive/static text or markup slot),
+ *     any `conditional`/`loop`/`component`/`async`/`provider`/
+ *     `if-statement`/`slot` node, is data-dependent or opaque width and
+ *     FREEZES the rest of this children list (see below) — this is
+ *     strictly conservative: it also means a `/* @client *\/` expression
+ *     is never eligible once any of these appears earlier at the same
+ *     level, even though `/* @client *\/`'s own width is always zero,
+ *     because SIBLINGS reached only via nested recursion past that point
+ *     would otherwise resolve an absolute path through the frozen node's
+ *     uncertain contributed width;
+ *   - the same hazard-tag / force-close-group / void-element / `<tr>`
+ *     foster-parenting guards `computeSkeletonSlotPaths` uses (imported,
+ *     not re-derived) abort the ENTIRE walk (a global bail, exactly like
+ *     that function's `state.bailed`) — a parser hazard means every index
+ *     computed anywhere in this tree is suspect, not just the ones near
+ *     the hazard, so "don't guess" means don't guess about the blast
+ *     radius either.
+ *
+ * "Freeze" (the one simplification versus a maximally-precise per-branch
+ * eligibility tracker): once ANY `/* @client *\/` slot at a given level is
+ * elided — OR once anything data-dependent/opaque is seen at that level —
+ * that level's remaining siblings (and anything nested only through them)
+ * stop being assigned real paths for the rest of THIS walk, even though a
+ * maximally precise analysis could sometimes still find one. This caps
+ * elision at (at most) one `/* @client *\/` slot per static subtree —
+ * conservative by design, matching the elision rule's own framing, and it
+ * guarantees two elided slots can never end up needing an insertion whose
+ * reference node depends on the other's still-unresolved width. Freezing is
+ * PER CHILDREN-LIST (an element's own children start a fresh, unfrozen
+ * scope) — global-bail is reserved for hazard tags alone.
+ *
+ * Deferred (loudly, not silently): ordinary reactive text slots in loop
+ * rows / conditional branches keep their markers — see above for why
+ * widening this to data-dependent-width content needs a materially
+ * different (and per-adapter-verified) safety argument that this PR does
+ * not attempt.
+ */
+import type { IRNode } from '../types.ts';
+/**
+ * Entry point: mutates `root`'s `expression` nodes in place, setting
+ * `markerless`/`elidedPath` on every eligible `/* @client *\/` slot found.
+ * Safe to call on any component's render tree; a tree with none simply
+ * mutates nothing.
+ */
+export declare function decideClientOnlyElision(root: IRNode): void;
+//# sourceMappingURL=client-only-elision.d.ts.map

package/dist/ir-to-client-js/client-only-elision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-only-elision.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/client-only-elision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,aAAa,CAAA;AAmBvD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE1D"}

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,CA+RN;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,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"}

package/dist/ir-to-client-js/control-flow/plan/branch-loop.d.ts

@@ -17,6 +17,7 @@
 import type { CompositeLoopPlan, LoopChildRefBinding, PreambleRegionPlan } from './loop.ts';
 import type { EventDelegationPlan } from './event-delegation.ts';
 import type { ReactiveEffectsPlan } from './reactive-effects.ts';
+import type { LazyRowPlanData } from './build-lazy-row.ts';
 export interface BranchPlainLoopPlan {
     /**
      * flatMap descriptor mode — see `PlainLoopVariant.flatMapLeafItem`
@@ -87,6 +88,11 @@ export interface BranchPlainLoopPlan {
      * renderItem layout, mirroring the top-level plain plan.
      */
     preambleRegions: readonly PreambleRegionPlan[];
+    /**
+     * Lazy row graph plan (`spec/slot-unification.md` §9, L3) — see
+     * `PlainLoopVariant.lazyRow`. Undefined ⇒ today's eager emission.
+     */
+    lazyRow?: LazyRowPlanData;
 }
 export interface BranchCompositeLoopPlan {
     kind: 'composite';

package/dist/ir-to-client-js/control-flow/plan/branch-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,sEAAsE;IACtE,eAAe,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC9C;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;IACpB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAA;IACjB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAA;IACjB,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;;OAQG;IACH,kBAAkB,EAAE,MAAM,CAAA;IAC1B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,eAAe,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC3C,+DAA+D;IAC/D,eAAe,EAAE,mBAAmB,CAAA;IACpC;;;;OAIG;IACH,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACzC;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAC/C;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,WAAW,CAAA;IACjB,4DAA4D;IAC5D,SAAS,EAAE,iBAAiB,CAAA;IAC5B,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAA;IACvB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,uBAAuB,CAAA"}
+{"version":3,"file":"branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,sEAAsE;IACtE,eAAe,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC9C;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;IACpB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAA;IACjB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAA;IACjB,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;;OAQG;IACH,kBAAkB,EAAE,MAAM,CAAA;IAC1B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,eAAe,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC3C,+DAA+D;IAC/D,eAAe,EAAE,mBAAmB,CAAA;IACpC;;;;OAIG;IACH,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACzC;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC9C;;;OAGG;IACH,OAAO,CAAC,EAAE,eAAe,CAAA;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,WAAW,CAAA;IACjB,4DAA4D;IAC5D,SAAS,EAAE,iBAAiB,CAAA;IAC5B,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAA;IACvB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,uBAAuB,CAAA"}

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

@@ -10,6 +10,7 @@
  *     event-delegation plan.
  */
 import type { BranchLoop } from '../../types.ts';
+import type { LazyRowScopeInfo } from './lazy-row-eligibility.ts';
 import type { BranchLoopPlan } from './branch-loop.ts';
-export declare function buildBranchLoopPlan(loop: BranchLoop, profileComponentName?: string): BranchLoopPlan;
+export declare function buildBranchLoopPlan(loop: BranchLoop, profileComponentName?: string, lazyScope?: LazyRowScopeInfo): BranchLoopPlan;
 //# sourceMappingURL=build-branch-loop.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build-branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAOhD,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,cAAc,CAgEnG"}
+{"version":3,"file":"build-branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAMhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAGjE,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,oBAAoB,CAAC,EAAE,MAAM,EAC7B,SAAS,CAAC,EAAE,gBAAgB,GAC3B,cAAc,CAiFhB"}

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

@@ -8,12 +8,19 @@
  * data-to-text mapping.
  */
 import type { ConditionalElement } from '../../types.ts';
+import type { LazyRowScopeInfo } from './lazy-row-eligibility.ts';
 import type { InsertPlan, ScopeRef } from './types.ts';
 export interface BuildInsertOptions {
     scope: ScopeRef;
     eventNameMode: 'dom' | 'raw';
     /** Owning component name in profile mode (#1690, SR3) — else undefined. */
     profileComponentName?: string;
+    /**
+     * Component-scope name facts for the lazy row graph gate
+     * (`spec/slot-unification.md` §9.4). Threaded down to branch-scoped plain
+     * loops; omitted → those loops keep today's eager emission.
+     */
+    lazyScope?: LazyRowScopeInfo;
 }
 export declare function buildInsertPlan(elem: ConditionalElement, options: BuildInsertOptions): InsertPlan;
 //# sourceMappingURL=build-insert.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build-insert.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-insert.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,gBAAgB,CAAA;AAGvB,OAAO,KAAK,EACV,UAAU,EAGV,QAAQ,EACT,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,QAAQ,CAAA;IACf,aAAa,EAAE,KAAK,GAAG,KAAK,CAAA;IAC5B,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,kBAAkB,GAC1B,UAAU,CAaZ"}
+{"version":3,"file":"build-insert.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-insert.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,gBAAgB,CAAA;AAGvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,KAAK,EACV,UAAU,EAGV,QAAQ,EACT,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,QAAQ,CAAA;IACf,aAAa,EAAE,KAAK,GAAG,KAAK,CAAA;IAC5B,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;OAIG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAC7B;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,kBAAkB,GAC1B,UAAU,CAaZ"}

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

@@ -0,0 +1,107 @@
+/**
+ * Build the compiler-side `LazyRowPlan` payload (`spec/slot-unification.md`
+ * §9, L3) for one plain loop row — or `null` when the row is ineligible and
+ * must keep today's eager `mapArray` emission.
+ *
+ * Everything decided here is BUILD-TIME data: per-binding item/outer
+ * classification (`classifyLazyBinding`), ref-array and dedup-slot layout,
+ * and the outer-signal prime list. The stringifier
+ * (`stringify/lazy-row.ts`) is a deterministic walk over this plan — it
+ * makes no classification decision of its own.
+ *
+ * Free identifiers are never obtained by regex (repo rule). Texts carry
+ * `LoopChildReactiveText.freeIdentifiers` from the analyzer; attrs have no
+ * such field, so their expression is run through `parseExpression` +
+ * `freeIdentifiers` (`expression-parser.ts`) — both of which fail SAFE, the
+ * latter returning `null` on an `unsupported` node, which
+ * `classifyLazyBinding` turns into "reads both, and opaque".
+ */
+import { type AttrMeta } from '../../../types.ts';
+import type { BranchLoop, ClientJsContext, TopLevelLoop } from '../../types.ts';
+import { type LazyRowEligibility, type LazyRowScopeInfo } from './lazy-row-eligibility.ts';
+/** One reactive attribute of a lazy row. */
+export interface LazyRowAttrBinding {
+    slotId: string;
+    attrName: string;
+    /** Already wrapped via `wrapLoopParamAsAccessor` — reads `<param>()`. */
+    wrappedExpression: string;
+    meta: AttrMeta;
+    /** Index into `entry.refs` holding this slot's element. */
+    refIndex: number;
+    /** Index into `entry.last` holding this binding's dedup value. */
+    ordinal: number;
+    readsItem: boolean;
+    readsOuter: boolean;
+}
+/** One reactive text (content slot) of a lazy row. */
+export interface LazyRowTextBinding {
+    slotId: string;
+    wrappedExpression: string;
+    ordinal: number;
+    readsItem: boolean;
+    /**
+     * Reads at least one reactive outer name — emitted into `applyOuter` with
+     * §9.3(1) read-compare-write seeding, which needs the RW claim door
+     * (`LazyRowPlanData.textNeedsRead`).
+     */
+    readsOuter: boolean;
+}
+export interface LazyRowPlanData {
+    /** Distinct attr slot ids, in declaration order — `entry.refs[0..n-1]`. */
+    attrSlotIds: readonly string[];
+    attrs: readonly LazyRowAttrBinding[];
+    texts: readonly LazyRowTextBinding[];
+    /** Index into `entry.refs` holding the claimed-slot door; -1 when no texts. */
+    writerIndex: number;
+    /**
+     * PER-LOOP door selection (§9.3(1) content seeding): true when at least
+     * one text binding is outer-involving and therefore needs `read(id)` to
+     * seed by comparison. The emitter then claims through `lazyClaimSlots`
+     * (the `{ write, read }` door) and every text write becomes
+     * `__r[w].write(...)`; false keeps the single-closure `lazySlots` writer
+     * and the bare `__r[w](...)` call form. One decision for the whole loop —
+     * the door is a per-ROW allocation, so it must not be chosen per binding.
+     */
+    textNeedsRead: boolean;
+    /** Total `entry.last` slots. */
+    lastCount: number;
+    /**
+     * Signal / memo getters read at the top of `applyOuter` so the ONE
+     * loop-level effect subscribes even while the entry list is empty. Empty
+     * ⇒ no `applyOuter` is emitted at all (and hydration does literally
+     * nothing per row).
+     */
+    outerPrimeGetters: readonly string[];
+    /** True when at least one binding is outer-involving. */
+    hasOuter: boolean;
+}
+export interface BuildLazyRowArgs {
+    loop: TopLevelLoop | BranchLoop;
+    /** Fully-chained array expression as emitted (`buildChainedArrayExpr`). */
+    arrayExpr: string;
+    indexParam: string;
+    /** `destructureLoopParam(...).unwrap` — non-empty ⇒ ineligible. */
+    paramUnwrap: string;
+    mapPreambleWrapped: string;
+    preambleRegionCount: number;
+    callSite: 'plain' | 'branch-plain';
+    flatMapLeafItem: boolean;
+    anchored: boolean;
+    scope: LazyRowScopeInfo | undefined;
+}
+/**
+ * Returns the lazy row plan when eligible, otherwise `null` plus the
+ * decision (exposed for tests / diagnostics via {@link decideLazyRow}).
+ */
+export declare function buildLazyRowPlan(args: BuildLazyRowArgs): LazyRowPlanData | null;
+export declare function decideLazyRow(args: BuildLazyRowArgs): {
+    plan: LazyRowPlanData | null;
+    decision: LazyRowEligibility;
+};
+/**
+ * Project a `ClientJsContext` down to the name facts the §9.4 gate resolves
+ * against. Built once per component and threaded into every loop plan
+ * builder, so the gate never reaches back into the whole context.
+ */
+export declare function buildLazyRowScopeInfo(ctx: ClientJsContext): LazyRowScopeInfo;
+//# sourceMappingURL=build-lazy-row.d.ts.map

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

@@ -0,0 +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"}

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

@@ -19,6 +19,7 @@
  * `TopLevelLoop`, and is reused by the branch-loop wrapper plan.
  */
 import type { TopLevelLoop } from '../../types.ts';
+import type { LazyRowScopeInfo } from './lazy-row-eligibility.ts';
 import type { LoopPlan, PlainLoopPlan, StaticLoopPlan } from './types.ts';
 /** Inputs only the static-array variant consumes. */
 export interface BuildLoopPlanOptions {
@@ -26,6 +27,13 @@ export interface BuildLoopPlanOptions {
     unsafeLocalNames: Set<string>;
     /** Owning component name when compiling in profile mode (#1690) — else undefined. */
     profileComponentName?: string;
+    /**
+     * Component-scope name facts for the lazy row graph gate
+     * (`spec/slot-unification.md` §9.4, `buildLazyRowScopeInfo`). Omitted →
+     * no loop is lazy-eligible, i.e. today's emission everywhere. Optional so
+     * hand-built plan fixtures keep type-checking.
+     */
+    lazyScope?: LazyRowScopeInfo;
 }
 /**
  * The single public builder. Selects the variant via the decision tree
@@ -33,7 +41,7 @@ export interface BuildLoopPlanOptions {
  */
 export declare function buildLoopPlan(elem: TopLevelLoop, opts: BuildLoopPlanOptions): LoopPlan;
 /** @internal — prefer `buildLoopPlan`. Exported for the branch-loop wrapper only. */
-export declare function buildPlainLoopPlan(elem: TopLevelLoop, profileComponentName?: string): PlainLoopPlan;
+export declare function buildPlainLoopPlan(elem: TopLevelLoop, profileComponentName?: string, lazyScope?: LazyRowScopeInfo): PlainLoopPlan;
 /** @internal — prefer `buildLoopPlan`. */
 export declare function buildStaticLoopPlan(elem: TopLevelLoop, unsafeLocalNames: Set<string>, profileComponentName?: string): StaticLoopPlan;
 //# sourceMappingURL=build-loop.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,gBAAgB,CAAA;AAmBvB,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,cAAc,EACf,MAAM,YAAY,CAAA;AAEnB,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACnC,8FAA8F;IAC9F,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,oBAAoB,GAAG,QAAQ,CAsBtF;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,aAAa,CA6EnG;AAED,0CAA0C;AAC1C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,cAAc,CAmCpI"}
+{"version":3,"file":"build-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/plan/build-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,gBAAgB,CAAA;AAiBvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAIjE,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,cAAc,EACf,MAAM,YAAY,CAAA;AAEnB,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACnC,8FAA8F;IAC9F,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAC7B;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,oBAAoB,GAAG,QAAQ,CAsBtF;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,oBAAoB,CAAC,EAAE,MAAM,EAC7B,SAAS,CAAC,EAAE,gBAAgB,GAC3B,aAAa,CAgGf;AAED,0CAA0C;AAC1C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,cAAc,CAmCpI"}

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

@@ -0,0 +1,203 @@
+/**
+ * Lazy row graph eligibility — `spec/slot-unification.md` §9.4 (L3).
+ *
+ * ONE explicit decision function (`lazyRowEligibility`) answering a single
+ * question: may this plain loop row be emitted through `mapArrayLazy`
+ * (a compiler-emitted `LazyRowPlan`, no per-row reactive resources) instead
+ * of today's A3b-consolidated eager `mapArray` emission?
+ *
+ * Sound-or-loud (§9.3): the answer is always either `{ eligible: true }` or
+ * `{ eligible: false, reason }`. There is no silent third path — an
+ * ineligible loop keeps byte-for-byte today's emission, and `reason` is a
+ * human-readable string so a regression is diagnosable from a unit test
+ * rather than by diffing generated JS.
+ *
+ * The gate is deliberately conservative. Every restriction below is a
+ * "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.
+ *  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
+ *     even when the entry list is momentarily EMPTY (otherwise the effect
+ *     never subscribes and the loop goes permanently dead). The emitter
+ *     primes those reads with `getter()` statements, which is only possible
+ *     for names it can prove are zero-arg component signal / memo getters.
+ *     Any other name that could change reactively — a prop accessor (props
+ *     may be defined as getters over the parent's signals), or a name the
+ *     compiler cannot classify at all — is `opaque` and makes the loop
+ *     ineligible. Imports and component-local functions are opaque TOO
+ *     (`const isSelected = createSelector(selected)` is an ordinary local
+ *     whose CALL is the reactive read), so they refuse the loop as well —
+ *     the `inert` set names them only so the refusal can say which one.
+ *     Genuinely ignorable are the names that cannot carry a reactive read
+ *     at all: literal-derived local / module constants and pure globals.
+ *  4. **Outer-involving TEXT bindings are ACCEPTED** (§9.5, lifted).
+ *     §9.3(1) requires read-compare-write seeding on `applyOuter`'s first
+ *     run: compute the value, READ the current DOM, write only on
+ *     difference. For an attribute that read is `getAttribute` / a DOM
+ *     property on the held element ref. For a content slot the read door is
+ *     `lazyClaimSlots`' `read(id)` (`claim-slots.ts`), the read-capable twin
+ *     of `lazySlots` over the SAME claim. The emitter picks the door per
+ *     LOOP — a loop with no outer-involving text keeps the single-closure
+ *     writer — so this widening costs nothing for loops that do not use it
+ *     (see `refParts` in `stringify/lazy-row.ts`).
+ *  5. **Loop-source hydration consistency** (§9.3(2)): item-driven bindings
+ *     are never evaluated at hydration, so the SSR rows and the first client
+ *     `items()` read are TRUSTED to agree. That trust is only sound when
+ *     both derive from the same data — props (identical by construction via
+ *     the `bf-p` protocol), literals, and derivations thereof. Any name in
+ *     the loop source that reaches an import, an environment read, or
+ *     anything the compiler cannot resolve → ineligible.
+ *  6. **Profile mode is never lazy** (§9.4, same policy as A3b): a merged
+ *     loop-level effect would make every binding on every row share one
+ *     `#binding:<slotId>` id.
+ */
+/** Facts about one component signal needed by the §9.3(2) source gate. */
+export interface LazyRowSignalFacts {
+    /**
+     * Free identifiers of the signal's initializer, derived from its
+     * structured `SignalInfo.parsed` tree. `null` when `parsed` was absent or
+     * the tree contained an `unsupported` node — "unprovable", which the gate
+     * treats as a hard stop rather than an assumption.
+     */
+    initializerFreeIdentifiers: ReadonlySet<string> | null;
+}
+/** Component-scope facts the gate resolves names against. */
+export interface LazyRowScopeInfo {
+    /** Signal getter name → initializer facts. */
+    signals: ReadonlyMap<string, LazyRowSignalFacts>;
+    /** Memo getter names — reactive and primable via `name()`. */
+    memos: ReadonlySet<string>;
+    /** Props emit name (`_p`), the source props object name, and every destructured prop param. */
+    props: ReadonlySet<string>;
+    /**
+     * Constant name → free identifiers of its value (`ConstantInfo.freeIdentifiers`).
+     * An entry with an EMPTY set is literal-derived. Absent free-id data is
+     * modelled as `null` → unprovable for the source gate (but still inert for
+     * the binding gate — a `const` never changes reactively).
+     */
+    constants: ReadonlyMap<string, ReadonlySet<string> | null>;
+    /**
+     * Import local names and component-local function names. Used ONLY by the
+     * §9.3(2) source gate (to name the failure precisely); binding
+     * classification treats them as OPAQUE, not inert — see
+     * {@link classifyLazyBinding}.
+     */
+    inert: ReadonlySet<string>;
+    /** Profile mode (#1690) — never lazy. */
+    profile: boolean;
+}
+/**
+ * Sentinel `opaqueOuterNames` entry for "free-identifier analysis produced
+ * nothing". Distinct from a real opaque NAME: a name means the identifier
+ * set is known and only its primability is not, which the re-subscribe seam
+ * handles; this means the set itself is unknown, which nothing can handle.
+ */
+export declare const UNKNOWN_IDENTIFIERS = "<unknown>";
+/** One reactive binding of the row, already classified at build time. */
+export interface ClassifiedLazyBinding {
+    kind: 'attr' | 'text';
+    slotId: string;
+    /** Reads the loop param / a destructured param binding. */
+    readsItem: boolean;
+    /** Reads at least one reactive outer name (or is `opaque`). */
+    readsOuter: boolean;
+    /**
+     * Reactive outer names this binding depends on — signal / memo getters the
+     * emitter primes at the top of `applyOuter` so the loop-level effect
+     * subscribes even with zero rows.
+     */
+    reactiveOuterNames: readonly string[];
+    /**
+     * Outer names that are neither primable (signal/memo) nor provably inert
+     * — including the FAIL-SAFE case where free identifiers were unavailable
+     * (then `readsItem`/`readsOuter` are both forced true and this carries the
+     * `'<unknown>'` sentinel). Non-empty ⇒ ineligible.
+     */
+    opaqueOuterNames: readonly string[];
+    /** References the loop's index parameter — `applyItem`/`applyOuter` have no index. */
+    referencesIndex: boolean;
+}
+/** §9.4 shape facts, read off the loop plan / IR by the caller. */
+export interface LazyRowShapeFacts {
+    /** Which emission site is asking. Both plain-loop-row sites are in scope. */
+    callSite: 'plain' | 'branch-plain';
+    flatMapLeafItem: boolean;
+    anchored: boolean;
+    bodyIsMultiRoot: boolean;
+    /** `LoopCore.key != null` — index-keyed loops are ineligible in v1 (§9.4). */
+    hasExplicitKey: boolean;
+    conditionalCount: number;
+    childRefCount: number;
+    nestedComponentCount: number;
+    innerLoopCount: number;
+    hasChildComponent: boolean;
+    hasMapPreamble: boolean;
+    preambleRegionCount: number;
+    /** A destructured loop param with no `paramBindings` (snapshot unwrap). */
+    hasParamUnwrap: boolean;
+}
+export interface LazyRowEligibilityArgs {
+    shape: LazyRowShapeFacts;
+    bindings: readonly ClassifiedLazyBinding[];
+    /**
+     * Free identifiers of the loop's SOURCE (`LoopCore.arrayFreeIdentifiers`
+     * unioned with the free identifiers of the fully-chained array expression,
+     * so `.filter(...)`/`.sort(...)` dependencies are covered). `null` when the
+     * IR carried none — ineligible, never assumed empty.
+     */
+    arraySourceIdentifiers: ReadonlySet<string> | null;
+    scope: LazyRowScopeInfo;
+}
+export type LazyRowEligibility = {
+    eligible: true;
+} | {
+    eligible: false;
+    reason: string;
+};
+/**
+ * Decide whether one plain loop row may use the lazy row graph (§9.4).
+ * Pure — every input is pre-resolved data, so this is directly unit-testable
+ * without building a component.
+ */
+export declare function lazyRowEligibility(args: LazyRowEligibilityArgs): LazyRowEligibility;
+/**
+ * Classify one binding's free identifiers into the row-local / reactive-outer
+ * / opaque-outer partition {@link lazyRowEligibility} consumes.
+ *
+ * **FAIL-SAFE (mandatory, §9.2):** when `free` is `null` — the IR carried no
+ * pre-computed free identifiers, or `freeIdentifiers()` refused the parsed
+ * tree (an `unsupported` node) — BOTH `readsItem` and `readsOuter` are forced
+ * true. A binding with `readsItem` is emitted into `applyItem`; a binding with
+ * `readsOuter` into `applyOuter`; a binding in both is emitted in BOTH. Double
+ * application is idempotent because every emitted write is dedup-guarded
+ * against `entry.last`, so "both" is always the safe answer and never a
+ * correctness risk.
+ *
+ * The unknown case ALSO records an `'<unknown>'` opaque name, which makes the
+ * loop ineligible: an outer dependency the compiler cannot name is an outer
+ * dependency it cannot PRIME, and an unprimed `applyOuter` effect would never
+ * 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.
+ */
+export declare function classifyLazyBinding(args: {
+    kind: 'attr' | 'text';
+    slotId: string;
+    free: ReadonlySet<string> | null;
+    /** Loop param name plus every destructured `paramBindings` name. */
+    rowLocalNames: ReadonlySet<string>;
+    indexParam: string;
+    scope: LazyRowScopeInfo;
+}): ClassifiedLazyBinding;
+//# sourceMappingURL=lazy-row-eligibility.d.ts.map

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

@@ -0,0 +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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"}

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

@@ -20,6 +20,7 @@ import type { IRLoopChildComponent } from '../../../types.ts';
 import type { SkeletonSlotPaths } from '../../html-template.ts';
 import type { ReactiveEffectsPlan } from './reactive-effects.ts';
 import type { InnerLoopsPlan } from './inner-loop.ts';
+import type { LazyRowPlanData } from './build-lazy-row.ts';
 /** Fields shared by every `LoopPlan` variant. */
 interface LoopPlanCommon {
     /** Container element variable (e.g. `_s1` for top-level, `__loop_<cv>` for branch). */
@@ -163,6 +164,15 @@ interface PlainLoopVariant extends DynamicLoopCommon {
      * `__el` to query against.
      */
     preambleRegions: readonly PreambleRegionPlan[];
+    /**
+     * Lazy row graph plan (`spec/slot-unification.md` §9, L3). Non-null when
+     * `lazyRowEligibility` accepted this loop: the stringifier emits
+     * `mapArrayLazy(...)` with this row plan instead of `mapArray(...)` +
+     * renderItem, and the row carries NO per-row reactive resources.
+     * Undefined for every ineligible loop — those keep today's emission
+     * byte-for-byte (sound-or-loud, `plan/lazy-row-eligibility.ts`).
+     */
+    lazyRow?: LazyRowPlanData;
 }
 /**
  * Loop body is a single child component (with or without nested child

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

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

package/dist/ir-to-client-js/control-flow/shared.d.ts

@@ -16,7 +16,7 @@ import type { IRLoopChildComponent, LoopParamBinding } from '../../types.ts';
 import type { LoopChildRefBinding, PreambleRegionPlan } from './plan/loop.ts';
 import type { PreambleRegionSource } from '../../types.ts';
 /**
- * Build the `keyFn` argument for mapArray / reconcileElements. `null` when
+ * Build the `keyFn` argument for mapArray / mapArrayAnchored. `null` when
  * the loop has no key expression. Every `CollectedLoop` variant (top-level /
  * branch / nested) carries an `index: string | null` field (#2218 threaded
  * it onto `NestedLoop` too), so the index param — when present — is always

package/dist/ir-to-client-js/control-flow/stringify/branch-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,wBAAwB,CAAA;AAE/B,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAW/E;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,SAAS,cAAc,EAAE,GAC/B,IAAI,CAIN"}
+{"version":3,"file":"branch-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/branch-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,wBAAwB,CAAA;AAE/B,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAW/E;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,SAAS,cAAc,EAAE,GAC/B,IAAI,CAIN"}