@barefootjs/jsx 0.26.4 → 0.28.0

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

@@ -0,0 +1,54 @@
+/**
+ * Claim-plan literal rendering — the compiler-side half of slot unification
+ * A3 (`spec/slot-unification.md` §4/§5-A3). The runtime's `SlotSpec`/
+ * `ClaimPlan` (`@barefootjs/client/runtime/claim-slots.ts`, A2) are pure
+ * data: `{ id, kind, path }` triples. This module is the single place that
+ * turns compile-time slot descriptors into that data's source-text form —
+ * every content-slot emission site (loop rows, preamble regions, dynamic
+ * text/JSX slots, `@client` expressions) renders its plan through
+ * `claimPlanLiteral`, never by hand-splicing strings, so the literal shape
+ * can only ever match `SlotSpec`.
+ *
+ * Paths are real root-relative child-index arrays wherever the caller
+ * already has them (the hoisted single-root loop skeleton, #2143's
+ * `SkeletonSlotPaths`); everywhere else a slot gets `path: []` and A2's
+ * `lazySlots`/`claimSlots` marker-scan fallback resolves it — sound, just a
+ * per-claim scan instead of an O(depth) walk. This is the explicit
+ * "cannot be statically pathed" escape valve `spec/slot-unification.md`
+ * §5-A3 sanctions, not a shortcut invented here.
+ */
+export interface ClaimSlotSpec {
+    readonly id: string;
+    readonly kind: 'text' | 'markup';
+    /** Root-relative child-index path, used when the path is unconditionally
+     *  valid at claim time. Ignored when `pathExpr` is set. */
+    readonly path: readonly number[];
+    /**
+     * Raw JS expression (already rendered source text) evaluating to a
+     * `number[]` at runtime, for the one case a plain literal can't express:
+     * a hoisted-skeleton path that's valid ONLY on the fresh-CSR-clone branch,
+     * never on the hydration-adopts-SSR branch (#2143 precedent — `__p` is
+     * nulled when `__existing` is truthy because the skeleton's simplified
+     * markup doesn't describe the real SSR-rendered tree). Typically
+     * `__existing ? [] : [1, 0]`. Overrides `path` when present.
+     */
+    readonly pathExpr?: string;
+    /**
+     * Slot unification Step B (`spec/slot-unification.md` §3(b), §5 Step B):
+     * true when NO marker was emitted for this slot — `path`'s last index is
+     * the slot's own position, not an anchor comment. Only ever set by
+     * `client-only-elision.ts`-derived callers; every other emission site
+     * omits it (falsy = today's marker-based behavior, unchanged).
+     */
+    readonly markerless?: boolean;
+}
+/** Render a `ClaimPlan` (an array of `SlotSpec`) as a source-text array literal. */
+export declare function claimPlanLiteral(slots: readonly ClaimSlotSpec[]): string;
+/**
+ * A stable JS identifier for the claimed-slot writer covering `slots`,
+ * derived from the first slot's id. Slot ids are unique per component (the
+ * `bf="sN"` marker namespace), so this can never collide across two
+ * distinct claim-plan call sites within the same emitted component.
+ */
+export declare function claimWriterVarName(slots: readonly ClaimSlotSpec[], sanitize: (id: string) => string): string;
+//# sourceMappingURL=claim-plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claim-plan.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/claim-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;IAChC;+DAC2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B;AASD,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAG5G"}

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

@@ -1 +1 @@
-{"version":3,"file":"inner-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/inner-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAOH,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,uBAAuB,CAAA;AAE9B,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAQN"}
+{"version":3,"file":"inner-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/inner-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,uBAAuB,CAAA;AAE9B,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,GACV,IAAI,CAQN"}

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

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/insert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAgC,MAAM,kBAAkB,CAAA;AAKhF,MAAM,WAAW,sBAAsB;IACrC,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAA;IACrB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,sBAAsB,GAC3B,IAAI,CAgBN"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/insert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAgC,MAAM,kBAAkB,CAAA;AAMhF,MAAM,WAAW,sBAAsB;IACrC,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAA;IACrB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,sBAAsB,GAC3B,IAAI,CAgBN"}

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;AAQH,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,CAmDN;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,CAsCN"}
+{"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

@@ -1,7 +1,7 @@
 /**
  * Stringify LoopPlan variants to source lines.
  *
- * Output shapes (preserved byte-identical from the legacy emitter):
+ * Output shapes:
  *
  *   PlainLoopPlan, no reactive effects (single-line renderItem):
  *     <indent>mapArray(() => <arr>, <container>, <keyFn>, (<head>, <idx>, __existing) =>
@@ -12,19 +12,23 @@
  *     <indent>  <unwrap?>
  *     <indent>  <preamble?>
  *     <indent>  const __el = __existing ?? (() => { ... })()
- *     <indent>  <reactive effects via stringifyReactiveEffects>
+ *     <indent>  <reactive effects + preamble regions via stringifyReactiveEffects —
+ *     <indent>   row-granularity (spec/slot-unification.md §3(c)): attrs, outer
+ *     <indent>   texts, and preamble regions merge into ONE createEffect per row
+ *     <indent>   in normal builds; profile-mode builds keep the legacy
+ *     <indent>   one-effect-per-slot shape (see that module's docstring)>
  *     <indent>  return __el
  *     <indent>})
  *
  *   StaticLoopPlan: two parallel forEach blocks (attrs / texts) — see
  *     emitStaticLoop. The forEach-duplication noted in observation O-4 is
- *     preserved bug-for-bug; PR 5+ collapses them.
+ *     preserved bug-for-bug; PR 5+ collapses them. Left untouched by the
+ *     row-granularity pass above — a different (forEach, not mapArray) shape.
  *
  * Indent convention for plain loops: top-level emission uses `'  '` (2 sp);
  * passed in via `topIndent`.
  */
 import type { LoopChildRefBinding, LoopPlan, PlainLoopPlan, StaticLoopPlan } from '../plan/types.ts';
-import type { PreambleRegionPlan } from '../plan/loop.ts';
 /**
  * Emit `(callback)(__rf)` for each ref on a per-item slot, looking up the
  * target element via `qsa(__el, '[bf="<slot>"]')` (or `qsaItem` for
@@ -44,23 +48,16 @@ export declare function emitLoopChildRefs(lines: string[], refs: readonly LoopCh
     elementIndexBySlot?: ReadonlyMap<string, number>;
 }): void;
 /**
- * Emit the region-patch effect for each preamble-patched region (#2389 —
- * `arr.map(t => { const cells = []; ...; return <tr>{cells}<td>{t.name}</td></tr> })`).
- * The effect re-runs the (loop-param-accessor-wrapped) preamble on every
- * reactive tick so it re-reads the current per-item signal, recomputes the
- * region's value, and — past the FIRST run (which only records, trusting
- * the SSR/CSR mount-time content already in the DOM) — patches the DOM
- * range via `patchSlotRange(__el, 'sN', html)`. The marker lookup lives
- * inside `patchSlotRange`, so a row that never changes pays zero lookup
- * cost at mount/adoption.
- *
- * Non-empty `regions` forces the caller's multi-line renderItem layout (the
- * effect needs `__el` as a query root), mirroring `emitLoopChildRefs`.
+ * Preamble-patched regions (#2389 — `arr.map(t => { const cells = []; ...;
+ * return <tr>{cells}<td>{t.name}</td></tr> })`) used to get their own
+ * per-region `createEffect` here. Row-granularity effects (perf,
+ * spec/slot-unification.md §3(c)/§8) merged that into the SAME single row
+ * effect `stringifyReactiveEffects` now emits for attrs/outer texts — see
+ * that module's docstring. Both plain-loop-row call sites
+ * (`stringifyPlainLoop` below, `stringify/branch-loop.ts`'s `emitPlain`) pass
+ * `preambleRegions`/`mapPreambleWrapped` straight into
+ * `stringifyReactiveEffects` instead of calling a separate emitter.
  */
-export declare function emitPreambleRegionEffects(lines: string[], regions: readonly PreambleRegionPlan[], mapPreambleWrapped: string, opts: {
-    indent: string;
-    elVar: string;
-}): void;
 /**
  * Single dispatch over `LoopPlan` (#1253). Narrows on `plan.kind` and
  * delegates to the per-variant stringifier. Callers should consume this

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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AASH,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACpG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEzD;;;;;;;;;;;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;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,kBAAkB,EAAE,MAAM,EAC1B,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACtC,IAAI,CAaN;AAED;;;;;;;;;;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,CAyIN;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CA+G/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/stringify/reactive-effects.d.ts

@@ -6,15 +6,46 @@
  * bodies (events, child component inits, inner loops, nested conditionals,
  * branch-scoped texts) flow through the per-arm stringifiers in
  * `loop-child-arm.ts` — no legacy passthrough remains.
+ *
+ * Row-granularity effects (perf, spec/slot-unification.md §3(c)/§8, the
+ * deferred A3b): for the "plain loop row, top-level or branch-scoped" shape
+ * — the only shape where `stringifyReactiveEffects` is called alongside
+ * `PreambleRegionPlan`s from the SAME renderItem scope (`stringify/loop.ts`'s
+ * `stringifyPlainLoop`, `stringify/branch-loop.ts`'s `emitPlain`) — reactive
+ * attrs, outer texts, and preamble regions all read the SAME per-item signal
+ * dependency, so consolidating them into ONE `createEffect` per row removes
+ * N-1 effect objects and subscription-list entries per row without changing
+ * the firing profile. Composite loops, component loops, and the anchored
+ * (whole-item-conditional) loop shape keep the legacy one-effect-per-slot
+ * emission — their reactiveEffects never carry preamble regions, and
+ * consolidating them wasn't part of this pass's mechanically-verified scope
+ * (see the call sites' docstrings).
+ *
+ * Profile mode (#1690) carries a `<Component>#binding:<slotId>` id per
+ * effect so the profiler attributes a re-run to its source binding — merging
+ * bindings into one effect would make every binding on the row share one id.
+ * Resolution: profile mode (`plan.profileComponentName` set) keeps the
+ * granular per-slot/per-attr effect emission (`emitAttrSlotsGranular` /
+ * `emitOuterTexts` below); normal builds get the consolidated row effect.
+ * Preamble regions never carried a per-region bfId even before this pass, so
+ * they always consolidate into one effect regardless of profile mode.
  */
 import type { ReactiveEffectsPlan } from '../plan/reactive-effects.ts';
+/** A resolved preamble-patched region (#2389) ready to merge into the row
+ *  effect — same shape as `plan/loop.ts`'s `PreambleRegionPlan`, restated
+ *  here so this module doesn't need a cross-import into the loop plan file
+ *  for one two-field shape. */
+export interface RowPreambleRegion {
+    slotId: string;
+    valueExpr: string;
+}
 export interface StringifyReactiveEffectsOptions {
     /** Indent prefix for every emitted line. */
     indent: string;
     /**
      * Element variable to attach effects to (e.g., `__el`, `__existing`,
      * `__csrEl`). The stringifier never inspects it — it is simply substituted
-     * into the qsa() / $t() / insert() call shapes.
+     * into the qsa() / lazySlots() / insert() call shapes.
      */
     elVar: string;
     /**
@@ -33,8 +64,36 @@ export interface StringifyReactiveEffectsOptions {
      * still resolves through the battle-tested runtime lookup.
      */
     elementIndexBySlot?: ReadonlyMap<string, number>;
-    /** Same as `elementIndexBySlot`, for text-marker slots (`$t`). */
-    textIndexBySlot?: ReadonlyMap<string, number>;
+    /**
+     * Rendered path EXPRESSION source (not a plain array — see
+     * `ClaimSlotSpec.pathExpr`) for outer text slots, keyed by slotId: perf,
+     * #2143's hoisted single-root loop skeleton
+     * (`SkeletonSlotPaths.textMarkerPaths`), guarded by `__existing` the same
+     * way `__p` is nulled on the hydration branch (the skeleton's simplified
+     * markup doesn't describe the real SSR-rendered tree). Only
+     * `stringifyPlainLoop`'s hoisted-skeleton path supplies these; every other
+     * caller omits it and each text slot's claim-plan entry gets `path: []`
+     * — A2's marker-scan fallback resolves it at claim time (sound, just
+     * slower), per `spec/slot-unification.md` §5-A3's explicit "cannot be
+     * statically pathed" allowance.
+     */
+    textClaimPathExprs?: ReadonlyMap<string, string>;
+    /**
+     * Preamble-patched regions (#2389) to merge into the SAME row effect as
+     * this scope's reactive attrs/outer texts (row-granularity effects,
+     * §3(c)) — only supplied by the plain-loop-row call sites
+     * (`stringify/loop.ts`, `stringify/branch-loop.ts`) where
+     * `PlainLoopVariant.preambleRegions` exists on the plan. Every other
+     * caller omits this and gets the legacy per-slot emission untouched.
+     */
+    preambleRegions?: readonly RowPreambleRegion[];
+    /**
+     * The loop callback's pre-return preamble (already wrapped with the loop
+     * param accessor), re-run once per row-effect tick — BEFORE any preamble
+     * region read — so `preambleRegions`' `valueExpr`s see freshly recomputed
+     * locals. Only meaningful alongside `preambleRegions`.
+     */
+    mapPreambleWrapped?: string;
 }
-export declare function stringifyReactiveEffects(lines: string[], plan: ReactiveEffectsPlan, opts: StringifyReactiveEffectsOptions): void;
+export declare function stringifyReactiveEffects(lines: string[], plan: ReactiveEffectsPlan | null, opts: StringifyReactiveEffectsOptions): void;
 //# sourceMappingURL=reactive-effects.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,6BAA6B,CAAA;AAEpC,MAAM,WAAW,+BAA+B;IAC9C,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,kEAAkE;IAClE,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9C;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,+BAA+B,GACpC,IAAI,CAmCN"}
+{"version":3,"file":"reactive-effects.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/reactive-effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAMH,OAAO,KAAK,EAGV,mBAAmB,EAEpB,MAAM,6BAA6B,CAAA;AAEpC;;;+BAG+B;AAC/B,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,+BAA+B;IAC9C,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAA;IAC9C;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,mBAAmB,GAAG,IAAI,EAChC,IAAI,EAAE,+BAA+B,GACpC,IAAI,CA8BN"}

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

@@ -4,7 +4,7 @@
  * These three functions are called from `generate-init.ts` to emit the
  * client-side runtime calls that drive reactive conditionals
  * (`insert(...)`) and reactive loops (`mapArray(...)` /
- * `reconcileElements`) for a single component.
+ * `mapArrayAnchored(...)`) for a single component.
  *
  * Each entry point thinly wraps the Plan layer:
  *

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

package/dist/ir-to-client-js/element-refs.d.ts

@@ -2,13 +2,18 @@
  * Element ref declarations — `const [_s0, _s1] = $(…, 's0', 's1')`.
  *
  * Every element the init body needs to find at hydration time (events,
- * dynamic text, loops, refs, reactive attrs, reactive props, rest-attr
- * elements, child component slots) is emitted via one of three finders:
+ * loops, refs, reactive attrs, reactive props, rest-attr elements, child
+ * component slots) is emitted via one of two finders:
  *
  *   `$(…)`  — regular DOM elements (bf-*)
- *   `$t(…)` — text comment markers for dynamic text (`<!--bf:sN-->`)
  *   `$c(…)` — component slots (bf-s, component-rooted)
  *
+ * Dynamic text/JSX content slots (`<!--bf:sN-->` markers) don't need a ref
+ * here at all — they resolve through a claimed-slot writer built where
+ * they're used (`emitDynamicTextUpdates`/`emitClientOnlyExpressions` in
+ * `ir-to-client-js/emit-reactive.ts`, slot unification A3), not a
+ * pre-resolved `_sN` var.
+ *
  * Slots inside conditional branches are excluded here because
  * `insert()` bindEvents re-queries them when the branch activates.
  * Component slots take precedence over regular slots (#360): when a

package/dist/ir-to-client-js/element-refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"element-refs.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/element-refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAuDhE"}
+{"version":3,"file":"element-refs.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/element-refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAgDhE"}

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

@@ -18,7 +18,14 @@ export declare function emitAttrUpdate(target: string, attrName: string, express
 export declare function rewriteDestructuredPropsInExpr(expr: string, ctx: ClientJsContext): string;
 /** Emit createEffect blocks that update text nodes for reactive expressions. */
 export declare function emitDynamicTextUpdates(lines: string[], ctx: ClientJsContext): void;
-/** Emit createEffect blocks for client-only expressions using comment markers. */
+/**
+ * Emit createEffect blocks for `@client` expressions. Slot unification A3:
+ * these are ordinary claimed 'text' slots now (never Node-valued — `@client`
+ * only ever evaluates a plain expression), one writer per slot at `__scope`,
+ * replacing `updateClientMarker`'s full-tree rescan + zero-width-space
+ * managed-node marker (no longer needed: a claimed Text node's identity is
+ * already known, so there's nothing to disambiguate from other content).
+ */
 export declare function emitClientOnlyExpressions(lines: string[], ctx: ClientJsContext): void;
 /** Emit createEffect blocks that sync reactive attribute values (class, value, checked, etc.). */
 export declare function emitReactiveAttributeUpdates(lines: string[], ctx: ClientJsContext): void;

package/dist/ir-to-client-js/emit-reactive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit-reactive.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/emit-reactive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,aAAa,CAAA;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAoBjD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAyC7G;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAmBzF;AAqLD,gFAAgF;AAChF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAkElF;AAED,kFAAkF;AAClF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAQrF;AAED,kGAAkG;AAClG,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAyBxF;AAED,+FAA+F;AAC/F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAqDpF;AAED,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAgClF"}
+{"version":3,"file":"emit-reactive.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/emit-reactive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,aAAa,CAAA;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAqBjD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAyC7G;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAmBzF;AAqLD,gFAAgF;AAChF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAsFlF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAgBrF;AAED,kGAAkG;AAClG,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAyBxF;AAED,+FAA+F;AAC/F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAqDpF;AAED,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAgClF"}

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

@@ -30,6 +30,7 @@ export declare function createTemplateAwareStringProtector(): {
     restore: (s: string) => string;
     replaceProtectedCall: (haystack: string, needle: string, replacement: () => string) => string;
 };
+export declare const VOID_ELEMENTS: Set<string>;
 /**
  * Source-of-truth predicates for the collision-safe spread-attrs merge
  * shared by all three CSR-side emit paths (`irToHtmlTemplate`,
@@ -194,6 +195,25 @@ export interface SkeletonSlotPaths {
     /** slotId -> path to the first Comment of the `<!--bf:slotId--><!--/-->` marker pair. */
     textMarkerPaths: ReadonlyMap<string, readonly number[]>;
 }
+/**
+ * Tags whose HTML-parser behavior can silently restructure or drop children
+ * relative to the naive IR-tree model (implied table sections, `<select>`/
+ * `<optgroup>` child-dropping, `<p>` auto-close, leading-newline drop in
+ * `<pre>`/`<textarea>`, `<template>` content relocating into `.content`). A
+ * skeleton containing any of these bails on path computation entirely —
+ * the loop keeps its hoisted-clone fast path, but every slot lookup falls
+ * back to `qsa`/`$t`.
+ */
+export declare const SKELETON_PATH_HAZARD_TAGS: Set<string>;
+/**
+ * Tag groups the HTML parser force-closes when a tag from the group is
+ * nested inside ANY other open tag from the SAME group — not just an
+ * identical tag (e.g. `<h2>` inside `<h1>` closes the `<h1>`, `<dd>` inside
+ * `<dt>` closes the `<dt>`). A skeleton hitting this bails on path
+ * computation entirely (see `SKELETON_PATH_HAZARD_TAGS` doc).
+ */
+export declare const SKELETON_PATH_FORCE_CLOSE_GROUPS: ReadonlyArray<ReadonlySet<string>>;
+export declare function skeletonForceCloseGroup(tag: string): number;
 /**
  * Compute per-slot child-index paths for a loop skeleton already proven
  * safe by `buildLoopSkeletonTemplate` — call this ONLY after that returned
@@ -204,6 +224,10 @@ export interface SkeletonSlotPaths {
  * diverge from the browser's actual parsed structure.
  */
 export declare function computeSkeletonSlotPaths(node: IRNode, safe: LoopSkeletonSafeSlots): SkeletonSlotPaths | null;
+/** True if `children` (already flattened) contains anything the HTML parser would foster-parent out of a `<tr>`. */
+export declare function hasForeignTableRowContent(children: readonly IRNode[]): boolean;
+/** Splice fragment children inline — a fragment contributes no DOM node of its own. */
+export declare function flattenSkeletonChildren(children: readonly IRNode[]): IRNode[];
 /**
  * Generate an HTML template for composite element reconciliation.
  * Identical to irToHtmlTemplate except component nodes become placeholder

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":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAe,MAAM,EAAU,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAG/G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAG/C,OAAO,EAAwD,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACvG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI;IACvC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC9B,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CAC/B,CAaA;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBnE;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,IAAI;IACpD,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC9B,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC9B,oBAAoB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,MAAM,KAAK,MAAM,CAAA;CAC9F,CAgDA;AAkSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,gBAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,KAAK,OAAO,CAAA;IACxE,+EAA+E;IAC/E,eAAe,EAAE,OAAO,CAAA;CACzB;AAgHD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAC/C,IAAI,EAAE;IACJ,0EAA0E;IAC1E,WAAW,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IACnC,oEAAoE;IACpE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACtC,uEAAuE;IACvE,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAA;IAClC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,GACA,MAAM,CAaR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc5D;AAQD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EACrC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC5B,MAAM,CAUR;AAED,+EAA+E;AAC/E,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,OAAO,CAE1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACxC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC5B,MAAM,CAQR;AAkCD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,SAAS,SAAI,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,UAAU,UAAQ,EAAE,iBAAiB,UAAQ,GAAG,MAAM,CAuO/N;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,6GAA6G;IAC7G,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACrC,yFAAyF;IACzF,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,MAAM,GAAG,IAAI,CA4FlG;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,gIAAgI;IAChI,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACpD,yFAAyF;IACzF,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;CACxD;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,iBAAiB,GAAG,IAAI,CAK5G;AAgHD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,SAAS,SAAI,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,MAAM,CA6G9J;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAM7D;AA0ED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAM1E;AAeD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC9B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACpC,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC7B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAC9B,MAAM,CAER;AA4PD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC7B,OAAO,CA8ET;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnD,GAAG,EAAE,eAAe,EACpB,UAAU,CAAC,EAAE,OAAO,EACpB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC7B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,EAC/B,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC9B,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACvC,MAAM,CAgBR;AAuHD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnD,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EACjD,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAC9B,GAAG,CAAC,MAAM,CAAC,CAmDb;AAsVD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAiBpF"}
+{"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/imports.d.ts

@@ -2,9 +2,9 @@
  * Import detection and DOM import management.
  */
 import type { ComponentIR } from '../types.ts';
-export declare const RUNTIME_IMPORT_CANDIDATES: readonly ['createSignal', 'createMemo', 'createEffect', 'onCleanup', 'onMount', 'hydrate', 'insert', 'reconcileElements', 'getLoopChildren', 'getLoopNodes', 'mapArray', 'mapArrayAnchored', 'patchLeaf', 'patchSlotRange', 'createDisposableEffect', 'createComponent', 'renderChild', 'registerComponent', 'registerTemplate', 'initChild', 'upsertChild', 'updateClientMarker', 'createPortal', 'provideContext', 'createContext', 'useContext', 'forwardProps', 'applyRestAttrs', 'splitProps', 'spreadAttrs', 'styleToCss', 'escapeAttr', 'escapeText', 'qsa', 'qsaItem', 'qsaChildScope', 'qsaChildScopes', 'upsertChildItem', '__slot', '__bfSlot', '__bfText', 'tAfter', 'beginTurn', 'endTurn', 'date', 'formatDate'];
+export declare const RUNTIME_IMPORT_CANDIDATES: readonly ['createSignal', 'createMemo', 'createEffect', 'onCleanup', 'onMount', 'hydrate', 'insert', 'getLoopChildren', 'getLoopNodes', 'mapArray', 'mapArrayAnchored', 'mapArrayLazy', 'patchLeaf', 'createDisposableEffect', 'createComponent', 'renderChild', 'registerComponent', 'registerTemplate', 'initChild', 'upsertChild', 'createPortal', 'provideContext', 'createContext', 'useContext', 'forwardProps', 'applyRestAttrs', 'splitProps', 'spreadAttrs', 'styleToCss', 'escapeAttr', 'escapeText', 'escapeTextOrNode', 'qsa', 'qsaItem', 'qsaChildScope', 'qsaChildScopes', 'upsertChildItem', '__slot', '__bfSlot', '__bfText', 'claimSlots', 'lazySlots', 'lazyClaimSlots', 'textOrNode', 'beginTurn', 'endTurn', 'date', 'formatDate'];
 /** @deprecated Use RUNTIME_IMPORT_CANDIDATES */
-export declare const DOM_IMPORT_CANDIDATES: readonly ["createSignal", "createMemo", "createEffect", "onCleanup", "onMount", "hydrate", "insert", "reconcileElements", "getLoopChildren", "getLoopNodes", "mapArray", "mapArrayAnchored", "patchLeaf", "patchSlotRange", "createDisposableEffect", "createComponent", "renderChild", "registerComponent", "registerTemplate", "initChild", "upsertChild", "updateClientMarker", "createPortal", "provideContext", "createContext", "useContext", "forwardProps", "applyRestAttrs", "splitProps", "spreadAttrs", "styleToCss", "escapeAttr", "escapeText", "qsa", "qsaItem", "qsaChildScope", "qsaChildScopes", "upsertChildItem", "__slot", "__bfSlot", "__bfText", "tAfter", "beginTurn", "endTurn", "date", "formatDate"];
+export declare const DOM_IMPORT_CANDIDATES: readonly ["createSignal", "createMemo", "createEffect", "onCleanup", "onMount", "hydrate", "insert", "getLoopChildren", "getLoopNodes", "mapArray", "mapArrayAnchored", "mapArrayLazy", "patchLeaf", "createDisposableEffect", "createComponent", "renderChild", "registerComponent", "registerTemplate", "initChild", "upsertChild", "createPortal", "provideContext", "createContext", "useContext", "forwardProps", "applyRestAttrs", "splitProps", "spreadAttrs", "styleToCss", "escapeAttr", "escapeText", "escapeTextOrNode", "qsa", "qsaItem", "qsaChildScope", "qsaChildScopes", "upsertChildItem", "__slot", "__bfSlot", "__bfText", "claimSlots", "lazySlots", "lazyClaimSlots", "textOrNode", "beginTurn", "endTurn", "date", "formatDate"];
 export declare const RUNTIME_MODULE = "@barefootjs/client/runtime";
 export declare const IMPORT_PLACEHOLDER = "/* __BAREFOOTJS_DOM_IMPORTS__ */";
 export declare const MODULE_CONSTANTS_PLACEHOLDER = "/* __MODULE_LEVEL_CONSTANTS__ */";

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

@@ -1 +1 @@
-{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/imports.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,aAAa,CAAA;AAItD,eAAO,MAAM,yBAAyB,YACpC,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EACpE,SAAS,EAAE,QAAQ,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,WAAW,EAAE,gBAAgB,EAAE,wBAAwB,EACpK,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EAAE,oBAAoB,EAC3H,cAAc,EACd,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAC/C,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EACvG,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EACxG,QAAQ,EAER,WAAW,EAAE,SAAS,EAItB,MAAM,EAIN,YAAY,CACJ,CAAA;AAEV,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,gsBAA4B,CAAA;AAE9D,eAAO,MAAM,cAAc,+BAA+B,CAAA;AAE1D,eAAO,MAAM,kBAAkB,qCAAqC,CAAA;AACpE,eAAO,MAAM,4BAA4B,qCAAqC,CAAA;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAqB3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,EAAE,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAmCvH"}
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/imports.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,aAAa,CAAA;AAItD,eAAO,MAAM,yBAAyB,YACpC,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EACpE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,wBAAwB,EAC7I,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EACrG,cAAc,EACd,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAC/C,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAC3H,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAUxG,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAEzD,WAAW,EAAE,SAAS,EAItB,MAAM,EAIN,YAAY,CACJ,CAAA;AAEV,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,wtBAA4B,CAAA;AAE9D,eAAO,MAAM,cAAc,+BAA+B,CAAA;AAE1D,eAAO,MAAM,kBAAkB,qCAAqC,CAAA;AACpE,eAAO,MAAM,4BAA4B,qCAAqC,CAAA;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAqB3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,EAAE,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAmCvH"}

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

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

package/dist/ir-to-client-js/types.d.ts

@@ -222,7 +222,7 @@ export interface LoopCore {
     /**
      * Unique id for this loop's `<!--bf-loop:<id>--> ... <!--bf-/loop:<id>-->`
      * marker pair, threaded from `IRLoop.markerId`. Each `mapArray()` /
-     * `reconcileElements()` call passes this id so sibling loops under the
+     * `mapArrayAnchored()` call passes this id so sibling loops under the
      * same parent reconcile their own range (#1087).
      */
     markerId: string;
@@ -598,6 +598,14 @@ export interface ReactiveAttribute extends AttrMeta {
 export interface ClientOnlyElement {
     slotId: string;
     expression: string;
+    /**
+     * Slot unification Step B (`spec/slot-unification.md` §3(b), §5 Step B):
+     * copied from `IRExpression.elidedPath` (`client-only-elision.ts`) when
+     * the compiler proved this slot's marker pair can be elided. Absent
+     * (`undefined`) is always safe — the claim plan falls back to `path: []`
+     * / marker-based resolution exactly as before Step B.
+     */
+    elidedPath?: readonly number[];
 }
 export interface RestAttrElement {
     slotId: string;