@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/observe/store/store.js

@@ -0,0 +1,2127 @@
+import { attrHooks } from "../core/attribution-hooks.js";
+
+import { CONFIG_MANUAL_WRITE, CONFIG_OVERRIDE, CONFIG_HELD, $REFRESH, NOT_PENDING, STATUS_PENDING, STATUS_ERROR, EFFECT_RENDER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_STAGED_READ, CONFIG_VERDICT, CONFIG_CHILDREN_FORBIDDEN, STATUS_UNINITIALIZED, CONFIG_PROMOTED, REACTIVE_DIRTY, REACTIVE_CHECK } from "../core/constants.js";
+
+import { writeHook, setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead, tracking } from "../core/core.js";
+
+import { registerGraph } from "../core/dev.js";
+
+import { signalHook } from "../core/identities.js";
+
+import { link, setSlotUnobserved } from "../core/graph.js";
+
+import { getOwner, getObserver } from "../core/owner.js";
+
+import { insertIntoHeap } from "../core/heap.js";
+
+import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, resolveTx, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
+
+import { lookupTarget, storeOwners, setLookup, $OWNER, isOwned, markDescendants } from "./target.js";
+
+import { optHooks, affectsHooks } from "./hooks.js";
+
+import { $TARGET, rawValuesUsed, isRawValue, isWrappable, markRawIngest, writeOverride, markRawOne, $RECORD, $PROXY, $TRACK, installShallowView } from "./types.js";
+
+export { markRaw } from "./types.js";
+
+/**
+ * Store — plain stores on L2 (plan sec. 31, S1).
+ *
+ * A store is a tree of L2 nodes and nothing else carries reactive state:
+ *
+ * - **Leaf nodes** (one per tracked-or-written key, lazy; `slotSignal`, one
+ *   literal): `_value` committed, `_pendingValue` this batch's staging.
+ * - **Presence nodes** (`in` tracks presence, not value — R13) and the
+ *   **deep witness** (`deep()` subscribes one node per record).
+ * - The **container node** `k` (plan sec. 31.3, Q-A): the `$TRACK` node given a
+ *   value. `_value` is the committed backing, `_pendingValue` the pending
+ *   backing the draft mutates — so a write to a key nobody reads has a
+ *   staging home the scheduler owns, and park/commit/revert of the backing
+ *   is the hold model's, not a fold ledger of the store's. Structural
+ *   readers (`ownKeys`, iteration, `$TRACK`, `length`, `deep`) subscribe to
+ *   it; value readers never do — a key with no leaf reads through the
+ *   container's visible backing without subscribing (R1: node existence is
+ *   unobservable).
+ *
+ * The committed backing (`t.v`) is owned raw (CoW: a user object is shared
+ * until the first write privatizes it and its ancestor chain). It mutates at
+ * exactly one moment — the flush's commit (`_storeCommit`), after the
+ * container node committed its staging. Reads: context-free readers see the
+ * committed backing until the flush; a pass sees the staging (signal
+ * parity, RUL-1); the draft reads its own staging.
+ *
+ * Perf contracts (plan sec. 31.4): lazy nodes; one literal per node; O(written) per
+ * setter (`wk`); overlay drafts for large plain records; no new named
+ * fields on array targets; zero allocation for adopted-but-unread objects.
+ */
+/** Key of the deep-witness slot node (never a user key). */ const $DEEP = Symbol(0);
+
+// ---------------------------------------------------------------------------
+// wrap / dedupe
+/** Pre-shaped constructor for OBJECT proxy targets: V8 tips a bare `{}` into
+ * dictionary mode once ~19 named properties are assigned onto it (the #3044
+ * `ovl`/`del` fields crossed that line — every trap's field read became a
+ * hash lookup, a 15% deep-dbmon tick regression). Declaring every field in a
+ * constructor pre-allocates in-object slots so the map stays fast, with
+ * headroom for future fields. The prototype is reset to `Object.prototype`
+ * so proxy-forwarded semantics (getPrototypeOf, constructor) are exactly a
+ * plain object's. Array targets keep the bare-`[]` path — they must carry
+ * the array exotic class for `Array.isArray(proxy)`.
+ *
+ * ARRAY SHAPE RULE: arrays normalize their named properties to dictionary
+ * mode as the count grows (V8 13.x: counts ≡ 0 mod 3 from 18 up), so the
+ * target's named field count is capped at 20 — any future write-side state
+ * beyond `wk` must ride an extension object (see target.ts), never new
+ * named fields here. */ function TargetShape() {
+    this.v = undefined;
+    this.ch = undefined;
+    this.pb = undefined;
+    this.n = undefined;
+    this.h = undefined;
+    this.k = undefined;
+    this.dk = undefined;
+    this.u = undefined;
+    this.pk = undefined;
+    this.px = undefined;
+    this.d = undefined;
+    this.a = undefined;
+    this.sc = undefined;
+    this.kc = undefined;
+    this.nc = undefined;
+    this.fam = undefined;
+    this.s = undefined;
+    this.ovl = undefined;
+    this.del = undefined;
+    this.wk = undefined;
+}
+
+TargetShape.prototype = Object.prototype;
+
+function createTarget(e, t, n, r = t?.fam ?? null) {
+    // The proxy target carries the array exotic class when the value is an
+    // array, so Array.isArray(proxy) is true; the fields live on it directly.
+    // Direct field assignment in one fixed order (no Object.assign literal
+    // copy): every target shares a hidden-class transition chain — createTarget
+    // was the #2 store cost in the uibench creation profile.
+    const o = Array.isArray(e) ? [] : new TargetShape;
+    o.v = e;
+    // Chained-backing flag (backing IS another store's proxy, §7b) — cached so
+    // the hot read path never does a per-read symbol lookup on the backing.
+        o.ch = e[$TARGET] !== undefined;
+    o.pb = null;
+    o.n = null;
+    o.h = null;
+    o.k = null;
+    o.dk = null;
+    o.wk = null;
+    o.u = t;
+    o.pk = n;
+    o.px = null;
+    o.d = false;
+    o.a = false;
+    o.sc = 0;
+    o.kc = 0;
+    o.nc = 0;
+    o.fam = r;
+    o.s = false;
+    o.ovl = false;
+    o.del = null;
+    o.px = new Proxy(o, traps);
+    setLookup(e, o);
+    return o;
+}
+
+function wrap(e, t = null, n = null, r = t?.fam ?? null) {
+    // markRaw'd values never wrap through ANY store (R42; sticky raw-marking
+    // is one half of the never-both-wrapped-and-raw invariant, RUL-12).
+    if (rawValuesUsed && isRawValue(e)) return e;
+    const o = lookupTarget(e, r);
+    if (o !== undefined) return o.px;
+    const i = e[$TARGET];
+    if (i?.px === e) {
+        // Foreign-family proxies re-wrap into THIS family (writes stay isolated);
+        // same-family and plain-store proxies pass through.
+        if (r === null || i.fam === r) return e;
+        return createTarget(e, t, n, r).px;
+    }
+    return createTarget(e, t, n, r).px;
+}
+
+/** Unwrap our own proxies to their current backing; leave everything else.
+ * A projection draft wrapper is registered as its target's alias
+ * (projection.ts `wrapDraft`) — adopted as a backing, it would forward to
+ * itself (#3767). */ function unwrapValue(e) {
+    if (e == null || typeof e !== "object") return e;
+    const t = e[$TARGET];
+    if (t !== undefined && (t.px === e || lookupTarget(e, t.fam) === t) && t.v !== undefined) {
+        // A draft escaping into other storage must be a REAL container that
+        // becomes this target's committed backing at fold (the shared-raw
+        // contract) — a prototype overlay is neither.
+        if (t.ovl) materializePB(t);
+        return t.pb ?? t.v;
+    }
+    return e;
+}
+
+// ---------------------------------------------------------------------------
+// nodes: pure subscription points (values used only for equality gating)
+// Shared slot-node equality (create-floor diet): ONE function for every
+// leaf — `this` is the node (method-call convention at every _equals site),
+// `_host` is the baked-in target backref. Logical-slot equality: values
+// resolving to the same child target are the same slot (privatization/
+// adoption swap raw identity without changing the logical value — only
+// changed leaves notify, R9).
+const slotNodeEquals = function(e, t) {
+    return isEqual(e, t) || sameLogicalSlot(this.O, e, t);
+};
+
+/** The deep witness: the store decides when it notifies. */ const never = false;
+
+function sameKey(e, t) {
+    return e === t || e !== e && t !== t;
+}
+
+/** The container node's arrangement guess: the rows (or keys) the setter
+ * left the container with, in order. Its comparator judges a landing or a
+ * revert against it by row identity — by key when the family has one
+ * (the server's object for a guessed row is the same row). */ class LaneView {
+    rows;
+    base;
+    removed;
+    constructor(e, 
+    /** The backing the guess is shown over: the committed one at the
+     * guess, the composed arrangement after a re-base (optimistic.ts). */
+    t, 
+    /** Keys the setter REMOVED from the view it saw (a deliberate delete,
+     * not a row the truth has yet to show): a re-base does not restore
+     * them. `null` when none. */
+    n = null) {
+        this.rows = e;
+        this.base = t;
+        this.removed = n;
+    }
+}
+
+/** A container node's value as a backing: the base an arrangement guess is
+ * shown over, else the value itself. */ function asBacking(e) {
+    return e instanceof LaneView ? e.base : e;
+}
+
+/** The container node's comparator: a staging is a backing (identity — a
+ * pending backing is never "equal" to the committed one); a lane value is
+ * an arrangement (`LaneView`), judged by the optimistic machinery. */ const containerEquals = function(e, t) {
+    return e === t || !!optHooks?.arrangement(this.O, e, t);
+};
+
+function sameLogicalSlot(e, t, n) {
+    if (t === null || typeof t !== "object" || n === null || typeof n !== "object") return false;
+    const r = lookupTarget(t, e.fam);
+    return r !== undefined && r === lookupTarget(n, e.fam);
+}
+
+/** Slot nodes whose last subscriber left while they still held a staging:
+ * released at the commit that resolves it (`drainFolds`). */ const deferredReleases = new Set;
+
+function releaseSlot(e) {
+    const t = e.O;
+    const n = e.gt;
+    if (n === $TRACK) {
+        if (t.k === e) t.k = null;
+    } else if (n === $DEEP) {
+        if (t.dk === e) t.dk = null;
+    } else if (t.n?.[n] === e) {
+        delete t.n[n];
+        t.nc--;
+    } else if (t.h?.[n] === e) delete t.h[n];
+    // The family's index keeps only targets that still carry a node.
+        if (t.fam !== null && t.nc === 0 && t.k === null && t.dk === null && (t.h === null || Reflect.ownKeys(t.h).length === 0)) t.fam.live.delete(t);
+}
+
+/** A node was born on `target`: a family target enters the live index. */ function noteNode(e, t, n) {
+    if (e.fam !== null) e.fam.live.add(e);
+    markDescendants(e);
+    if (affectsHooks !== null) affectsHooks.ro(e, t, n);
+}
+
+// Shared slot-node release handler: registered once; the core sweep
+// dispatches CONFIG_SLOT_NODE nodes here (graph.ts) instead of holding a
+// per-node closure in a per-node NodeExtension. A dropped node is
+// unreachable through the store — a fresh read makes a fresh node.
+// A staged write — or a lane's value (a guess, S4) — is state only the node
+// holds: its release waits for the commit that resolves it. So does a leaf of
+// a held container (#4146): a mainline write it carried is in the held
+// staging too, where it would read as the hold's until the landing.
+const slotKept = e => e.ue !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
+
+setSlotUnobserved(e => {
+    if (slotKept(e)) deferredReleases.add(e); else releaseSlot(e);
+});
+
+/** A node born while its container has a staging is born from the two
+ * frames (A29): committed from the committed backing, the staging from the
+ * pending one — and held by the container's transaction when the container
+ * is held (#3706: the unit of the hold is the key — a key the batch left
+ * unchanged stages nothing and holds no one). */ function bornStaged(e, t, n, r) {
+    if (t.je && t.je(t.le, n)) return;
+    queuePendingNode(t);
+    t.ue = n;
+    const o = e.k;
+    if (o === null) return;
+ // a node-less staging holds nothing (`stageOn`)
+    // Held by the container's transaction only for a key the HELD staging
+    // changed — a mainline layer's change above it stages mainline. (A
+    // container carrying a guess is a lane's: the flush's park decides —
+    // unless a correction folded under the guess, D-34: the key is that
+    // correction's hold's.)
+        if (o.l & CONFIG_HELD && heldKeyChanged(e, r)) {
+        const e = txOf(o);
+        if (!(o.l & CONFIG_OVERRIDE) || e.folded) holdNode(t, resolveTx(e._parent ?? e));
+    }
+    // A28 (4): a batch written inside a creation-time pass is promoted — its
+    // late-materialized leaf with it.
+        if (o.l & CONFIG_PROMOTED) notePromotedWrite(t);
+}
+
+function getNode(e, t, 
+// First-read dedupe (create-floor slice 2): the get trap probes
+// accessor-ness right before creating the node — pass the verdict through
+// so creation skips the second descriptor scan. -1 = unknown (other
+// callers), 0/1 = probed.
+n = -1) {
+    const r = e.n ??= Object.create(null);
+    let o = r[t];
+    if (o === undefined) {
+        // Accessor-ness resolved ONCE per node (no per-object descriptor scan
+        // on reads): accessor keys serve through Reflect.get with the proxy
+        // receiver.
+        const i = e.pb;
+        const l = o = slotSignal(committed(e)[t], slotNodeEquals, e, t, n === -1 ? isOwnAccessor(i ?? e.v, t) : n === 1);
+        if (i !== null && !l.acc) bornStaged(e, l, e.del?.has(t) ? undefined : i[t], t);
+        // Attribution-only: name store property nodes by path segment so
+        // attribution chains and wide-scope warnings read "store.todos" (or
+        // "todos.title" when the store was declared with a name), not
+        // "signal". Gated on the engine being installed — node creation is
+        // the hottest store path, and the disabled cost must stay one null
+        // check (nodes created before enable() stay generically named).
+                if (attrHooks !== null) {
+            const n = storeRoot(e);
+            l._name = (storeNames.get(n) ?? "store") + "." + String(t);
+            l._loc = storeLocs.get(n);
+            stampNodeOwner(l, e);
+        }
+        r[t] = o;
+        e.nc++;
+        noteNode(e, l, t);
+    }
+    return o;
+}
+
+function getHasNode(e, t) {
+    const n = e.h ??= Object.create(null);
+    let r = n[t];
+    if (r === undefined) {
+        const o = r = slotSignal(t in committed(e), isEqual, e, t, false);
+        const i = e.pb;
+        if (i !== null) bornStaged(e, o, t in i && !e.del?.has(t), t);
+        if (attrHooks !== null) stampNodeOwner(o, e);
+        n[t] = r;
+        noteNode(e, o, t);
+    }
+    return r;
+}
+
+/** The container node (plan sec. 31.3): created by the first structural subscription
+ * or the first write that needs to stage. Its committed value is the
+ * committed backing. */ function getContainerNode(e) {
+    let t = e.k;
+    if (t === null) {
+        t = e.k = slotSignal(e.v, containerEquals, e, $TRACK, false);
+        if (attrHooks !== null) stampNodeOwner(t, e);
+        noteNode(e, t, $TRACK);
+        // Born while a batch is staged without a node (`stageOn`): the node
+        // takes the staging as its own — the pre-batch backing committed, the
+        // pending backing staged — so whoever asked for it reads the frame it
+        // would have read had the node been there from the write.
+                if (e.pb !== null && !directCommit) {
+            t.le = preBatch(e);
+            t.ue = e.pb;
+            queuePendingNode(t);
+        }
+    }
+    return t;
+}
+
+/** Q-A's escape hatch (plan sec. 33; measured plan sec. 41.4): a staging needs the container
+ * node as its home only when something can read the frame through it — a
+ * structural subscriber (the node exists), lane work (the staging is the
+ * lane's), a pass outside a flush (its write is promoted at the pass's end,
+ * A28 (4)), or a derive a transaction holds (the staging is the derive's,
+ * `holdWithDerive`). Otherwise the backing and the fold queue are the whole
+ * staging: nothing allocates, nothing is swept at the commit (dbmon's tick
+ * re-created, queued, swept and dropped ~7000 container nodes). If the
+ * flush parks, the seam materializes and holds the node then
+ * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, t) {
+    if (e.k === null && passLane === null && (context === null || globalQueue.Y) && !deriveHolds(e)) return;
+    const n = getContainerNode(e);
+    if (n.ue === NOT_PENDING) queuePendingNode(n);
+    n.ue = t;
+    // A28 (4): a write issued inside a pass outside a flush (a creation-time
+    // derive) is promoted at the pass's end — the batch with it.
+        if (context !== null) notePromotedWrite(n);
+    if (e.fam !== null) holdWithDerive(e, n);
+}
+
+/** The projection's derive is held by a transaction and this is its own
+ * write (not a user setter's): the staging is the derive's (`holdWithDerive`). */ function deriveHolds(e) {
+    const t = e.fam?.node;
+    return t != null && !userWrite && (t.l & CONFIG_HELD) !== 0;
+}
+
+const storePark = e => {
+    for (let t = 0; t < foldList.length; t++) {
+        const n = foldList[t];
+        if (n.k === null && n.pb !== null) holdNode(getContainerNode(n), e);
+    }
+    optHooks?.park(e);
+};
+
+function getDeepNode(e) {
+    let t = e.dk;
+    if (t === null) {
+        t = e.dk = slotSignal(0, never, e, $DEEP, false);
+        if (attrHooks !== null) stampNodeOwner(t, e);
+        noteNode(e, t, $DEEP);
+    }
+    return t;
+}
+
+function bumpDeep(e) {
+    if (e.dk !== null) setSignal(e.dk, 1);
+}
+
+/** The structural readers' one notification: a membership/arrangement
+ * change on the container (the staging is already on the node; `setSignal`
+ * re-stages the same backing and walks the subscribers — and, on later
+ * steps, routes a held or lane-owned container the way any node is). */ function notifyContainer(e, t) {
+    // A container carrying an arrangement guess takes the write as a landing
+    // on the guess (`laneWrite` → `supersede`, judged by `containerEquals`);
+    // otherwise the structural readers are walked (the staging is already on
+    // the node; the comparator is the store's, done).
+    if (e.l & CONFIG_OVERRIDE) setSignal(e, t); else {
+        if (e.l & CONFIG_HELD) joinFuture(txOf(e));
+        if (snapshotCaptureActive) captureWriteSnapshot(e, e.le);
+        insertSubs(e);
+        schedule();
+    }
+}
+
+// Observe-tier labels and owners (attribution).
+function storeRoot(e) {
+    let t = e;
+    while (t.u !== null) t = t.u;
+    return t;
+}
+
+function storeRootOwner(e) {
+    return storeOwners.get(storeRoot(e));
+}
+
+function stampNodeOwner(e, t) {
+    e.H = storeRootOwner(t) ?? null;
+}
+
+const storeNames = new WeakMap;
+
+// The store's `loc` option, carried onto every property node beside its
+// label (the same gate: nodes created before the engine is installed carry
+// neither).
+const storeLocs = new WeakMap;
+
+function nameStore(e, t, n) {
+    if (attrHooks !== null) {
+        const r = e[$TARGET];
+        if (t) storeNames.set(r, t);
+        if (n) storeLocs.set(r, n);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// clones (CoW privatization)
+const hasOwn = Object.prototype.hasOwnProperty;
+
+const lookupGetter = Object.prototype.__lookupGetter__;
+
+const lookupSetter = Object.prototype.__lookupSetter__;
+
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function isOwnAccessor(e, t) {
+    return hasOwn.call(e, t) && (lookupGetter.call(e, t) !== undefined || lookupSetter.call(e, t) !== undefined);
+}
+
+/** Shallow clone into store ownership. Plain data (grade 2) spreads; anything
+ * else copies descriptors (accessors kept, everything made configurable). */ function cloneRaw(e, t) {
+    t.sc || scanAccessorsOnce(t);
+    if (t.sc === 2) {
+        const n = {
+            ...e
+        };
+        n[$OWNER] = t;
+        return n;
+    }
+    // A plain array with no accessors and no named keys beyond `length`
+    // (`kc` counts own keys) clones by `slice()`: the descriptor path
+    // allocates one descriptor per element, O(n) per first draft write (10k
+    // rows: ~10 ms per push).
+        let n;
+    if (!t.a && t.kc <= e.length + 1 && Object.getPrototypeOf(e) === Array.prototype) n = e.slice(); else {
+        const r = Object.getOwnPropertyDescriptors(e);
+        for (const n of Reflect.ownKeys(r)) {
+            const o = r[n];
+            if (n === "length" && Array.isArray(e)) continue;
+            o.configurable = true;
+            if (!o.get && !o.set) o.writable = true; else t.a = true;
+        }
+        n = Array.isArray(e) ? Object.defineProperties([], r) : Object.create(Object.getPrototypeOf(e), r);
+    }
+    n[$OWNER] = t;
+    return n;
+}
+
+/** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, t) {
+    const n = Object.create(null);
+    for (const t of Reflect.ownKeys(e)) n[t] = e[t];
+    Object.setPrototypeOf(n, Object.prototype);
+    n[$OWNER] = t;
+    return n;
+}
+
+function copyOwn(e, t, n) {
+    const r = Object.getOwnPropertyDescriptor(t, n);
+    if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, n, r); else e[n] = r.value;
+}
+
+/** One descriptor scan per container (grade 1/2, `a`, `kc`). */ function scanAccessorsOnce(e) {
+    const t = e.v;
+    const n = Reflect.ownKeys(t);
+    let r = Object.getPrototypeOf(t) === Object.prototype;
+    for (const o of n) {
+        if (isOwnAccessor(t, o)) {
+            e.a = true;
+            r = false;
+            break;
+        }
+        if (r && !propertyIsEnumerable.call(t, o)) r = false;
+    }
+    e.sc = r ? 2 : 1;
+    e.kc = n.length;
+    return !e.a;
+}
+
+// ---------------------------------------------------------------------------
+// the pending backing
+const OVERLAY_MIN_KEYS = 32;
+
+const OVERLAY_REBUILD_MAX_KEYS = 1024;
+
+const OVERLAY_REBUILD_MIN_ADDS = 16;
+
+const WK_ALL = new Set;
+
+const plainProto = e => {
+    const t = Object.getPrototypeOf(e);
+    return t === Object.prototype || t === Array.prototype || t === null;
+};
+
+/** An overlay with many adds (or any delete) rebuilds the committed
+ * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, t) {
+    if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
+    if (e.del?.size) return true;
+    const n = e.wk;
+    if (n !== null && n !== WK_ALL && n.u === undefined && n.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    const r = e.v;
+    let o = 0;
+    for (const e of Reflect.ownKeys(t)) if (!hasOwn.call(r, e) && ++o > OVERLAY_REBUILD_MIN_ADDS) return true;
+    return false;
+}
+
+/** Downgrade an overlay to a real clone (a consumer needs a container). */ function materializePB(e) {
+    const t = e.pb;
+    if (!e.ovl) return t;
+    const n = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), t);
+    e.pb = n;
+    // The staging IS the pending backing: re-point the container node.
+        if (e.k?.ue === t) e.k.ue = n;
+    return n;
+}
+
+/** The batch's pending backing, created on the first draft write: an overlay
+ * of an owned plain-data record above the key threshold, a clone otherwise.
+ * Staged on the container node (the scheduler owns its lifetime) and queued
+ * for the fold at the flush's commit. */ function ensurePB(e) {
+    let t = e.pb;
+    // An optimistic edit composes on the view the user saw and becomes
+    // guesses at the setter's exit: nothing is staged, nothing folds
+    // (optimistic.ts).
+        if (optHooks && userWrite && e.fam?.opt === true && !pendingNotify.has(e)) return e.pb = optHooks.draft(e);
+    if (t !== null && !isOwned(t)) {
+        // An adopted object awaiting its fold is the user's: the draft writes a
+        // clone of it. The clone is the batch's staging — unless the adoption is
+        // HELD (another transaction's): then the held staging stays the
+        // adoption and the draft is a mainline layer above it (#3612/#3688: a
+        // mainline setter mid-hold publishes mainline; the held keys stay held).
+        t = e.pb = cloneRaw(t, e);
+        const n = e.k;
+        if (n !== null && !(n.l & CONFIG_HELD)) n.ue = t;
+    } else if (t === null) {
+        const n = e.v;
+        if (!directCommit) queueFold(e);
+        if (!e.ch && !Array.isArray(n) && (e.sc !== 0 ? !e.a : scanAccessorsOnce(e)) && e.kc > OVERLAY_MIN_KEYS && isOwned(n)) {
+            t = e.pb = Object.create(n);
+            e.ovl = true;
+        } else t = e.pb = cloneRaw(n, e);
+        if (!directCommit) stageOn(e, t);
+    }
+    return t;
+}
+
+/** Privatize `target`'s committed backing (and its ancestor chain — a shared
+ * parent cannot point at an owned child). Not a reactive event. */ function privatizeCommitted(e) {
+    if (isOwned(e.v)) return;
+    const t = e.v;
+    const n = cloneRaw(t, e);
+    // Mid-batch (a staging is open on this target) the fold still sees the
+    // backing the batch started from: the queue recorded it (`foldOlds`).
+        e.v = n;
+    e.ch = false;
+    if (e.u) {
+        privatizeCommitted(e.u);
+        const n = e.u.v;
+        const r = parentSlotKey(e, t);
+        if (n[r] === t) n[r] = e.v;
+    }
+}
+
+/** The key this target sits under in its parent — re-resolved by identity
+ * when an array parent moved it (#3282). Not searched when the slot already
+ * holds this target's backing (a parent adopted whole carries its children's
+ * new raws before the children fold — the miss was O(rows) per changed row
+ * of a keyed reconcile). */ function parentSlotKey(e, t) {
+    const n = e.pk;
+    const r = e.u.v;
+    if (r[n] === t || r[n] === e.v || !Array.isArray(r)) return n;
+    const o = r.indexOf(t);
+    if (o === -1) return n;
+    e.pk = o;
+    return o;
+}
+
+/** Overlay flatten (#3044): own keys onto the owned committed backing in
+ * place — the backing keeps its identity. */ function flattenOverlay(e, t) {
+    privatizeCommitted(e);
+    overlayOnto(e, e.v, t);
+ // the caller (`foldTarget`) closes the staging
+}
+
+/** An overlay's own keys and deletions onto `to` (the two are disjoint: a
+ * write un-deletes its key); the overlay is closed. */ function overlayOnto(e, t, n) {
+    for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
+    if (e.del !== null) {
+        for (const n of e.del) delete t[n];
+        e.kc -= e.del.size;
+        e.del = null;
+    }
+    e.ovl = false;
+    return t;
+}
+
+/** Adoption (a setter's returned replacement; reconcile and projection
+ * landings in S3): the incoming object becomes the backing by reference at
+ * the fold — no clones, no user-object mutation, ownership resets to
+ * shared. It is the container's staging until then (signal parity: a
+ * handler reads the committed frame until the flush; a hold keeps it
+ * staged with the rest). The nodes are told now, diffed against the view
+ * they were LAST told (#3296): the draft's pending backing when one
+ * preceded the adoption this batch — its node writes were real, and the
+ * adoption's re-stage cancels or confirms each — else the committed
+ * backing. */ function adoptPB(e, t, n = true) {
+    if (!directCommit) queueFold(e);
+    let r;
+    if (e.pb !== null) {
+        if (e.ovl) materializePB(e);
+        r = e.pb;
+    } else r = e.v;
+    if (directCommit) {
+        e.pb = null;
+        if (e.k !== null) e.k.le = t;
+    } else {
+        // Eager (INTERNALS §3): the backing swaps now — handlers read the
+        // adopted object before the flush — while the container node, when
+        // there is one (`stageOn`), keeps the committed frame (`_value`) for
+        // readers a hold keeps on it, and stages the adoption for the fold's
+        // path copy.
+        e.pb = t;
+        stageOn(e, t);
+    }
+    e.v = t;
+    e.ch = t[$TARGET] !== undefined;
+    e.ovl = false;
+    e.del = null;
+    e.sc = 0;
+    e.a = false;
+    e.wk = null;
+ // adoption supersedes staged trap writes
+        const o = t[$OWNER];
+    if (o?.fam === e.fam) t[$OWNER] = e; else setLookup(t, e);
+    if (n && r !== t) notifyFold(e, r, t);
+}
+
+// ---------------------------------------------------------------------------
+// the fold: owned raw's one mutation point, at the flush's commit
+/** The fold queue: the targets with a batch open (`pb !== null` IS the
+ * membership — a target is queued exactly while it carries a staging; the
+ * drain skips one already folded), in two reusable arrays. Nothing here
+ * allocates per batch once warm: a dbmon tick queues ~7000 containers, and
+ * a map built and drained per tick cost ~540 KB of table allocation — most
+ * of the tick's young-generation GC, and the whole of its gap to `next`
+ * (plan sec. 41.5).
+ *
+ * Beside each target, its PRE-BATCH committed backing — `t.v` as the batch
+ * opened on it (`foldOlds`, parallel to `foldList`). That one record is the
+ * fold's base in every case: a draft's backing does not move until the fold
+ * (so the record is `t.v` still), an adoption swaps it eagerly (the record
+ * is the frame committed readers keep), a mid-batch privatization or a
+ * draft over an adopted raw moves it again (the record is what the batch
+ * started from, which is all the fold wants to know). The record lives
+ * exactly as long as the batch: a weak map keyed by target kept every
+ * container's LAST adopted-away backing alive until its next adoption —
+ * for a keyed reconcile, the whole previous tree promoted out of the
+ * nursery every tick (the saturated listened-paths shape ran 15–25% over
+ * the fork, all of it this; plan sec. 43.2) — and for a store adopted
+ * once, for its lifetime.
+ *
+ * The target carries no slot for its record (ARRAY SHAPE RULE, target.ts),
+ * so a lookup by target (`preBatch`: a container node born onto an open
+ * staging, a committed-frame read of a node-less staging, a park) indexes
+ * the list through a map built on first use per batch — the drain itself
+ * walks the two lists in step and never builds it. */ let foldList = [];
+
+let foldOlds = [];
+
+let foldSpare = [];
+
+let foldOldsSpare = [];
+
+let foldIndex = null;
+
+/** Before the staging is set and before an adoption swaps the backing. */ function queueFold(e) {
+    if (e.pb !== null) return;
+    schedule();
+    if (foldIndex !== null) foldIndex.set(e, foldList.length);
+    foldList.push(e);
+    foldOlds.push(e.v);
+}
+
+/** The committed backing before this batch (valid while `pb !== null`). */ function preBatch(e) {
+    if (foldIndex === null) {
+        foldIndex = new Map;
+        for (let e = 0; e < foldList.length; e++) foldIndex.set(foldList[e], e);
+    }
+    const t = foldIndex.get(e);
+    return t === undefined ? e.v : foldOlds[t];
+}
+
+/** The flush committed its pending nodes: fold every pending backing whose
+ * container node committed (its staging is gone — `_value` is the backing
+ * now) into the committed home; one a later step holds (its node still
+ * staged) waits for the flush that commits it. Then the deferred slot
+ * releases. */ function drainFolds() {
+    if (foldList.length !== 0) {
+        const e = foldList;
+        const t = foldOlds;
+        foldList = foldSpare;
+        foldOlds = foldOldsSpare;
+        foldSpare = e;
+        foldOldsSpare = t;
+        foldIndex = null;
+        for (let n = 0; n < e.length; n++) {
+            const r = e[n];
+            if (r.pb === null) continue;
+ // folded already (a direct commit)
+                        const o = r.k;
+            if (o !== null && o.ue !== NOT_PENDING) {
+                // held: commits with its hold
+                foldList.push(r);
+                foldOlds.push(t[n]);
+            } else foldTarget(r, t[n]);
+        }
+        e.length = 0;
+        t.length = 0;
+    }
+    if (deferredReleases.size !== 0) {
+        for (const e of deferredReleases) {
+            if (e.o === null && !slotKept(e)) {
+                deferredReleases.delete(e);
+                releaseSlot(e);
+            }
+        }
+    }
+}
+
+/** Core asks: is a slot node's truth in flight? Its family's derive is —
+ * lanes (A17, #2864: a guess mid-refetch stands in for the flight) and
+ * marks (an ambient `affects()` over a declared reload lives to the
+ * landing) read it. */ GlobalQueue.k = e => {
+    const t = e.O?.fam;
+    return (t?.node?.m & STATUS_PENDING) !== 0;
+};
+
+/** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
+ * A chained link's committed value is the inner store's at the last
+ * read-through — refreshed here, since a guess served the reads since
+ * (#3672: the revert compares against the base's live value). */ GlobalQueue.an = e => {
+    const t = e.O;
+    if (t.ch) {
+        const n = e.gt;
+        const r = t.v;
+        if (t.h?.[n] === e) e.le = untrack(() => n in r); else if (t.n?.[n] === e) e.le = untrack(() => unwrapValue(r[n]));
+    }
+    return e.le;
+};
+
+installStoreHooks(storePark, () => {
+    drainFolds();
+    optHooks?.sweep();
+});
+
+/** The store half of `affects()` (store/affects.ts) makes its marks' nodes
+ * and walks records through these: it never imports the engine. */ GlobalQueue.so = getNode;
+
+GlobalQueue.fo = isWrappable;
+
+/** A projection's creation run commits directly (a memo's first value is
+ * its `_value`, not a staging): the draft still writes a clone of the seed,
+ * nothing is staged on the nodes, and the setter's exit folds the touched
+ * containers at once. Only the synchronous first run. */ let directCommit = false;
+
+function runDirect(e) {
+    const t = directCommit;
+    directCommit = true;
+    try {
+        e();
+    } finally {
+        directCommit = t;
+    }
+}
+
+/** Fold one target's pending backing into its committed home. */ function foldTarget(e, t) {
+    {
+        {
+            const n = e.k;
+            const r = e.pb;
+            if (r !== null) {
+                if (r === e.v) ; else if (e.ovl && (e.v !== t || !overlayRebuilds(e, r) && n?.T?.st !== t)) {
+                    // Overlay flatten (#3044): the backing keeps its identity, so the
+                    // `t.v === old` gate below skips path copying (the parent slot
+                    // already points here) and the adopted-notify (setter
+                    // notifications happened at write time). A backing privatized
+                    // mid-batch is a fresh clone the parent already points at.
+                    flattenOverlay(e, r);
+                } else if (e.v !== t) {
+                    // Privatized mid-batch (a child's path copy repointed us): the
+                    // owned backing takes the written keys.
+                    privatizeCommitted(e);
+                    const n = e.v;
+                    const o = e.wk;
+                    if (o !== null && o !== WK_ALL) {
+                        for (let e = o; e !== undefined; e = e.u) for (const t of e) {
+                            if (hasOwn.call(r, t)) copyOwn(n, r, t); else delete n[t];
+                        }
+                    } else {
+                        for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) copyOwn(n, r, e);
+                        for (const e of Reflect.ownKeys(t)) {
+                            if (e !== $OWNER && !hasOwn.call(r, e)) delete n[e];
+                        }
+                    }
+                } else {
+                    // The clone (or adopted object) becomes the committed backing
+                    // (path copy below).
+                    e.v = e.ovl ? materializePB(e) : r;
+                    e.ch = e.v[$TARGET] !== undefined;
+                }
+                e.pb = null;
+                e.wk = null;
+ // the written-keys window closes with the commit
+                        }
+            if (n !== null) {
+                // The node's committed value is the backing. A container nobody
+                // subscribes to was a transient staging home (INTERNALS §5: an
+                // observer-less write holds a transient record until the fold,
+                // discarded with it) — gone with the batch.
+                if (n.o === null) e.k = null; else if (n.le instanceof LaneView) n.le.base = e.v; else n.le = e.v;
+            }
+            if (e.v !== t && e.u) {
+                const n = parentSlotKey(e, t);
+                if (e.u.v[n] === t) {
+                    privatizeCommitted(e.u);
+                    e.u.v[n] = e.v;
+                }
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// write-time notification (setter exit)
+/** Devtools and attribution: the containers a setter replaced wholesale. */ function storePathOf(e) {
+    let t = "";
+    for (let n = e; n !== null; n = n.u) t = n.pk === null ? "store" + t : "." + String(n.pk) + t;
+    return t;
+}
+
+const REPLACED_CENSUS_MAX = 64;
+
+function sameLeaf(e, t) {
+    if (e === t) return true;
+    if (e === null || t === null || typeof e !== "object" || typeof t !== "object") return false;
+    return unwrapValue(e) === unwrapValue(t) || targetsEqual(e, t);
+}
+
+function reportReplacedContainers(e, t, n, r) {
+    const o = r ?? Reflect.ownKeys(n);
+    const i = Array.isArray(n);
+    const l = storeRootOwner(e);
+    // Items the array held before the write: an index that now holds one of
+    // them was moved into place (an in-place splice / shift), not replaced.
+        let u = null;
+    for (const r of o) {
+        if (i && r === "length" || r === $OWNER) continue;
+        if (e.del?.has(r)) continue;
+        const o = unwrapValue(t[r]);
+        const f = unwrapValue(n[r]);
+        if (o === null || f === null || typeof o !== "object" || typeof f !== "object" || o === f || targetsEqual(o, f)) continue;
+        if (i) {
+            if (u === null) {
+                u = new Set;
+                for (const e of t) u.add(unwrapValue(e));
+            }
+            if (u.has(f)) continue;
+        }
+        const s = Array.isArray(f);
+        if (s !== Array.isArray(o)) continue;
+        let a;
+        let c = 0;
+        if (s) {
+            a = f.length;
+            if (a > REPLACED_CENSUS_MAX) continue;
+            const e = new Set;
+            for (const t of o) e.add(unwrapValue(t));
+            for (const t of f) if (e.has(unwrapValue(t))) c++;
+        } else {
+            const e = Object.keys(f);
+            a = e.length;
+            if (a > REPLACED_CENSUS_MAX) continue;
+            for (const t of e) if (sameLeaf(o[t], f[t])) c++;
+        }
+        attrHooks.storeReplaced(storePathOf(e) + "." + String(r), s, a, c, s ? o.length : Object.keys(o).length, l);
+    }
+}
+
+/** A user setter wrote a key whose staging is a derivation another
+ * transaction holds (A34 (3), #3612): the hold re-derives over the write. */ let heldDerivationHit = false;
+
+/** The open setter is a USER'S (`storeSetter(…, guard = true)`), not the
+ * derive's draft or landing. */ let userWrite = false;
+
+/** Is the open setter a user's? (reconcile.ts: a user's reconcile on an
+ * optimistic family writes the draft.) */ function userWriting() {
+    return userWrite;
+}
+
+function heldDerivation(e, t, n) {
+    if (e.fam === null || !userWrite) return false;
+    if (t !== undefined) return (t.l & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(t) !== flushTransaction;
+    const r = e.k;
+    return r !== null && (r.l & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, n);
+}
+
+/** Setter exit: one node write per changed observed key (the leaves stage
+ * like signals — holds and lanes engage here on later steps), presence and
+ * deep witnesses, and the container when membership changed. */ function notifyWrites(e) {
+    let t = e.pb;
+    if (t === null) return;
+    // Optimistic channel: a user's writes on an optimistic family become
+    // guesses on the nodes (lanes); the draft is discarded, the committed
+    // backing never touched.
+        if (optHooks && e.fam?.opt === true) {
+        if (userWrite) {
+            // The draft is discarded first: the diff reads the target (its nodes
+            // are born from the committed frame, not the draft).
+            e.pb = null;
+            e.wk = null;
+            e.pb = optHooks.writes(e, t);
+            return;
+        }
+        // The derive's draft: new rows under guessed rows are paired with them
+        // first (D-34, #4329).
+                optHooks.pair(e, t);
+    }
+    const n = e.v;
+    const r = e.n;
+    // Written-keys bound: trap writes record their keys, so the notify visits
+    // O(written) nodes instead of every subscription on the record (a selection
+    // map with thousands of per-key subscribers pays two visits per select,
+    // not a full scan). Falls back to the full node scan when the bound can't
+    // hold: no trap granularity (wk null), an array length write (WK_ALL —
+    // implicit index deletes), accessors on the record (t.a — a getter node's
+    // value can change when ANY key is written), or a non-plain prototype
+    // (class instances: prototype getters derive from arbitrary fields).
+    // Overlay pbs chain to the COMMITTED object (#3044) — plainness is the
+    // committed container's prototype, not the overlay's. THIS setter's keys
+    // only (D-8, #3743): a key an earlier setter of the batch wrote and this
+    // one did not is no second proposal — its node was told then, and telling
+    // a held node its unchanged value again would join this tick to the hold.
+        const o = e.wk;
+    const i = o === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : t) ? null : o;
+    if (attrHooks !== null) reportReplacedContainers(e, n, t, i);
+    if (e.fam !== null && !heldDerivationHit && i !== null) for (const t of i) if (heldDerivation(e, r?.[t], t)) {
+        heldDerivationHit = true;
+        break;
+    }
+    if (r !== null) {
+        const o = i ?? Reflect.ownKeys(r);
+        for (const i of o) {
+            const o = r[i];
+            if (o === undefined) continue;
+            if (o.acc === true || hasOwn.call(t, i) && lookupGetter.call(t, i) !== undefined) {
+                // Accessor keys: the node is linked for shape-change notification,
+                // its value is never served (the getter runs with the proxy
+                // receiver on read) — FORCE wakes the readers. A data descriptor
+                // falls through so the cleared-acc hot read serves it (#3949);
+                // an own getter's descriptor has no `value`, so the compare below
+                // would otherwise keep the getter's result (or FORCE) for `undefined`.
+                o.acc = isOwnAccessor(t, i);
+                const e = Object.getOwnPropertyDescriptor(n, i);
+                const r = Object.getOwnPropertyDescriptor(t, i);
+                if (!r || r.get || r.set) {
+                    if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(o, () => FORCE);
+                    continue;
+                }
+                if (e?.get || e?.set || !isEqual(e?.value, r.value)) setSignal(o, () => r.value);
+                continue;
+            }
+            const l = e.del?.has(i) ? undefined : t[i];
+            setSignal(o, () => l);
+            if (e.fam !== null) {
+                // The derive's write is a derivation; a user setter's is a proposal
+                // (A34 (3)'s discriminator).
+                if (!userWrite) {
+                    o.l &= ~CONFIG_MANUAL_WRITE;
+                    holdWithDerive(e, o);
+                } else o.l |= CONFIG_MANUAL_WRITE;
+            }
+        }
+    }
+    const l = e.h;
+    if (l !== null) {
+        const n = i ?? Reflect.ownKeys(l);
+        for (const r of n) {
+            const n = l[r];
+            if (n !== undefined) {
+                setSignal(n, r in t && !e.del?.has(r));
+                if (e.fam !== null) holdWithDerive(e, n);
+            }
+        }
+    }
+    if (e.dk !== null) {
+        if (e.del?.size) bumpDeep(e); else for (const r of i ?? Reflect.ownKeys(t)) {
+            if (r === $OWNER) continue;
+            const o = t[r];
+            const i = n[r];
+            if (o !== null && typeof o === "object" ? !targetsEqual(i, o) : !isEqual(i, o)) {
+                bumpDeep(e);
+                break;
+            }
+        }
+    }
+    // The container: structural readers hear membership/arrangement changes
+    // only (R9) — the compare is the store's, against the committed frame. A
+    // container carrying an arrangement guess is told whether or not anyone
+    // subscribes: the write is a landing on the guess (`notifyContainer`).
+        const u = e.k;
+    if (u !== null && (u.o !== null || u.l & CONFIG_OVERRIDE)) {
+        let r;
+        if (e.ovl) {
+            r = !!e.del?.size;
+            if (!r) {
+                for (const e of Reflect.ownKeys(t)) {
+                    if (!hasOwn.call(n, e)) {
+                        r = true;
+                        break;
+                    }
+                }
+            }
+        } else {
+            r = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
+        }
+        if (r) notifyContainer(u, t);
+    }
+}
+
+/** Accessor-node wake sentinel: readers re-run and re-invoke the getter. */ const FORCE = Symbol();
+
+/** Two raws that wrap to the same target are the same logical value. */ function targetsEqual(e, t) {
+    if (e === null || typeof e !== "object" || t === null || typeof t !== "object") return false;
+    const n = lookupTarget(e, null);
+    return n !== undefined && n === lookupTarget(t, null);
+}
+
+/** Positional identity IS content for arrays (R15). */ function arrayStructureChanged(e, t) {
+    if (e.length !== t.length) return true;
+    for (let n = 0; n < t.length; n++) {
+        const r = e[n];
+        const o = t[n];
+        if (!isEqual(r, o) && !targetsEqual(r, o)) return true;
+    }
+    return false;
+}
+
+function membershipChanged(e, t) {
+    const n = Reflect.ownKeys(t);
+    if (Reflect.ownKeys(e).length - +isOwned(e) !== n.length - +isOwned(t)) return true;
+    for (const t of n) if (t !== $OWNER && !(t in e)) return true;
+    return false;
+}
+
+/** One leaf's notification for an adoption diff (descriptor-aware). */ function notifyKeyDiff(e, t, n, r, o = true) {
+    if (e.acc === true || o && hasOwn.call(r, t) && lookupGetter.call(r, t) !== undefined) {
+        e.acc = isOwnAccessor(r, t);
+        const o = Object.getOwnPropertyDescriptor(n, t);
+        const i = Object.getOwnPropertyDescriptor(r, t);
+        // Data descriptors fall through, as in notifyWrites (#3949).
+                if (!i || i.get || i.set) {
+            if (o?.get !== i?.get || o?.set !== i?.set || o?.value !== i?.value) setSignal(e, () => FORCE);
+            return;
+        }
+        const l = o?.value;
+        const u = i?.value;
+        if (o?.get || o?.set || !isEqual(l, u) && !targetsEqual(l, u)) setSignal(e, typeof u === "function" ? () => u : u);
+    } else {
+        const o = n[t];
+        const i = r[t];
+        // A live chained `old` (a store proxy, §7b) already reads the inner
+        // store's next frame, not what the node was last told: written, the
+        // node's own equality judging it (#4361).
+                if (n[$TARGET] || !isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
+    }
+}
+
+function hasAccessorFlag(e) {
+    return e.acc === true;
+}
+
+/** One leaf's notification when the caller already has both values. */ function notifyKeyValue(e, t, n, r, o, i) {
+    if (e.acc === true) {
+        notifyKeyDiff(e, t, o, i, false);
+        return;
+    }
+    if (!isEqual(n, r) && !targetsEqual(n, r)) setSignal(e, typeof r === "function" ? () => r : r);
+}
+
+/** The structural half of an adoption's notifications (reconcile does the
+ * leaves itself): presence by `in`, the container by membership. Presence
+ * is DIFFED `old` → `neu` like the leaves (#3743): a presence node is
+ * written only where `in` changed between the view it was last told
+ * (#3296) and the adoption — `setSignal` joins a held node's transaction
+ * before its equality gate (A34 (1)), so repeating an unchanged absence to
+ * a node an action holds would make the whole tick the action's (an
+ * unrelated `a.value` stayed stale until the action settled). A real
+ * change still writes, and on a held node still proposes. A live chained
+ * `old` (a store proxy, §7b) reflects the inner store, not what the node
+ * was last told — written unconditionally, as before; its container too
+ * (#4361).
+ *
+ * The container is told of an arrangement change when it has structural
+ * subscribers OR carries an arrangement guess (S4): for a guessed
+ * container the write is the landing that judges the guess (Q-D, plan
+ * sec. 39 — confirm, supersede, or hold beneath), not a subscriber
+ * notification, and a landing whose truth changed no guessed key's value
+ * or presence (a newer question's rows beneath an optimistic push) still
+ * answers the arrangement — before, only the presence write reached the
+ * lane, by accident of being unconditional. */ function notifyFoldTail(e, t, n) {
+    const r = e.h;
+    const o = t[$TARGET];
+    if (r !== null) {
+        for (const e of Reflect.ownKeys(r)) if (o || e in t !== e in n) setSignal(r[e], e in n);
+    }
+    const i = e.k;
+    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
+        const e = o || (Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n));
+        if (e) notifyContainer(i, n);
+    }
+}
+
+/** An adoption's notifications: every node of the target, diffed `old` →
+ * `neu` (value nodes by key, presence by `in`, the container by
+ * membership, the deep witness by identity). */ function notifyFold(e, t, n) {
+    if (e.dk !== null && t !== n) bumpDeep(e);
+    const r = e.n;
+    if (r !== null) {
+        for (const e of Reflect.ownKeys(r)) notifyKeyDiff(r[e], e, t, n);
+    }
+    notifyFoldTail(e, t, n);
+}
+
+// ---------------------------------------------------------------------------
+// visibility
+let writing = 0;
+
+/** Roots of the stores with an open setter: reads of THEIR drafts are the
+ * writer's (no tracking, pending backing served); every other store reads
+ * normally — a derive's external reads are its dependencies (#3037). */ let writeScopes = null;
+
+const pendingNotify = new Set;
+
+function scopeKey(e) {
+    if (e.fam !== null) return e.fam;
+    let t = e;
+    while (t.u !== null) t = t.u;
+    return t;
+}
+
+function inDraft(e) {
+    return writeScopes !== null && writeScopes.has(scopeKey(e));
+}
+
+/** Shallow store: values served verbatim (a nested store proxy still wraps
+ * into the family so writes stay isolated). */ function serveShallow(e, t, n) {
+    if (n !== null && typeof n === "object" && n[$TARGET] !== undefined) return draftServe(e, wrap(n, e, t));
+    return n;
+}
+
+/** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, t) {
+    if (writeScopes !== null && inDraft(e)) {
+        const e = t?.[$TARGET];
+        if (e?.v !== undefined) writeScopes.add(scopeKey(e));
+    }
+    return t;
+}
+
+/** The committed backing: the container node's committed value while a
+ * batch is staged on it (an adoption swaps `t.v` eagerly — INTERNALS §3,
+ * "adoption is eager by contract" — and the node keeps the frame committed
+ * readers under a hold still see), `t.v` otherwise. */ function committed(e) {
+    const t = e.k;
+    if (t !== null) return t.ue !== NOT_PENDING ? asBacking(t.le) : e.v;
+    // A node-less staging (`stageOn`): the fold queue remembers the frame.
+        return e.pb !== null ? preBatch(e) : e.v;
+}
+
+/** The pass that sees this flush's staging (signal parity — `read()`'s
+ * staged arm): the computation running (`context`, never the owner — a
+ * handler, an effect callback or `onSettled` has an owner but no pass),
+ * unless it is a frame reader (children-forbidden, A32). Null = the
+ * committed frame. */ function stagingReader() {
+    let e = context;
+    if (e === null) return null;
+    if (e.Pt) e = e.Ht ?? null;
+    return e === null || e.l & CONFIG_CHILDREN_FORBIDDEN ? null : e;
+}
+
+/** The backing a read serves (RUL-1, signal parity): the draft and the write
+ * override read the pending backing; a tracked reader reads it too — only
+ * for presence and descriptors, its leaf (born from the two frames) decides
+ * the value through core; a context-free or frame reader the committed
+ * backing; a pass reading UNTRACKED asks the container node — `read()`
+ * without a link: the node's value is the backing, chosen by the hold rules
+ * (a render effect outside the parking flush sees committed and re-derives
+ * at the landing; a memo joins the future; a staging is marked read). */
+/** The backing a read of `target` is served from — the truth (committed,
+ * or the staging a pass may see). An optimistic family's lane values are
+ * NOT composed here: a guessed key always has its node, and the node is
+ * what serves its value (`nodeValue`); presence and enumeration compose
+ * per key / per walk (`optimisticHas`, `enumerationSource`). */ function readSource(e, t, n = false) {
+    // An optimistic setter's read before its first write sees what the writer
+    // sees — the lanes' values and the tick's own guesses over the truth
+    // (#3665), never a staging awaiting its fold: the draft is born on the
+    // read (and notified at the setter's exit like any).
+    if (userWrite && e.fam?.opt === true && !pendingNotify.has(e) && inDraft(e)) {
+        const t = ensurePB(e);
+        pendingNotify.add(e);
+        return t;
+    }
+    const r = e.pb;
+    if (r === null) return e.v;
+    if (inDraft(e) || writeOverride) {
+        // The derive reads its own store through its draft: a key (or the
+        // container) a transaction holds — a user's write inside an action,
+        // held with it — is the future, and the pass that reads it derives
+        // from the future (L2: a read of something already held joins it): the
+        // derive's whole result reveals with the action (core R31 / #3733:
+        // "under the transaction and revealed with it"), not key by key. A
+        // user's setter reading its draft is no pass and joins nothing here.
+        if (writeOverride && !userWrite) {
+            const n = t !== undefined ? e.n?.[t] : undefined;
+            if (n !== undefined) {
+                if ((n.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(n));
+            } else {
+                const n = e.k;
+                if (n !== null && (n.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (t === undefined || heldKeyChanged(e, t))) joinPassTx(txOf(n));
+            }
+        }
+        return r;
+    }
+    const o = e.k;
+    // A key whose leaf carries a lane's value (a guess, S4): the leaf serves
+    // it — the container's frame is not consulted (a reader is not made a
+    // stale reader of the container's hold for a key it does not see through
+    // it).
+        if (t !== undefined) {
+        const n = e.n?.[t];
+        if (n?.l & CONFIG_OVERRIDE) return committed(e);
+    }
+    const i = o !== null && (o.l & CONFIG_HELD) !== 0;
+    // A held container: the hold's unit is the key (#3706). A key the HELD
+    // staging left unchanged reads the ambient view — a mainline layer's
+    // write above the hold publishes mainline (#3688, #3612); a key it
+    // changed reads the frame core serves this reader.
+        if (i && t !== undefined && !heldKeyChanged(e, t, n)) return r;
+    const l = stagingReader();
+    if (l === null) {
+        if (getObserver() !== null) return r;
+ // a frame reader's leaf decides the value
+        // A projection's writes are its truth as soon as made (the derive is
+        // the authority, nothing it writes is a proposal): a context-free reader
+        // sees them before the flush — unless a hold keeps them staged.
+                if (familyAhead(e)) return r;
+        // A verdict window (`isPending`/`latest`) with no reader (a top-level
+        // probe) judges the container like any node — for a key the batch
+        // changed; an unchanged key is committed and final (A22: pending is per
+        // key). A held container's committed frame is the node's.
+                if (verdict === null || !i && t !== undefined && !keyChanged(e, t, n)) return i ? asBacking(o.le) : e.v;
+        return o === null ? committed(e) : asBacking(read(o));
+    }
+    // A pass reading a key the batch left unchanged: the same value in both
+    // frames — committed, holding no one. Otherwise the container's frame by
+    // core's rules — `read()` of the node WITHOUT a link (a value reader never
+    // subscribes to the container): a render effect outside a hold's flush
+    // sees committed and re-derives at the landing, a memo joins the future,
+    // a staging read is marked. The key's own leaf, when it has one, decides
+    // the value the same way.
+        if (!i) {
+        // A plain pass this flush already served a staging as the screen
+        // (REACTIVE_STAGED_READ — what `read()` would set again here) reads an
+        // unheld staging directly: an unchanged key is the same value in both
+        // frames, a changed one is what the mark already stands for. The
+        // per-key question is asked once per pass, not once per key (a
+        // `mapArray` over 1k shifted rows asked it 1k times).
+        if (l.R & REACTIVE_STAGED_READ && !(l.l & (CONFIG_VERDICT | CONFIG_CHILDREN_FORBIDDEN))) return r;
+        if (t !== undefined && !keyChanged(e, t, n)) return committed(e);
+        // A node-less staging (`stageOn`): what `read()` of its node would do
+        // for this pass — a verdict reader sees the screen, any other derives
+        // from the staging and is marked as having read it.
+                if (o === null) {
+            if (l.l & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
+            stagedRead(l);
+            return r;
+        }
+    }
+    return asBacking(untrack(() => read(o)));
+}
+
+/** Did the HELD staging (the container node's, not a mainline layer above
+ * it) change `key`? */ function heldKeyChanged(e, t, n = true) {
+    return changedBetween(e, e.k.le, e.k.ue, t, n) && !adoptChild(e, t);
+}
+
+/** The values of a held frame, built once per frame: neither the committed
+ * frame nor the held staging changes while the hold stands (a draft writes a
+ * clone), so the set stays true for every first read of the hold. */ const frameRaws = new WeakMap;
+
+function rawsOf(e) {
+    let t = frameRaws.get(e);
+    if (t === undefined) frameRaws.set(e, t = new Set(Object.values(e)));
+    return t;
+}
+
+/** The same row at a slot, as the adoption pairs rows (reconcile.ts): two
+ * objects whose keys agree — positionally for an unkeyed family. */ function sameRow(e, t, n) {
+    return e !== null && typeof e === "object" && t !== null && typeof t === "object" && (n === null || sameKey(n(e), n(t)));
+}
+
+/** A key of a held adoption whose old and new values are the same row that
+ * nothing had proxied when the adoption ran, so `descend` never paired
+ * them: paired now, as it would have been (#3712) — one target, the old
+ * raw its committed frame, the new raw its staging, held by the same
+ * transaction. Both raws resolve to it, so the slot reads as unchanged and
+ * the row's own leaves decide: `id` the same in both frames holds no one,
+ * `version` holds. A record's keys pair by name; an array's by the family's
+ * key — without a family the pairing is not known here and the hold stands. */ function adoptChild(e, t) {
+    const n = e.k;
+    const r = asBacking(n.le);
+    const o = r[t];
+    const i = n.ue[t];
+    const l = Array.isArray(r) ? e.fam?.key : null;
+    if (e.s || l === undefined || !sameRow(o, i, l) || !isWrappable(o) || !isWrappable(i) || Array.isArray(o) !== Array.isArray(i) || lookupTarget(o, e.fam) !== undefined || lookupTarget(i, e.fam) !== undefined || 
+    // A raw in both frames (the same objects swapped or reordered) is its
+    // own row: pairing it with another would alias the two after the commit.
+    rawsOf(r).has(i) || rawsOf(n.ue).has(o)) return false;
+    // A raw-marked value wraps to itself, a proxy to its own target: neither
+    // is a fresh target around `ov`.
+        const u = wrap(o, e, t)[$TARGET];
+    if (u?.v !== o) return false;
+    adoptPB(u, i, false);
+    holdNode(getContainerNode(u), txOf(n));
+    return true;
+}
+
+/** A family target's unheld staging, read with no pass (a handler). */ function familyAhead(e) {
+    return e.fam !== null && context === null && !(e.k?.l & CONFIG_HELD);
+}
+
+/** Did this batch change `key` — value (slot equality), presence, and (for
+ * a `shape` reader — a descriptor read, a node's hold) enumerability or
+ * accessor-ness? A swapped or non-plain prototype, or a chained backing,
+ * changes every key (#3706: those hold the whole container).
+ *
+ * A VALUE read asks without `shape`: a key whose value is the same in both
+ * frames serves the same value from either, whatever its descriptor did —
+ * and the descriptor probes (`__lookupGetter__`, `propertyIsEnumerable`,
+ * twice each) are the cost of the question on a wide container read under
+ * a staging (a keyed reconcile's 1k rows, read by `mapArray` in the flush
+ * that staged them: ~3× the tick). A container with accessors seen (`a`)
+ * keeps the full test — a getter's answer is not a slot's. */ function keyChanged(e, t, n = true) {
+    return changedBetween(e, committed(e), e.pb, t, n);
+}
+
+function changedBetween(e, t, n, r, o) {
+    if (e.ch || n[$TARGET] !== undefined || Object.getPrototypeOf(n) !== Object.getPrototypeOf(t) || !plainProto(t)) return true;
+    if (e.del?.has(r)) return r in t;
+    const i = hasOwn.call(n, r) || e.ovl && hasOwn.call(e.v, r);
+    if (i !== hasOwn.call(t, r)) return true;
+    if (!i) return false;
+    if ((o || e.a) && (isOwnAccessor(t, r) || isOwnAccessor(n, r) || propertyIsEnumerable.call(t, r) !== propertyIsEnumerable.call(n, r))) return true;
+    const l = n[r];
+    const u = t[r];
+    return !isEqual(u, l) && !sameLogicalSlot(e, u, l);
+}
+
+/** Value of a key with a leaf: core's — `read()` links a tracked reader and,
+ * tracked or not, applies the hold and A28 rules a signal's read does. A
+ * projection's unheld staging is ahead for a handler (`familyAhead`), and is
+ * the only value while its derive has never committed: the committed side
+ * is the seed, never observable (A25) — a reader core serves the screen (a
+ * verdict reader, #4355) is served the staging, as for a memo born staged
+ * (core `serve`). */ function nodeValue(e, t, n) {
+    let r;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && n.fam !== null && (context === null || n.fam.node?.m & STATUS_UNINITIALIZED)) {
+        if (context !== null && tracking) link(e, context);
+        r = e.ue;
+    } else r = read(e);
+    return r === FORCE ? t : r;
+}
+
+/** Serve a present data key: link the leaf for a tracked reader (creating it
+ * on first read), wrap a wrappable child through the per-node wrap cache. */ function serveDataKey(e, t, n, r, o, i = -1) {
+    // Read-through (§7b): the inner store's node is the truth; the outer's is
+    // a subscription point only — unless it carries a guess (an optimistic
+    // store over a store: the guess is the outer's, shown over the inner).
+    const l = e.ch && r === e.v;
+    let u = n;
+    // A write-override read (a derive's draft) serves the backing: the derive
+    // composes on the truth, never on a lane's or a hold's frame.
+        if (!inDraft(e) && !writeOverride) {
+        if (o === undefined && getObserver() !== null) o = getNode(e, t, i);
+        if (o !== undefined) {
+            const t = nodeValue(o, n, e);
+            if (l) {
+                // The link's committed value follows the inner store's (what a lane
+                // over it covers — its reveal and revert compare against it, S4).
+                o.le = n;
+                if (o.l & CONFIG_OVERRIDE) u = t;
+            } else u = t;
+        }
+    }
+    if (e.s) return serveShallow(e, t, u);
+    // A derive's draft wrapper answers `$TARGET` without being a proxy: the
+    // inner store's alias (#3767), resolved like a raw (#3859).
+        if (e.ch && !l && u !== null && typeof u === "object" && u[$TARGET]?.px !== u) u = resolveChainedRaw(e, t, u);
+    if (o !== undefined) {
+        if (o.pxv === u && u !== undefined) return draftServe(e, o.px);
+        if (!isWrappable(u)) return u;
+        const n = wrap(u, e, t);
+        o.px = n;
+        o.pxv = u;
+        return draftServe(e, n);
+    }
+    if (!isWrappable(u)) return u;
+    return draftServe(e, wrap(u, e, t));
+}
+
+/** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, t) {
+    for (let n = e.C; n !== null; n = n.G) if (n.S === t) return true;
+    return false;
+}
+
+/** The projection's obligation (plan sec. 31.7 Q-B): before any value is served
+ * through a family target, the derive — the firewall — is brought up to
+ * date WITHOUT the reader subscribing to it. Core's `read()` of the
+ * firewall with no link does all of it: the pull, the status gate
+ * (uninitialized / pending → NotReady, errored → the error; a verdict
+ * window judges it; a pending source registers the reader for the landing)
+ * and the reader's height. The derive's own draft ops are exempt (the write
+ * override): the derive is the author. */ function pullFamily(e) {
+    const t = e.fam.node;
+    if (t === null || writeOverride || inDraft(e)) return;
+    // A settled derive: the pull alone, no link (the barrier). A derive with a
+    // flight up (or errored): the reader observes the flight exactly as a
+    // reader of a memo would — linked, so it re-runs at the landing (the
+    // next settled pass pulls without linking and the stale link trims), a
+    // verdict reader registered, a tracked pass suspended.
+        if (t.m & (STATUS_PENDING | STATUS_ERROR)) {
+        // A render effect outside the flight's own flush is the frame, not a
+        // derivation: it keeps what it shows and learns of the landing from the
+        // leaves the landing changes (unchanged leaves say nothing — it is not a
+        // stale reader of the derive). Inside the flush it suspends like any.
+        // One that already observes the flight (linked by the pass that saw it
+        // go up — the frame's hold, `blocked`) keeps observing it: a re-run for
+        // another reason (a guess it read, the seam) that dropped the link would
+        // release the hold with the flight still up. An errored derive has no
+        // landing to learn of: the error is what the frame shows.
+        const n = context;
+        if (n !== null && n.i === EFFECT_RENDER && !(t.m & STATUS_ERROR) && t.l & CONFIG_HELD && flushTransaction !== txOf(t) && !linkedTo(n, t)) return;
+        // An optimistic family carrying guesses that stand in for the flight
+        // (A17): the guesses are the display — a reader is served the leaves
+        // (committed plus the guesses) and does not suspend on the derive; a
+        // verdict window still asks it (`isPending` is true while the flight is
+        // up). The family's, not the target's: the edit stands in for the one
+        // flight the family has — not over a new question they do not answer
+        // (optimistic.ts `stands`, #4336).
+                if (verdict === null && t.m & STATUS_PENDING && optHooks?.stands(e)) return;
+        read(t);
+    } else untrack(() => read(t));
+}
+
+/** A projection's writes are its derive's: a staging made while the derive
+ * is held (a flight up — its continuation writes after an `await`, a
+ * callback's late write) belongs to the derive's transaction and reveals
+ * with it, never drained early — and answers the derive's question: a quiet
+ * re-ask's landing is quiet through its reveal (A19 exc. 2; the leaf's own
+ * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, t) {
+    const n = e.fam?.node;
+    if (n !== undefined && n !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
+    n.l & CONFIG_HELD && t.ue !== NOT_PENDING && 
+    // A node carrying a guess is the lane's: its staging is the truth beneath
+    // the guess (`setSignal` → `laneWrite`), never re-homed by the store.
+    !(t.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
+        holdNode(t, txOf(n));
+        t.T.ut = n.T.ut;
+    }
+}
+
+/** A chained backing's child (§7b): a raw the inner family owns, or holds
+ * at this key, is served as the inner store's wrapper — never a fresh
+ * raw-keyed one — so the chained targets are the same objects across
+ * settled and pending views. */ function resolveChainedRaw(e, t, n) {
+    const r = e.v[$TARGET];
+    if (r.ch) {
+        const e = resolveChainedRaw(r, t, n);
+        return e === n ? n : wrap(e, r, t);
+    }
+    const o = lookupTarget(n, r.fam);
+    if (o !== undefined) return o.px;
+    if ((r.v[t] === n || r.pb?.[t] === n) && isWrappable(n)) return wrap(n, r, t);
+    return n;
+}
+
+/** The backing a structural read serves: a tracked reader subscribes to the
+ * container and reads the frame core serves it — committed or staging by
+ * the hold rules (`read()` on the node: the node's value IS the backing);
+ * anyone else reads by `readSource`. */ function enumerationSource(e) {
+    if (!inDraft(e) && !writeOverride && getObserver() !== null) {
+        // A container's arrangement guess is not a backing: the view composes
+        // over the base it is shown over.
+        const t = asBacking(read(getContainerNode(e)));
+        return optHooks && e.fam?.opt === true ? optHooks.view(e, t) : t;
+    }
+    const t = readSource(e);
+    return optHooks && optRead(e) ? optHooks.view(e, t) : t;
+}
+
+/** A read on an optimistic family that composes the lanes' values: not the
+ * draft's (it composed already), not a derive's write-override read (the
+ * derive composes on the truth). */ function optRead(e) {
+    return e.fam?.opt === true && !inDraft(e) && !writeOverride;
+}
+
+/** Pollution keys are never served from the prototype (core R30). */ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
+
+// ---------------------------------------------------------------------------
+// traps
+/** A trap write: the target is told at the setter's exit, the key recorded
+ * in this setter's `wk`. A setter's first write to a target still staged by
+ * an earlier setter of the batch opens a set of its own (the notify visits
+ * it, D-8) and chains the earlier one behind for the fold's union. */ function touch(e, t) {
+    let n = e.wk;
+    if (!pendingNotify.has(e)) {
+        pendingNotify.add(e);
+        if (n !== null && n !== WK_ALL) {
+            n = new Set;
+            n.u = e.wk;
+            e.wk = n;
+        }
+    }
+    if (n !== WK_ALL) (e.wk ??= new Set).add(t);
+}
+
+const traps = {
+    get(e, t, n) {
+        // One typeof gates every brand-symbol compare off the hot string path.
+        if (typeof t !== "string") {
+            if (t === $TARGET) return e;
+            if (t === $PROXY) return n;
+            if (t === $OWNER) return undefined;
+ // ownership stamp: never a user key
+                        if (t === $RECORD) return undefined;
+ // a store is no view (see `viewOf`)
+            // refresh()/isPending resolve the projection computed through $REFRESH.
+                        if (t === $REFRESH) return e.fam?.node ?? undefined;
+            if (t === $TRACK) {
+                if (e.fam !== null) pullFamily(e);
+                if (!inDraft(e) && getObserver() !== null) {
+                    read(getContainerNode(e));
+                    // Structural chaining (§7b): a chained backing's $TRACK reads
+                    // through to the INNER store's container — structural
+                    // notifications land on the source's own node.
+                                        const t = readSource(e);
+                    if (t[$TARGET] !== undefined) t[$TRACK];
+                }
+                return undefined;
+            }
+            // user symbols fall through to the generic path
+                }
+        // (The witness before the pull: a mark on an uninitialized derived
+        // store is witnessed, then the pull throws — loading, declared pending.)
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, t);
+        if (e.fam !== null) pullFamily(e);
+        // Hot inline case: existing PLAIN node (non-accessor) read outside any
+        // draft — the dbmon/uibench effect re-read shape. Core's `read()` serves
+        // it (linking a tracked reader; the hold rules either way). Skips
+        // serveDataKey's frame, the FORCE compare (only accessor keys ever hold
+        // the sentinel), and isWrappable for primitives. ONE node-map lookup
+        // serves this block and the accessor probe below. Before the backing is
+        // consulted: a deleted key's node serves `undefined` (notifyWrites), and
+        // a chained target's node carrying a GUESS is the value (A17 — the base
+        // beneath it, and any hold there, is not this reader's concern; a link
+        // without one reads through below).
+                const r = e.n?.[t];
+        if (writeScopes === null && !writeOverride) {
+            const n = r;
+            if (n !== undefined && n.acc !== true && (!e.ch || n.l & CONFIG_OVERRIDE)) {
+                const r = nodeValue(n, undefined, e);
+                if (r === null || typeof r !== "object") return r;
+                if (e.s) return serveShallow(e, t, r);
+                if (n.pxv === r) return n.px;
+                if (isWrappable(r)) {
+                    const o = wrap(r, e, t);
+                    n.px = o;
+                    n.pxv = r;
+                    return o;
+                }
+                return r;
+            }
+        }
+        const o = readSource(e, t);
+        // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
+        // deleted keys are tracked aside and read as absent in the pending view.
+                if (o === e.pb && e.del?.has(t)) {
+            if (!inDraft(e) && getObserver() !== null) read(getNode(e, t));
+            return undefined;
+        }
+        // Accessor keys serve through Reflect.get with the PROXY receiver
+        // (R20/R29: internal reads track; the node is linked for shape-change
+        // notification but its value is never served). Accessor-ness comes from
+        // the node's cached flag; the first TRACKED read (which creates the
+        // node) probes once — untracked node-less reads take the plain path,
+        // where a raw-receiver getter still returns correct committed values.
+        // Tracking suppression is PER-TARGET (inDraft), never global (#3037).
+                let i = -1;
+        {
+            let l;
+            if (r !== undefined) l = r.acc === true; else if (!inDraft(e) && getObserver() !== null) {
+                l = isOwnAccessor(o, t);
+                if (o === (e.pb ?? e.v)) i = l ? 1 : 0;
+            } else l = false;
+            if (l) {
+                if (!inDraft(e) && getObserver() !== null) read(r ?? getNode(e, t, i));
+                const l = Reflect.get(o, t, n);
+                if (e.s) return serveShallow(e, t, l);
+                return isWrappable(l) ? draftServe(e, wrap(l, e, t)) : l;
+            }
+        }
+        // Plain-data fast path: no descriptor allocation per read. Inherited
+        // pollution keys are never served (core R30) — checked before the
+        // proto-function branch can leak `constructor`. Overlay pending backings
+        // chain to the committed backing, so "own in the view" means own on
+        // either layer — a genuine prototype method is one that is own on
+        // NEITHER.
+                const l = e.ovl && o === e.pb;
+        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t))) return undefined;
+        let u = o[t];
+        if (u === undefined ? !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t)) : false) {
+            // Inherited: prototype getters/methods run with the proxy receiver.
+            u = Reflect.get(o, t, n);
+            if (typeof u === "function") return u;
+ // proto methods untracked
+            // Read-through (§7b): the inner store answers an absent key too — the
+            // outer's node is a subscription point unless it carries a guess.
+                        if (e.ch && o === e.v) return serveDataKey(e, t, u, o, r, i);
+            // Reading a currently-absent own key subscribes to it (R12) — for any
+            // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
+                        if (u === undefined && !inDraft(e)) {
+                // (`nodeValue` reads — and links — the node it creates.)
+                if (getObserver() !== null) getNode(e, t, i);
+                const n = e.n?.[t];
+                if (n) {
+                    const r = nodeValue(n, undefined, e);
+                    if (e.s) return serveShallow(e, t, r);
+                    return isWrappable(r) ? draftServe(e, wrap(r, e, t)) : r;
+                }
+            }
+            if (e.s) return serveShallow(e, t, u);
+            return isWrappable(u) ? draftServe(e, wrap(u, e, t)) : u;
+        }
+        if (typeof u === "function" && !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t))) return u;
+ // proto method
+                return serveDataKey(e, t, u, o, r, i);
+    },
+    has(e, t) {
+        if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
+        if (t === $OWNER || t === $RECORD) return false;
+        // (The witness before the pull: a mark on an uninitialized derived
+        // store is witnessed, then the pull throws — loading, declared pending.)
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, t);
+        if (e.fam !== null) pullFamily(e);
+        const n = readSource(e, t);
+        // A tracked reader's presence node answers (born from the two frames;
+        // core decides which it sees); everyone else reads the backing. A
+        // chained target's node is a subscription point (§7b): the inner store
+        // answers through the backing — unless the outer node carries a guess.
+                if (!inDraft(e) && !writeOverride) {
+            if (getObserver() !== null) {
+                const r = getHasNode(e, t);
+                const o = read(r);
+                if (!e.ch || n !== e.v) return !!o;
+                const i = t in n;
+                r.le = i;
+ // the link follows the inner store (S4)
+                                if (r.l & CONFIG_OVERRIDE) return !!o;
+                return i;
+            } else if (optHooks && optRead(e)) {
+                const n = optHooks.has(e, t);
+                if (n !== undefined) return n;
+            }
+        }
+        return t in n && !(n === e.pb && e.del?.has(t));
+    },
+    ownKeys(e) {
+        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, undefined);
+        if (e.fam !== null) pullFamily(e);
+        return visibleKeys(e, enumerationSource(e));
+    },
+    getOwnPropertyDescriptor(e, t) {
+        if (t === $OWNER || t === $RECORD) return undefined;
+        const n = getObserver();
+        if (verdict !== null && affectsHooks !== null && n === null) affectsHooks.io(e, t);
+        if (e.fam !== null) pullFamily(e);
+        // An enumerator (spread, Object.entries) already holds the container
+        // node and reads its frame; a descriptor read on its own tracks
+        // presence (R13).
+                const r = n !== null && !inDraft(e) && !writeOverride;
+        const o = r && observerHoldsContainer(e, n);
+        let i;
+        if (o) i = enumerationSource(e); else if (r) {
+            // The presence node's frame (core decides which) is the one described
+            // (a chained target's inner store answers through the backing, §7b);
+            // the descriptor itself comes from the backing the container's frame
+            // serves this reader (`readSource`: a held container's changed key —
+            // enumerability, accessor-ness — reads committed for a stale reader,
+            // the staging for a member; #3706 contrast).
+            const n = getHasNode(e, t);
+            const r = read(n);
+            i = readSource(e, t, true);
+            if (!r && (!e.ch || n.l & CONFIG_OVERRIDE || !(t in i))) return undefined;
+        } else i = readSource(e, t, true);
+        let l;
+        if (optHooks && !o && optRead(e)) {
+            const n = optHooks.descriptor(e, t);
+            if (n === null) return undefined;
+            l = n;
+        }
+        l ??= visibleDescriptor(e, i, t);
+        if (l === undefined) return undefined;
+        if (!(t === "length" && Array.isArray(e))) l.configurable = true;
+        return l;
+    },
+    set(e, t, n) {
+        const r = inDraft(e);
+        if (!r && !writeOverride) {
+            return true;
+        }
+        if (t === "__proto__") return true;
+ // pollution guard (core R30)
+                const o = e.s ? n : unwrapValue(n);
+        const i = ensurePB(e);
+        // #4146 (R1: node existence is unobservable; #3706: the hold's unit is
+        // the key): a user setter writing a key a HELD container's staging left
+        // unchanged would write it into the held staging — read as the hold's
+        // until its landing, while the same key with a leaf (a live reader)
+        // publishes at the flush. The key gets its leaf first, born from the two
+        // frames (`bornStaged`: a key the hold left unchanged — or added — is
+        // unstaged and held by no one; a key the hold changed is born held, A34
+        // (1)), and the write stages on it (A28; a write by the holder joins it,
+        // A34) — as it would with a reader's leaf. Kept while the container is
+        // held (`deferredReleases`).
+                if (userWrite && e.k?.l & CONFIG_HELD) deferredReleases.add(getNode(e, t));
+        if (Array.isArray(i)) {
+            touch(e, t);
+            if (t === "length") e.wk = WK_ALL; else touch(e, "length");
+        } else {
+            touch(e, t);
+            if (!(t in i)) e.kc++;
+        }
+        const l = UNSAFE_KEYS.has(t);
+        if (l || e.ovl && e.sc !== 2 && !hasOwn.call(i, t)) {
+            Object.defineProperty(i, t, {
+                value: o,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        } else i[t] = o;
+        e.del?.delete(t);
+        if (l) return true;
+        if (e.s && o !== null && typeof o === "object") markRawOne(o);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
+    },
+    defineProperty(e, t, n) {
+        const r = inDraft(e);
+        if (!r && !writeOverride) {
+            return true;
+        }
+        if (t === "__proto__") return true;
+        if (n.get || n.set) e.a = true;
+        if ("value" in n) n = {
+            ...n,
+            value: unwrapValue(n.value)
+        };
+        const o = ensurePB(e);
+        if (e.a || !(n.enumerable && n.writable && n.configurable)) e.sc = 1;
+        touch(e, t);
+        Object.defineProperty(o, t, n);
+        e.del?.delete(t);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
+    },
+    deleteProperty(e, t) {
+        const n = inDraft(e);
+        if (!n && !writeOverride) {
+            return true;
+        }
+        const r = ensurePB(e);
+        touch(e, t);
+        // The key count (`kc`, the overlay gate and the rebuild cap) follows a
+        // delete the way it follows an add: an own key of the draft leaving — a
+        // clone's key, or an overlay's own add — is one fewer now. An overlay's
+        // override of a committed key is the exception: the committed key's
+        // deletion is recorded in `del` and counted at the rebuild, as before.
+        // Without the decrement the natural "delete the old key, set the new
+        // one" shape drifted the count up by one per write until a three-key
+        // object crossed the overlay threshold and paid a rebuild on every
+        // commit after.
+                const o = e.ovl && hasOwn.call(e.v, t);
+        if (hasOwn.call(r, t)) {
+            delete r[t];
+            o || e.kc--;
+        }
+        if (o) (e.del ??= new Set).add(t);
+        if (!n) notifyWrites(e);
+ // a write-override write
+                return true;
+    }
+};
+
+/** Is `obs` subscribed to the container BY THIS PASS (its enumerator holds
+ * it)? A link left from a previous pass is stale — the reader must subscribe
+ * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, t) {
+    const n = e.k;
+    if (n === null) return false;
+    const r = n.Ot;
+    return r !== null && r.u === t && (!(t.R & REACTIVE_RECOMPUTING_DEPS) || r.de === t.Ne);
+}
+
+function storeSetter(e, t, n = true) {
+    if (writeHook !== null) writeHook(e);
+    const r = e[$TARGET];
+    const o = writeScopes;
+    writeScopes = new Set;
+    writeScopes.add(scopeKey(r));
+    const i = userWrite;
+    userWrite = n;
+    writing++;
+    let l;
+    try {
+        // No untrack: the writing flag already disables store-node linking
+        // (draft reads never self-track, proj R2), while EXTERNAL reads (signals
+        // inside a projection derive) must keep tracking — they are the derive's
+        // dependencies.
+        l = t(e);
+    } finally {
+        writing--;
+        writeScopes = o;
+        // Outermost setter exit: emit write-time notifications (one node write
+        // per changed observed key) so holds and lanes engage now.
+                if (writing === 0 && pendingNotify.size) {
+            const e = [ ...pendingNotify ];
+            pendingNotify.clear();
+            for (const t of e) notifyWrites(t);
+            // A direct commit (a projection's creation run) folds at the setter's
+            // exit, unqueued: the backing is the pre-batch one (nothing swapped).
+                        if (directCommit) for (const t of e) if (t.pb !== null) foldTarget(t, t.v);
+        }
+        userWrite = i;
+    }
+    if (l !== undefined && l !== e && isWrappable(l)) {
+        // A returned replacement: on an optimistic family a user's is itself an
+        // optimistic edit — diffed against the view as guesses (`next` parity);
+        // otherwise it is adopted as the incoming truth.
+        if (optHooks && n && r.fam?.opt === true && !writeOverride) optHooks.writes(r, unwrapValue(l)); else adoptPB(r, unwrapValue(l));
+    }
+    // A34 (3), #3612 — the derived store's twin of `setMemo`: a user write to
+    // a derivation another transaction holds is nobody's proposal; it becomes
+    // the draft's prior state and the hold re-derives over it (the writes
+    // joined the hold through `setSignal`; the derive re-runs under it).
+        if (n && heldDerivationHit) {
+        heldDerivationHit = false;
+        const e = r.fam.node;
+        if (!(e.R & REACTIVE_DIRTY)) {
+            e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+            insertIntoHeap(e, dirtyQueue);
+            schedule();
+        }
+    }
+}
+
+function createStore(e, t) {
+    const n = t?.shallow === true;
+    const r = wrap(e);
+    // Dependency edges (store/edges.ts): the root is named like a plain signal.
+        if (signalHook !== null) signalHook(r[$TARGET]);
+    if (n) {
+        r[$TARGET].s = true;
+        markRawIngest(e);
+    }
+    {
+        const e = getOwner();
+        registerGraph(r, e);
+        // Only once the engine is installed, like the node stamping it feeds: a
+        // WeakMap.set per fresh store is a growing ephemeron table and,
+        // disabled, buys nothing.
+                if (attrHooks !== null) {
+            storeOwners.set(r[$TARGET], e);
+            nameStore(r, t?.name, t?.loc);
+        }
+    }
+    const setter = e => storeSetter(r, e);
+    return [ r, setter ];
+}
+
+/** The list driver's slot view of a shallow store (types.ts `shallowView`):
+ * one `readSource` for the container instead of a trap per slot. A shallow
+ * store's slots hold raw records, so the backing the container read serves
+ * is what each slot read would — except where a slot's own leaf can answer
+ * differently: an optimistic family's guesses, a chained backing, accessor
+ * keys, or a read inside a draft or write scope. Those keep the trap. */ installShallowView(e => {
+    // Any open write scope keeps the trap (it covers `inDraft`).
+    if (e?.s && !(e.ch || e.a || writeScopes || writeOverride || e.fam?.opt)) return e.fam && pullFamily(e), 
+    readSource(e);
+});
+
+/** True when `proxy` is a SHALLOW store (children served verbatim, slots
+ * replaced by reference — #2932). The list driver uses this to choose the
+ * slot-patch channel (collected row bodies) over per-record registration. */ function storeIsShallow(e) {
+    const t = e?.[$TARGET];
+    return t?.s === true;
+}
+
+/** True when `proxy` belongs to a projection family (S3). */ function storeHasFamily(e) {
+    const t = e?.[$TARGET];
+    return t?.fam != null;
+}
+
+/** True when `proxy` belongs to an OPTIMISTIC family (S4). */ function storeHasOptimisticFamily(e) {
+    const t = e?.[$TARGET];
+    return t?.fam?.opt === true;
+}
+
+// ---------------------------------------------------------------------------
+// enumeration views (one visibility rule for the traps AND the deep walk)
+function visibleKeys(e, t) {
+    let n;
+    if (e.ovl && t === e.pb) {
+        n = Reflect.ownKeys(e.v);
+        const r = e.del;
+        if (r?.size) n = n.filter(e => !r.has(e));
+        for (const r of Reflect.ownKeys(t)) {
+            if (!hasOwn.call(e.v, r)) n.push(r);
+        }
+    } else n = Reflect.ownKeys(t);
+    // The ownership stamp is the last symbol on an owned backing: hide it.
+        for (let e = n.length - 1; e >= 0 && typeof n[e] === "symbol"; e--) {
+        if (n[e] === $OWNER) {
+            n.splice(e, 1);
+            break;
+        }
+    }
+    return n;
+}
+
+function visibleDescriptor(e, t, n) {
+    let r = Object.getOwnPropertyDescriptor(t, n);
+    if (e.ovl && t === e.pb) {
+        if (e.del?.has(n)) return undefined;
+        if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, n);
+    }
+    return r;
+}
+
+// ---------------------------------------------------------------------------
+// deep / snapshot
+/** Tracking snapshot: subscribes every reachable record's container and deep
+ * witness (one node per record, not one per path), then snapshots. */ function deep(e) {
+    const t = e?.[$TARGET];
+    if (t?.px !== e) return e;
+    const n = new Set;
+    const childTarget = (e, t, n) => {
+        let r = lookupTarget(t, e.fam);
+        if (r === undefined) {
+            if (!isWrappable(t)) return undefined;
+            wrap(t, e, n);
+            r = lookupTarget(t, e.fam) ?? t[$TARGET];
+        }
+        return r;
+    };
+    const walkT = e => {
+        if (e.fam !== null) pullFamily(e);
+        const t = enumerationSource(e);
+        if (n.has(t)) return;
+        n.add(t);
+        read(getDeepNode(e));
+        // Through a chain (#3323): every inner record's container AND deep
+        // witness — base writes bump the inner witnesses.
+                for (let t = e; t.ch; ) {
+            t = t.v[$TARGET];
+            read(getContainerNode(t));
+            read(getDeepNode(t));
+        }
+        for (const n of visibleKeys(e, t)) {
+            const r = visibleDescriptor(e, t, n);
+            if (r === undefined) continue;
+            if (r.get || r.set) {
+                e.a = true;
+                continue;
+ // accessors track through their own reads when invoked
+                        }
+            let o = r.value;
+            if (o === null || typeof o !== "object") continue;
+            if (e.ch && o[$TARGET] === undefined) o = resolveChainedRaw(e, n, o);
+            const i = childTarget(e, o, n);
+            if (i === undefined) continue;
+ // raw-marked: leaf by contract
+                        walkT(i);
+        }
+    };
+    walkT(t);
+    return snapshot(e);
+}
+
+/** Non-tracking snapshot: source identity for unowned subtrees (zero copy),
+ * a copy for owned ones (they are by definition modified relative to the
+ * source). Sees the pending backing (R27). */ function snapshot(e) {
+    const t = e?.[$TARGET];
+    return snapshotWalk(e, new Map, t?.fam ?? null);
+}
+
+function snapshotWalk(e, t, n) {
+    if (e === null || typeof e !== "object") return e;
+    let r = e;
+    for (let e = true; ;e = false) {
+        const t = r?.[$TARGET]?.v !== undefined;
+        let o = t ? r[$TARGET] : undefined;
+        if (o === undefined && n !== null) o = lookupTarget(r, n);
+        if (o === undefined) o = lookupTarget(r, null);
+        if (o === undefined) break;
+        if (e && !t && n !== null && o.fam !== n) {
+            const e = n.map.get(o.px);
+            if (e !== undefined) o = e;
+        }
+        if (o.fam !== null) n = o.fam;
+        // R27: a snapshot sees the batch's pending backing — a held one (another
+        // transaction's future) only from its own draft.
+                let i = o.v;
+        if (o.pb !== null && (inDraft(o) || writeOverride || o.k === null || !(o.k.l & CONFIG_HELD))) {
+            if (o.ovl) materializePB(o);
+            i = o.pb;
+        }
+        if (optHooks && optRead(o)) i = optHooks.view(o, i);
+        if (i === r) break;
+        r = i;
+    }
+    if (!isWrappable(r)) return r;
+    const o = t.get(r);
+    if (o !== undefined) return o;
+    if (isOwned(r)) {
+        const e = Array.isArray(r);
+        const o = e ? [] : Object.create(Object.getPrototypeOf(r));
+        t.set(r, o);
+        for (const i of Reflect.ownKeys(r)) {
+            if (e && i === "length" || i === $OWNER) continue;
+            const l = Object.getOwnPropertyDescriptor(r, i);
+            if (typeof i === "symbol" && !l.enumerable) continue;
+            if (l.get || l.set) {
+                Object.defineProperty(o, i, l);
+                continue;
+            }
+            const u = l.value;
+            const f = u !== null && typeof u === "object" ? snapshotWalk(u, t, n) : u;
+            if (l.enumerable && l.writable && l.configurable) o[i] = f; else Object.defineProperty(o, i, {
+                ...l,
+                value: f
+            });
+        }
+        if (e && o.length !== r.length) o.length = r.length;
+        return o;
+    }
+    t.set(r, r);
+    let i = null;
+    for (const e of Reflect.ownKeys(r)) {
+        const o = Object.getOwnPropertyDescriptor(r, e);
+        if (!o || o.get || o.set) continue;
+        const l = o.value;
+        if (l === null || typeof l !== "object") continue;
+        const u = snapshotWalk(l, t, n);
+        if (u !== l) {
+            if (i === null) {
+                i = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                t.set(r, i);
+            }
+            i[e] = u;
+        }
+    }
+    return i ?? r;
+}
+
+export { $PROXY, $TARGET, $TRACK, LaneView, adoptPB, arrayStructureChanged, asBacking, bumpDeep, cloneRaw, committed, containerEquals, createStore, deep, getContainerNode, getHasNode, getNode, hasAccessorFlag, materializePB, membershipChanged, nameStore, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, resolveChainedRaw, runDirect, sameKey, sameRow, snapshot, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetter, targetsEqual, unwrapValue, userWriting, wrap };