@barefootjs/client 0.26.4 → 0.28.0

package/dist/reactive.d.ts.map

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

package/dist/runtime/claim-slots.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Claim-plan interpreter and claimed-slot primitives (slot unification
+ * Steps A2/A3, `spec/slot-unification.md` §4/§5).
+ *
+ * This module is the ONE claim mechanism the spec's §4 target architecture
+ * describes: a compile-time `ClaimPlan` (per-slot child-index paths from a
+ * claim root down to the slot's anchor comment) is resolved ONCE — either
+ * eagerly (`claimSlots`) or lazily on first write (`lazySlots`) — and every
+ * later write goes through the held reference, never re-scanning the DOM.
+ * As of A3 the compiler emits claim plans for every content slot; the
+ * `patchSlotRange` and `updateClientMarker` mechanisms it superseded are
+ * deleted. `$t`/text-effect writes and `__bfText` are ALSO superseded for
+ * every emission site but one — see `dynamic-text.ts`'s docstring for the
+ * one deliberately-deferred case (`emitDynamicTextUpdates`'s
+ * `conditionalElems` path).
+ *
+ * Anchors are still the existing `<!--bf:sN-->…<!--/-->` marker pairs — SSR
+ * bytes are unchanged in Step A (§5, §6) so the new client claims against
+ * known-good SSR output. A path is only required to be valid AT THE MOMENT
+ * OF CLAIM (§2): once a 'text' Text node or a 'markup' boundary pair is
+ * held, subsequent writes never consult the path or the marker again, so a
+ * sibling slot's later variable-length change cannot invalidate anything
+ * already claimed.
+ *
+ * Kind contracts (mirroring the mechanisms being superseded — this is the
+ * "one slot concept with an identity contract" of §4):
+ *   - 'text': held ref is the Text node immediately after the anchor
+ *     comment. The CLAIM is non-mutating: it adopts that node when SSR
+ *     rendered the slot non-empty and otherwise holds the ANCHOR COMMENT
+ *     itself as a stand-in for the not-yet-created node, deferring
+ *     `document.createTextNode` to the first write that actually needs it
+ *     (`materializeText` reads the insertion point off that comment). That
+ *     one-field representation is deliberate — see `ClaimedTextSlot`. What
+ *     lets
+ *     `read` exist — a seed that only compares must be able to inspect a
+ *     slot without leaving an empty Text node behind on every row
+ *     (§9.3(1)). Writes are a `nodeValue` assignment, and once materialized
+ *     the node's identity never changes — the guarantee effect closures and
+ *     `mapArray`'s same-key path rely on.
+ *   - 'markup': held ref is BOTH boundary comments (start = anchor, end =
+ *     the matching `<!--/-->` found by a nesting-depth walk (any further
+ *     `bf:`-prefixed comment along the way opens a nested region). A string
+ *     write clears everything strictly between the boundaries and inserts
+ *     freshly `<template>`-parsed HTML before the end comment; a `Node`
+ *     write clears the range and splices the node in by identity (the
+ *     `__bfText` live-Node case). The boundaries themselves are never
+ *     removed, so the range stays writeable on every later write. Because
+ *     the end ref is already held, a write never needs to re-walk for
+ *     nesting depth — only the CLAIM does.
+ *
+ * Warn-don't-guess (§4, "one ownership rule"): a path that fails to resolve
+ * to its slot's own `bf:sN` comment — out of range, or shape drift where
+ * the path now lands on some other node — falls back to a marker scan
+ * within the claim root, using the same ownership rule as `query.ts`'s `$t`:
+ * a `bf:sN` comment owned by a nested `bf-s` scope (a child component's own
+ * same-numbered slot — ids are
+ * assigned per component, so collisions are expected) is never a candidate
+ * — UNLESS the id is `^`-prefixed (`BF_PARENT_OWNED_PREFIX`), meaning the
+ * marker is content the claiming component itself authored and merely
+ * forwarded through one or more descendants' `children` (see
+ * `findOwnedMarker`'s docstring); for those the ownership walk is skipped
+ * outright, matching `query.ts`'s `$()`. If neither the path nor the
+ * fallback scan finds an owned marker, that one slot is dropped with a
+ * `console.warn` and the rest of the plan still claims — never guess a
+ * boundary, and never let one bad slot sink its siblings. An EMPTY path
+ * (`[]`) skips straight to the scan without that first warning — the
+ * compiler emits `path: []` deliberately when a slot's position can't be
+ * statically pathed (slot unification A3), so a miss there is expected, not
+ * drift; only a non-empty path that fails to resolve signals a real shape
+ * mismatch worth warning about.
+ *
+ * Row-pristine lazy claim (§3(a)): `lazySlots` touches NOTHING until the
+ * first write, and that first write claims the WHOLE plan at once (not just
+ * the slot being written) — so no earlier write into one slot can shift a
+ * sibling slot's still-unclaimed path out from under it. A row that never
+ * updates never pays for a claim at all. `claimSlots` is the eager escape
+ * hatch for callers that cannot honor that invariant (streaming/portal
+ * paths that mutate row content before any write would occur, per §6's
+ * risk note) — it claims every slot in the plan immediately.
+ *
+ * Dedup, no trust-first-run (slot unification A3 follow-up): a 'markup'
+ * slot's write door holds a `last` value alongside its boundary refs. Every
+ * write — INCLUDING THE FIRST — clears-and-inserts unless the new string
+ * equals `last`, in which case the DOM touch is skipped. `last` starts
+ * `undefined`, which never equals a `String(...)`-coerced value, so the
+ * first write can never dedup away; it always patches. A `Node` write is
+ * deduped by identity (mirrors `__bfText`'s `value === current` check) and,
+ * like the string case, is never skipped on the first write — a freshly
+ * `createComponent`-built element is a distinct object from whatever the
+ * SSR markup rendered, so it always splices. 'text' writes stay a plain
+ * `nodeValue` assignment (already idempotent, per §5's design note) — no
+ * dedup state needed.
+ *
+ * The first write is never skipped on the assumption that the claimed
+ * range already matches SSR/CSR content ("trust-first-run") — that
+ * assumption only holds for a preamble-region row whose SSR content and
+ * the effect's mount-time recomputation are both derived from the exact
+ * same source data, so they cannot disagree. It is false in general: any
+ * markup slot whose value comes from client-only state that the server
+ * cannot see — `createSignal(readFromLocalStorage())`, a client-side region
+ * swap adopting HTML the server rendered from a different default — can
+ * genuinely differ from the SSR/CSR content on the very first write, and
+ * skipping that first write would silently leave the stale SSR default on
+ * screen until the NEXT change (regression pin: site/ui's
+ * `admin-gallery.spec.ts` cross-page time-range persistence test). So every
+ * write unconditionally applies unless deduped by value/identity — never
+ * because it happens to be the first one — for every 'markup' caller,
+ * including the preamble-region case (which only loses a same-value
+ * redundant-patch skip on mount, not correctness).
+ */
+/**
+ * A slot's compile-time descriptor. `path` is the list of child indices
+ * from the claim root to the slot's ANCHOR NODE — in Step A that anchor is
+ * always the existing `<!--bf:sN-->` start comment (markers are still
+ * emitted; Step B may point paths at other node kinds), so resolution
+ * walks `childNodes` by index with no assumption about the target's
+ * `nodeType` until the kind-specific claim inspects it. `id` is kept for
+ * diagnostics and as the marker-scan fallback's search key.
+ */
+export interface SlotSpec {
+    id: string;
+    kind: 'text' | 'markup';
+    path: readonly number[];
+    /**
+     * Slot unification Step B (`spec/slot-unification.md` §3(b), §5 Step B):
+     * true when NO `<!--bf:id-->…<!--/-->` marker was emitted for this slot at
+     * all — `path` is then a path to the slot's POSITION itself (the LAST
+     * index is this slot's own index within its parent's `childNodes`, not an
+     * anchor comment to search from). Only ever set for `kind: 'text'` — a
+     * `'markup'` slot always keeps its markers (an empty-able range needs a
+     * physical anchor to splice into; see `spec/slot-unification.md` §3(b)
+     * case (ii)). Resolution CREATES a Text node at that position if SSR
+     * rendered the slot empty (nothing to adopt there yet) — see `claimOne`.
+     * The compiler emits this only when it has already proven the position
+     * safe (`client-only-elision.ts`); the runtime never re-derives it.
+     */
+    markerless?: boolean;
+}
+export type ClaimPlan = readonly SlotSpec[];
+/**
+ * The result of claiming a plan: a write door keyed by slot id. Writing an
+ * id that failed to claim (or was never in the plan) warns and no-ops —
+ * one bad/missing slot never breaks any other slot's writes.
+ */
+export interface ClaimedSlots {
+    write(id: string, value: unknown): void;
+}
+/**
+ * A claimed plan that can be read as well as written. Separate from
+ * {@link ClaimedSlots} because a door is allocated PER ROW: giving every
+ * claim a reader costs an extra closure on every row of a list, read or not
+ * (measured: ~40KB/1k rows). Only the loops that need read-compare-write
+ * seeding (`spec/slot-unification.md` §9.3(1)) ask for this shape. Both
+ * shapes sit on the SAME claim (`claimRefs`) — this is a second accessor
+ * bundle, never a second way to resolve a position (§2's claim-once rule).
+ */
+export interface ClaimedSlotsRW extends ClaimedSlots {
+    /**
+     * Current DOM text of a 'text' slot. `''` when the slot rendered empty,
+     * `null` when the slot cannot answer (not a 'text' slot, or it failed to
+     * claim); `null` MUST be treated by the caller as "differs, write it".
+     */
+    read(id: string): string | null;
+}
+/** `lazySlots`'s per-write function — the same shape `ClaimedSlots.write` has. */
+export type SlotWriter = (id: string, value: unknown) => void;
+/**
+ * Pass a live Node through untouched; coerce anything else with `String`.
+ *
+ * The 'text' door's counterpart to {@link escapeTextOrNode}. A 'text' slot
+ * writes through `nodeValue`, which needs no escaping — routing it through
+ * `escapeText` would double-escape — but it DOES need the Node case
+ * separated out, because a Text node cannot host an element and
+ * `String(node)` destroys it: `[object HTMLDivElement]` in a browser, the
+ * serialized markup rendered as visible text under some DOM shims. Wrong
+ * either way, and silently so, which is why the split lives here rather
+ * than at each call site.
+ *
+ * A Node reaches a content slot whenever a child-position interpolation
+ * calls something that builds one — `props.renderRow(item)` handed an
+ * inline-JSX arrow, which the compiler lifts into a component whose call
+ * returns a real element. Whether such a call returns a string or a Node is
+ * not decidable from the expression's syntax (both are `CallExpression`), so
+ * the decision belongs at runtime, on the value.
+ *
+ * `String(value)`, not `String(value ?? '')`: a non-Node value must coerce
+ * exactly as the previous inline `String(...)` emission did. The nullish
+ * collapse stays where it already was, in {@link writeText}.
+ */
+export declare function textOrNode(value: unknown): string | Node;
+/**
+ * Claim every slot in `plan` against `root` NOW. Escape hatch for callers
+ * that cannot honor the row-pristine invariant `lazySlots` relies on
+ * (streaming/portal paths that may mutate row content before any write
+ * would naturally occur, per §6) — claim eagerly there instead.
+ */
+export declare function claimSlots(root: Element, plan: ClaimPlan): ClaimedSlots;
+/**
+ * Lazy wrapper honoring the row-pristine invariant (§3(a)): nothing touches
+ * `root`'s DOM until the first write, and that first write claims the
+ * WHOLE plan at once — so no earlier write into a sibling slot can shift
+ * this row's still-unclaimed paths first. A row that never updates never
+ * pays for a claim at all.
+ */
+export declare function lazySlots(root: Element, plan: ClaimPlan): SlotWriter;
+/**
+ * The read-capable twin of `lazySlots`: the same deferred claim, exposed as
+ * the full `{ write, read }` door instead of a bare write function.
+ *
+ * Two entry points rather than one door with a `.read` property because the
+ * door is allocated PER ROW: attaching a reader to every writer costs the
+ * extra closures on every row in the list, whether or not it ever reads
+ * (measured: +84KB/1k rows). Loops that need read-compare-write seeding
+ * (`spec/slot-unification.md` §9.3(1)) pay for the reader; every other loop
+ * keeps the single-closure writer. There is still exactly ONE claim
+ * mechanism underneath — every entry point resolves through `claimRefs`,
+ * and the first access of either kind resolves the whole plan while the row
+ * is pristine (§2's claim-once rule; reads never open a second resolution
+ * path).
+ */
+export declare function lazyClaimSlots(root: Element, plan: ClaimPlan): ClaimedSlotsRW;
+//# sourceMappingURL=claim-slots.d.ts.map

package/dist/runtime/claim-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-slots.d.ts","sourceRoot":"","sources":["../../src/runtime/claim-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AAMH;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;IACvB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,MAAM,SAAS,GAAG,SAAS,QAAQ,EAAE,CAAA;AAgD3C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAe,SAAQ,YAAY;IAClD;;;;OAIG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAChC;AAED,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;AAwN7D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAGxD;AA8HD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,YAAY,CAGvE;AAYD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAMpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,cAAc,CAO7E"}

package/dist/runtime/component.d.ts

@@ -2,10 +2,16 @@
  * BarefootJS - Component Creation
  *
  * Functions for dynamically creating component instances at runtime.
- * Used by reconcileList() when rendering components in loops.
+ * Used by mapArray()/mapArrayAnchored() when rendering components in loops.
  */
 import type { ComponentDef } from './types.ts';
 export declare function setParentScopeId(id: string | null): void;
+/** Where `mapArray` wants a fresh loop row connected before its `init` runs. */
+export type RowMountPoint = {
+    container: Node;
+    anchor: Node | null;
+};
+export declare function setRowMountPoint(p: RowMountPoint | null): RowMountPoint | null;
 /**
  * Create a component instance with DOM element and initialized state.
  *
@@ -19,6 +25,10 @@ export declare function setParentScopeId(id: string | null): void;
  * @param name - Component name (e.g., 'TodoItem')
  * @param props - Props to pass to the component
  * @param key - Optional key for list reconciliation
+ * @param slot - Slot-relationship markers stamped as `bf-h` / `bf-m`
+ * @param mountAt - Placeholder this component replaces. When given, the
+ *   element is connected to the document *before* `init` runs — see
+ *   "Connect before init" below.
  * @returns Created DOM element
  *
  * @example
@@ -43,17 +53,7 @@ export interface CreateComponentSlotInfo {
     /** Slot id in the host (this child's `bf-m` value). */
     mount: string;
 }
-export declare function createComponent(nameOrDef: string | ComponentDef, props?: Record<string, unknown>, key?: string | number, slot?: CreateComponentSlotInfo): HTMLElement;
-/**
- * Get the props stored for a component element.
- * Used by reconcileList to pass props to an existing element.
- */
-export declare function getComponentProps(element: HTMLElement): Record<string, unknown> | undefined;
-/**
- * Get the props update function for an element.
- * Used by reconcileList to update props when reusing an element.
- */
-export declare function getPropsUpdateFn(element: HTMLElement): ((props: Record<string, unknown>) => void) | undefined;
+export declare function createComponent(nameOrDef: string | ComponentDef, props?: Record<string, unknown>, key?: string | number, slot?: CreateComponentSlotInfo, mountAt?: Element | null): HTMLElement;
 /**
  * Render a child component's template to an HTML string.
  * Used by compiler-generated template functions when a stateless component
@@ -105,14 +105,36 @@ export declare function escapeAttr(value: unknown): string;
  *
  * A nullish value renders as empty text — the JSX/Solid semantics the Hono
  * SSR reference follows (`{undefined}` / `{null}` produce no text), and
- * what the reactive text-update path already does (`dynamic-text.ts` and
- * `client-marker.ts` both `String(value ?? '')`). Only this initial-render
- * escape site used to stringify `undefined` / `null` into literal
- * "undefined" / "null" text, so a bare `{props.x}` on an absent prop
- * diverged from SSR at first paint (#2137). Non-nullish values (including
- * `0` and `false`) keep their `String()` form, matching the reactive path.
+ * what the reactive text-update path already does (`claim-slots.ts`'s
+ * `writeText`/`writeMarkup` and `dynamic-text.ts` all `String(value ?? '')`).
+ * Only this initial-render escape site used to stringify `undefined` /
+ * `null` into literal "undefined" / "null" text, so a bare `{props.x}` on
+ * an absent prop diverged from SSR at first paint (#2137). Non-nullish
+ * values (including `0` and `false`) keep their `String()` form, matching
+ * the reactive path.
  */
 export declare function escapeText(value: unknown): string;
+/**
+ * `escapeText`'s counterpart for a claimed 'markup' slot's REACTIVE write
+ * (slot unification A3 follow-up), where the value is a plain-JS expression
+ * that may resolve to either a string or a live `Node` (e.g. `{cond &&
+ * logo(id)}`, a hoisted `renderNode` callback, #1213). `writeMarkup`
+ * (`claim-slots.ts`) inserts a string via `<template>.innerHTML =`, which —
+ * unlike the old `__bfText`'s plain `Text.nodeValue =` assignment — DOES
+ * interpret HTML, so a raw un-escaped string is an injection/corruption
+ * risk exactly where the initial SSR/CSR TEMPLATE already calls
+ * `escapeText` on the same expression (`html-template.ts`'s
+ * `escapeTextSlotExpr`). A live `Node`, by contrast, must pass through
+ * untouched — `escapeText(node)` would stringify it to garbage, and
+ * `writeMarkup`'s own `instanceof Node` check needs the real object to
+ * splice in by identity. This is the single call every "dynamic JSX/text
+ * slot, value may be a Node" emission site (`emit-reactive.ts`,
+ * `stringify/loop-child-arm.ts`, `stringify/insert.ts`) wraps the value in
+ * before handing it to a 'markup' writer — NOT the preamble-region case
+ * (`stringify/loop.ts`), whose value is already-built HTML from a nested
+ * compiled render and must stay unescaped.
+ */
+export declare function escapeTextOrNode(value: unknown): string | Node;
 /**
  * Parse an HTML string into a DocumentFragment, safely escaping ">" in
  * attribute values. All code that sets innerHTML on dynamic HTML should

package/dist/runtime/component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/runtime/component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAS9C,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAExD;AAWD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;GAGG;AACH;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,GAAG,YAAY,EAChC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACnC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,IAAI,CAAC,EAAE,uBAAuB,GAC7B,WAAW,CAgLb;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAE3F;AAuBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAE7G;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAiDR;AA+DD;;;;;GAKG;AACH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOjD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGjD;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,gBAAgB,CAcjF"}
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/runtime/component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAS9C,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAExD;AAED,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CAAA;CAAE,CAAA;AAsBpE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,aAAa,GAAG,IAAI,CAI9E;AAQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;;;GAGG;AACH;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,GAAG,YAAY,EAChC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACnC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,IAAI,CAAC,EAAE,uBAAuB,EAC9B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,GACvB,WAAW,CAcb;AA2ND;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAiDR;AA+DD;;;;;GAKG;AACH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGjD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAG9D;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,gBAAgB,CAcjF"}

package/dist/runtime/dynamic-text.d.ts

@@ -1,7 +1,30 @@
 /**
  * Dynamic text/JSX slot updater (#1663).
  *
- * The compiler wraps reactive child expressions (`<div>{expr}</div>`) in a
+ * Slot unification A3 (`spec/slot-unification.md` §5-A3) replaced every
+ * OTHER `__bfText` call site with a claimed 'markup' slot writer
+ * (`claim-slots.ts`'s `writeMarkup` provides the identical Node/text
+ * contract). ONE emission site still calls `__bfText` directly and is
+ * deliberately deferred: `emitDynamicTextUpdates`'s `conditionalElems`
+ * path (`ir-to-client-js/emit-reactive.ts`) — a dynamic text/JSX
+ * expression nested inside a top-level (non-loop) conditional, tracked by
+ * an effect OUTSIDE the conditional's own `insert()` `bindEvents`. That
+ * effect re-resolves its anchor via `$t(__scope, slotId)` on EVERY run
+ * because `insert()` may swap the branch independently of this effect's own
+ * reruns — a cached `lazySlots` claim would go stale across such a swap, and
+ * a 'markup' slot's dedup `last` state can't safely survive being re-claimed
+ * fresh every run either: a fresh claim's `last` always starts `undefined`,
+ * so re-claiming per-run would throw away the dedup skip on every single
+ * run (every write would re-clear-and-reparse even when the value hasn't
+ * changed) — unlike the 'text'-kind conditional cases elsewhere in the
+ * compiler, which have no such state to go stale and so DO re-claim fresh
+ * each run safely. Moving this one case onto the claim-plan model needs the
+ * slot's claim door tied to the branch's OWN activation lifecycle instead of
+ * this separate effect's — real architectural work, not a mechanical swap —
+ * so it stays on `$t`/`__bfText` for now.
+ *
+ * The mechanism itself, for the reader who lands here from that one site:
+ * the compiler wraps reactive child expressions (`<div>{expr}</div>`) in a
  * `createEffect` that writes the value into the text node sitting between
  * the slot's `<!--bf:sX-->` / `<!--/-->` comment markers. That was a pure
  * `nodeValue = String(value)` assignment, which is correct for primitives

package/dist/runtime/dynamic-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-text.d.ts","sourceRoot":"","sources":["../../src/runtime/dynamic-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAsCH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAoD1E"}
+{"version":3,"file":"dynamic-text.d.ts","sourceRoot":"","sources":["../../src/runtime/dynamic-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAsCH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAoD1E"}

package/dist/runtime/index.d.ts

@@ -8,14 +8,14 @@ export { queryHref, type QueryParams, type QueryParamValue } from '../query-href
 export { formatDate } from '../format-date.ts';
 export { createContext, useContext, provideContext, setCurrentScope, type Context, } from './context.ts';
 export { createPortal, isSSRPortal, findSiblingSlot, cleanupPortalPlaceholder, type Portal, type PortalOptions, type Renderable, type PortalChildren, } from './portal.ts';
-export { reconcileList, type RenderItemFn } from './list.ts';
-export { reconcileElements, getLoopChildren, getLoopNodes } from './reconcile-elements.ts';
+export { getLoopChildren, getLoopNodes } from './loop-markers.ts';
 export { qsaItem, upsertChildItem } from './qsa-item.ts';
 export { mapArray, mapArrayAnchored } from './map-array.ts';
+export { mapArrayLazy, type LazyRowEntry, type LazyRowPlan } from './map-array-lazy.ts';
 export { patchLeaf } from './patch-leaf.ts';
-export { patchSlotRange } from './patch-slot-range.ts';
+export { claimSlots, lazySlots, lazyClaimSlots, textOrNode, type SlotSpec, type ClaimPlan, type ClaimedSlots, type ClaimedSlotsRW, type SlotWriter } from './claim-slots.ts';
 export { registerTemplate, getTemplate, hasTemplate, type TemplateFn } from './template.ts';
-export { createComponent, renderChild, getPropsUpdateFn, getComponentProps, parseHTML, escapeAttr, escapeText, } from './component.ts';
+export { createComponent, renderChild, parseHTML, escapeAttr, escapeText, escapeTextOrNode, } from './component.ts';
 export { applyRestAttrs } from './apply-rest-attrs.ts';
 export { spreadAttrs } from './spread-attrs.ts';
 export { styleToCss } from './style.ts';
@@ -26,7 +26,6 @@ export { registerComponent, getComponentInit, initChild, upsertChild } from './r
 export { insert, type BranchConfig, type BranchTemplateResult } from './insert.ts';
 export { __bfSlot } from './branch-slot.ts';
 export { __bfText } from './dynamic-text.ts';
-export { updateClientMarker } from './client-marker.ts';
 export { hydratedScopes } from './hydration-state.ts';
 export { render } from './render.ts';
 export { __bf_swap, setupStreaming } from './streaming.ts';

package/dist/runtime/index.d.ts.map

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