@barefootjs/jsx 0.27.0 → 0.28.0

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":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,EACb,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,iDAAiD;AACjD,UAAU,cAAc;IACtB,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAA;IACpB,kGAAkG;IAClG,SAAS,EAAE,MAAM,CAAA;IACjB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;;OAQG;IACH,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACzC;;;;;;;;;;OAUG;IACH,eAAe,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAC/C;AAED,uEAAuE;AACvE,UAAU,iBAAkB,SAAQ,cAAc;IAChD,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;GAIG;AACH,UAAU,gBAAiB,SAAQ,iBAAiB;IAClD,IAAI,EAAE,OAAO,CAAA;IACb,4FAA4F;IAC5F,kBAAkB,EAAE,MAAM,CAAA;IAC1B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,iBAAiB,CAAA;IACjC,qFAAqF;IACrF,eAAe,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC3C;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;;OAIG;IACH,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC9C;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,eAAe,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,UAAU,oBAAqB,SAAQ,iBAAiB;IACtD,IAAI,EAAE,WAAW,CAAA;IACjB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAA;IACrB,iEAAiE;IACjE,kBAAkB,EAAE,MAAM,CAAA;IAC1B,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,WAAW,EAAE,mBAAmB,EAAE,CAAA;IAClC,0EAA0E;IAC1E,uBAAuB,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACnD;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;GAMG;AACH,UAAU,oBAAqB,SAAQ,iBAAiB;IACtD,IAAI,EAAE,WAAW,CAAA;IACjB,mFAAmF;IACnF,kBAAkB,EAAE,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAA;IAChB,kGAAkG;IAClG,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC3C,uDAAuD;IACvD,WAAW,EAAE,SAAS,cAAc,EAAE,CAAA;IACtC,iFAAiF;IACjF,UAAU,EAAE,cAAc,CAAA;IAC1B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,wDAAwD;IACxD,iBAAiB,EAAE,YAAY,CAAC,eAAe,CAAC,CAAA;IAChD,yDAAyD;IACzD,eAAe,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC3C;;;;OAIG;IACH,mBAAmB,EAAE,OAAO,CAAA;IAC5B,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;GAIG;AACH,UAAU,iBAAkB,SAAQ,cAAc;IAChD,IAAI,EAAE,QAAQ,CAAA;IACd,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;IACb,uFAAuF;IACvF,cAAc,EAAE,MAAM,CAAA;IACtB,0EAA0E;IAC1E,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC,CAAC,CAAA;IAC/E,2CAA2C;IAC3C,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;IACvC;;;;;OAKG;IACH,cAAc,EAAE,yBAAyB,GAAG,IAAI,CAAA;IAChD;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAChB,gBAAgB,GAChB,oBAAoB,GACpB,oBAAoB,GACpB,iBAAiB,CAAA;AAErB;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAChE,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AACxE,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AACxE,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AAElE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAA;IACrB,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAA;IACjB,+EAA+E;IAC/E,kBAAkB,EAAE;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACvD;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,oFAAoF;IACpF,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAA;CACzB"}

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"}

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

@@ -0,0 +1,98 @@
+/**
+ * Emit a lazy row graph loop — `mapArrayLazy(...)` + a compiler-built
+ * `LazyRowPlan` object literal (`spec/slot-unification.md` §9, L3).
+ *
+ * This is the alternative to `stringifyPlainLoop`'s `mapArray` + renderItem
+ * emission, taken only when `lazyRowEligibility` said yes (see
+ * `plan/lazy-row-eligibility.ts`). Every ineligible loop keeps today's
+ * emission byte-for-byte — sound-or-loud, no silent third path.
+ *
+ * Output shape:
+ *
+ *     const __tpl_<mid> = document.createElement('template')      // hoisted skeleton, when usable
+ *     __tpl_<mid>.innerHTML = `…`
+ *     const __lzp_<mid> = [...]                                   // hoisted fresh-clone text paths, when usable
+ *     const __lzs_<mid> = [{ id, kind: 'text', path: [] }, …]      // hoisted claim plan, ADOPTED-row form
+ *     const __lzsc_<mid> = [{ id, kind: 'text', path: __lzp_<mid>[i] }, …]  // FRESH-CLONE form, only when it differs
+ *     const __lzc_<mid> = (__e) => { … }                          // lazy ref claim for ADOPTED rows (door slot empty)
+ *     mapArrayLazy(() => <arr>, <container>, <keyFn>, {
+ *       createRow: (__e, <idx>) => { … writes every binding, seeds refs+last … },
+ *       applyItem: (__e) => { … item-driven bindings, dedup against __e.last … },
+ *       applyOuter: (__es, __seed) => { … one loop-level effect body … },
+ *     }, '<markerId>')
+ *
+ * Three shapes carry the plan's obligations (runtime docstring,
+ * `packages/client/src/runtime/map-array-lazy.ts`):
+ *
+ * **`createRow`** — CSR creation. Clones the row, resolves refs from KNOWN
+ * clone paths (the hoisted skeleton's `__p`-style child-index chains, reused
+ * verbatim from #2143 via `pathExpr`) with no scan, writes ALL bindings
+ * (item-driven and outer-involving alike) and seeds `entry.last` so the
+ * loop-level outer effect's dedup is correct from the row's first tick.
+ *
+ * **`applyItem`** — called by the reconciler after `entry.item` changed.
+ * Claims refs lazily through `__lzc_<mid>` (a `qsa` scan inside that ONE row)
+ * when `entry.refs` is null, materializes the content door on demand
+ * (`doorAccess`), then writes each item-driven binding behind a per-binding
+ * dedup on `entry.last`.
+ *
+ * **`applyOuter`** — the ONE loop-level effect body, emitted only when some
+ * binding is outer-involving. Two details matter:
+ *
+ *  - **Prime reads first.** The effect subscribes to whatever its body reads.
+ *    With an empty entry list the per-row loop reads nothing, so the effect
+ *    would never subscribe and the loop would go permanently dead. The plan
+ *    therefore emits a bare `getter()` statement per reactive outer name
+ *    BEFORE the row loop. The eligibility gate guarantees every reactive
+ *    outer name is a primable zero-arg signal/memo getter.
+ *  - **Read-compare-write seeding (§9.3(1)).** On the first run (`__seed`)
+ *    each binding computes its value, READS the current DOM, and writes only
+ *    on difference — sound even when the outer state is client-only and
+ *    diverges from SSR, with no writes on the consistent path. The DOM read
+ *    is per attribute KIND and pairs with `emitAttrUpdate`'s dispatch
+ *    (`emit-reactive.ts`); any kind this module does not recognise falls back
+ *    to `true` (always write on seed), which is conservative, never wrong.
+ *    CONTENT slots seed the same way through the claim's `read(id)` door
+ *    (§9.5, lifted) — see `refParts` for the per-loop door choice.
+ *
+ * A loop with NO outer binding emits no `applyOuter` at all — its rows do
+ * literally nothing at hydration.
+ */
+import type { SkeletonSlotPaths } from '../../html-template.ts';
+import type { LazyRowAttrBinding, LazyRowPlanData } from '../plan/build-lazy-row.ts';
+export interface StringifyLazyRowOptions {
+    /** Indent of the `mapArrayLazy(` line itself. */
+    indent: string;
+    containerVar: string;
+    /** Wrap the call in `if (<containerVar>) …` — branch-scoped loops do. */
+    guardContainer: boolean;
+    markerId: string;
+    arrayExpr: string;
+    keyFn: string;
+    paramHead: string;
+    indexParam: string;
+    /** Per-row interpolated template (the non-hoisted clone source). */
+    template: string;
+    skeletonTemplate?: string;
+    skeletonPaths?: SkeletonSlotPaths;
+    lazyRow: LazyRowPlanData;
+}
+export declare function stringifyLazyRowLoop(lines: string[], o: StringifyLazyRowOptions): void;
+/** `entry.last`-backed dedup test. `in` (not a truthiness check) so a
+ *  legitimately `undefined` value still records and still writes once. */
+declare function dedupGuard(ordinal: number): string;
+/**
+ * Read-compare-write seeding predicate (§9.3(1)): does the CURRENT DOM
+ * differ from the value `__x` this binding would write? Mirrors
+ * `emitAttrUpdate`'s per-kind dispatch (`emit-reactive.ts`) — the two must
+ * be read together. An unrecognised kind returns `true`, i.e. write on the
+ * seed run unconditionally: conservative, never unsound.
+ */
+declare function seedDiffersExpr(target: string, a: LazyRowAttrBinding): string;
+/** Exported for the emission-shape unit tests. */
+export declare const __lazyRowInternals: {
+    seedDiffersExpr: typeof seedDiffersExpr;
+    dedupGuard: typeof dedupGuard;
+};
+export {};
+//# sourceMappingURL=lazy-row.d.ts.map

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

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

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

@@ -45,6 +45,11 @@ export declare function stringifyBranchEventBindings(lines: string[], plan: Bran
  * SSR side: element has `bf-s` → qsa() finds it, initChild wires events.
  * CSR side: element is a `data-bf-ph` placeholder → createComponent
  * replaces it, then initChild runs against the new element.
+ *
+ * The placeholder is passed to `createComponent` as its `mountAt`
+ * argument so the component's own init runs connected — context resolves
+ * by DOM position, and a detached init falls back to the global,
+ * last-writer-wins context store.
  */
 export declare function stringifyBranchChildComponentInits(lines: string[], plan: BranchChildComponentInitsPlan, indent: string): void;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"loop-child-arm.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,OAAO,KAAK,EACV,6BAA6B,EAC7B,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAcN;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,uBAAuB,EAC7B,MAAM,EAAE,MAAM,GACb,IAAI,CAYN;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,6BAA6B,EACnC,MAAM,EAAE,MAAM,GACb,IAAI,CAIN;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CA0DN;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,SAAS,wBAAwB,EAAE,EACjD,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAIN;AA0BD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,gBAAgB,EACrB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,GAAG,SAAS,GACrB,IAAI,CAiDN"}
+{"version":3,"file":"loop-child-arm.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,OAAO,KAAK,EACV,6BAA6B,EAC7B,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAcN;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,uBAAuB,EAC7B,MAAM,EAAE,MAAM,GACb,IAAI,CAYN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,6BAA6B,EACnC,MAAM,EAAE,MAAM,GACb,IAAI,CAIN;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CA0DN;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,SAAS,wBAAwB,EAAE,EACjD,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAIN;AA0BD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,gBAAgB,EACrB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,GAAG,SAAS,GACrB,IAAI,CAiDN"}

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

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAUH,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,SAAS,mBAAmB,EAAE,EACpC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAClH,IAAI,CAaN;AAED;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAoBnE;AAYD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,aAAa,EACnB,SAAS,GAAE,MAAa,GACvB,IAAI,CAyJN;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAkH/E"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAWH,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,SAAS,mBAAmB,EAAE,EACpC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAClH,IAAI,CAaN;AAED;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAoBnE;AAYD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,aAAa,EACnB,SAAS,GAAE,MAAa,GACvB,IAAI,CA+KN;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAkH/E"}

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

@@ -1 +1 @@
-{"version":3,"file":"control-flow.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/control-flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,YAAY,CAAA;AAY/D,yFAAyF;AACzF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAOlF;AAED,8EAA8E;AAC9E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAQtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAmB1G"}
+{"version":3,"file":"control-flow.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/control-flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,YAAY,CAAA;AAa/D,yFAAyF;AACzF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAOlF;AAED,8EAA8E;AAC9E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAQtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAuB1G"}