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

package/dist/prod/store/store.js

@@ -1,325 +1,2010 @@
-import "../core/core.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 { GlobalQueue } from "../core/scheduler.js";
+import { writeHook, setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead, tracking } from "../core/core.js";
 
-import "../core/invariants.js";
+import { signalHook } from "../core/identities.js";
 
-import "../core/verdict.js";
+import { link, setSlotUnobserved } from "../core/graph.js";
 
-import "../core/effect.js";
+import { getObserver } from "../core/owner.js";
 
-import { storeNextLookup } from "./next/target.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, 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";
 
 /**
- * Brand symbols used internally by the store proxy / projection plumbing.
- * Cross-package wiring; not part of the user-facing API.
+ * 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)`.
  *
- * @internal
- */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), // Node-map slot carrying a record-level `affects()` mark: any read through
-// the record witnesses it into the active isPending() probe.
-$AFFECTS = Symbol(0);
+ * 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;
 
-// Structural field names of store targets (StoreNextTarget aliases these, so
-// shared machinery — affects walks, tests — reads targets via the consts).
-const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
+function createTarget(e, n, t, r = n?.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 = n;
+    o.pk = t;
+    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 lookupTarget(e, t) {
-    // Family maps (projections/optimistic) map raw -> target; the global next
-    // lookup maps raw -> target too. Proxies resolve through $TARGET directly.
-    if (t !== undefined) {
-        const o = t.get(e);
-        if (o !== undefined) return o[$TARGET] ?? o;
+function wrap(e, n = null, t = null, r = n?.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, n, t, r).px;
     }
-    return storeNextLookup.get(e);
+    return createTarget(e, n, t, r).px;
 }
 
-// Values marked raw never acquire a proxy identity: wrap() serves them as-is
-// everywhere — deep stores hold them as leaf values replaced by reference.
-// Once raw, always raw (identity stays single, just unwrapped). Consulted
-// only on wrap-creation and ingest paths; reads never touch it.
-const rawValues = new WeakSet;
+/** 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 n = e[$TARGET];
+    if (n !== undefined && (n.px === e || lookupTarget(e, n.fam) === n) && n.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 (n.ovl) materializePB(n);
+        return n.pb ?? n.v;
+    }
+    return e;
+}
 
-/**
- * Marks a value as raw: no store will ever wrap it — every store presents it
- * as-is, tracked by reference at whatever slot holds it and updated by
- * replacement. Useful for class instances and external objects (editors,
- * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
- * for the value's lifetime.
- */
-// Flipped on the first mark and exported as a LIVE binding: reconcile
-// consults it on every recursable pair, and importing the boolean directly
-// lets those sites skip even the function call when no shallow store or raw
-// mark exists anywhere in the app.
-let rawValuesUsed = false;
-
-function isRawValue(e) {
-    return rawValuesUsed && rawValues.has(e);
-}
-
-function markRawOne(e) {
-    if (isWrappable(e)) {
-        // A store proxy is already tracked elsewhere: the shallow boundary passes
-        // it through by reference (replaced, never edited — same slot semantics
-        // as a raw) instead of claiming it raw. The sticky mark is global, so
-        // marking a live proxy would make wrap() serve it verbatim through every
-        // OTHER store too — downstream deep stores then captured it instead of
-        // wrapping it in their own family, and their writes landed in the
-        // upstream store's override layer (#2932).
-        if (e[$TARGET] !== undefined) return;
-        rawValuesUsed = true;
-        rawValues.add(e);
-    }
-}
-
-function markRawIngest(e) {
-    if (Array.isArray(e)) {
-        for (let t = 0, o = e.length; t < o; t++) markRawOne(e[t]);
-    } else {
-        for (const t in e) markRawOne(e[t]);
-    }
-}
-
-const OBJECT_PROTO = Object.prototype;
-
-// Per-prototype memo for the custom-proto branch of isWrappable: the verdict
-// is fully determined by the prototype (tag and Node lineage both live on
-// the chain), so each class pays the tag call once — not per read.
-const wrappableProtos = new WeakMap;
-
-function isWrappable(e) {
-    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
-    // Plain data and user class instances wrap; platform objects never do
-    // (#2952). Native code brand-checks internal slots and throws through a
-    // proxy (`Map.prototype.size`, `Date.prototype.getTime`, ...), so
-    // collections and other built-ins can't honestly be stores — they get the
-    // markRaw-children contract automatically: served raw, mutations land raw,
-    // the property holding them still tracks (reassignment notifies). The tag
-    // check separates them structurally: user classes stringify as
-    // `[object Object]` while every native/host object carries its own brand
-    // (`[object Map]`, `[object Date]`, `[object Headers]`, ...), including
-    // subclasses, which inherit the tag. getPrototypeOf keeps the hot path
-    // (plain and null-proto objects) intrinsic-only — no property lookup.
-        const t = Object.getPrototypeOf(e);
-    if (t === OBJECT_PROTO || t === null) return true;
-    if (Array.isArray(e)) return true;
-    let o = wrappableProtos.get(t);
+// ---------------------------------------------------------------------------
+// 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, n) {
+    return isEqual(e, n) || sameLogicalSlot(this.O, e, n);
+};
+
+/** The deep witness: the store decides when it notifies. */ const never = false;
+
+function sameKey(e, n) {
+    return e === n || e !== e && n !== n;
+}
+
+/** 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). */
+    n, 
+    /** 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. */
+    t = null) {
+        this.rows = e;
+        this.base = n;
+        this.removed = t;
+    }
+}
+
+/** 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, n) {
+    return e === n || !!optHooks?.arrangement(this.O, e, n);
+};
+
+function sameLogicalSlot(e, n, t) {
+    if (n === null || typeof n !== "object" || t === null || typeof t !== "object") return false;
+    const r = lookupTarget(n, e.fam);
+    return r !== undefined && r === lookupTarget(t, 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 n = e.O;
+    const t = e.Xe;
+    if (t === $TRACK) {
+        if (n.k === e) n.k = null;
+    } else if (t === $DEEP) {
+        if (n.dk === e) n.dk = null;
+    } else if (n.n?.[t] === e) {
+        delete n.n[t];
+        n.nc--;
+    } else if (n.h?.[t] === e) delete n.h[t];
+    // The family's index keeps only targets that still carry a node.
+        if (n.fam !== null && n.nc === 0 && n.k === null && n.dk === null && (n.h === null || Reflect.ownKeys(n.h).length === 0)) n.fam.live.delete(n);
+}
+
+/** A node was born on `target`: a family target enters the live index. */ function noteNode(e, n, t) {
+    if (e.fam !== null) e.fam.live.add(e);
+    markDescendants(e);
+    if (affectsHooks !== null) affectsHooks.ro(e, n, t);
+}
+
+// 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, n, t, r) {
+    if (n.ye && n.ye(n.le, t)) return;
+    queuePendingNode(n);
+    n.ue = t;
+    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(n, 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(n);
+}
+
+function getNode(e, n, 
+// 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.
+t = -1) {
+    const r = e.n ??= Object.create(null);
+    let o = r[n];
     if (o === undefined) {
-        o = Object.prototype.toString.call(e) === "[object Object]" && (
-        // Dynamic Node check (kept dynamic so test/SSR overrides of
-        // `globalThis.Node` are observed at call time): shimmed DOMs implement
-        // nodes as plain user classes, which pass the tag check.
-        typeof Node === "undefined" || !(e instanceof Node));
-        wrappableProtos.set(t, o);
+        // 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)[n], slotNodeEquals, e, n, t === -1 ? isOwnAccessor(i ?? e.v, n) : t === 1);
+        if (i !== null && !l.acc) bornStaged(e, l, e.del?.has(n) ? undefined : i[n], n);
+        r[n] = o;
+        e.nc++;
+        noteNode(e, l, n);
     }
     return o;
 }
 
-let writeOverride = false;
+function getHasNode(e, n) {
+    const t = e.h ??= Object.create(null);
+    let r = t[n];
+    if (r === undefined) {
+        const o = r = slotSignal(n in committed(e), isEqual, e, n, false);
+        const i = e.pb;
+        if (i !== null) bornStaged(e, o, n in i && !e.del?.has(n), n);
+        t[n] = r;
+        noteNode(e, o, n);
+    }
+    return r;
+}
 
-function setWriteOverride(e) {
-    writeOverride = e;
+/** 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 n = e.k;
+    if (n === null) {
+        n = e.k = slotSignal(e.v, containerEquals, e, $TRACK, false);
+        noteNode(e, n, $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) {
+            n.le = preBatch(e);
+            n.ue = e.pb;
+            queuePendingNode(n);
+        }
+    }
+    return n;
 }
 
-function getWriteOverride() {
-    return writeOverride;
+/** 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, n) {
+    if (e.k === null && passLane === null && (context === null || globalQueue.Y) && !deriveHolds(e)) return;
+    const t = getContainerNode(e);
+    if (t.ue === NOT_PENDING) queuePendingNode(t);
+    t.ue = n;
+    // 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(t);
+    if (e.fam !== null) holdWithDerive(e, t);
 }
 
-// Own enumerable keys including symbols (`Object.keys` drops symbol-keyed props). #2769
-function ownEnumerableKeys(e) {
-    return Reflect.ownKeys(e).filter(t => Object.prototype.propertyIsEnumerable.call(e, t));
+/** 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 n = e.fam?.node;
+    return n != null && !userWrite && (n.l & CONFIG_HELD) !== 0;
 }
 
-/**
- * Scope inheritance for late-created nodes: every live mark whose identity
- * scope contains the owning record's raw — and, for keyed marks, whose key
- * is this property — gets counted on the new node. Inherited marks live
- * exactly as long as the scope's carrier — the release hook below drops
- * them with the entry.
- */ function inheritAffectsMarks(e, t, o) {
-    // A live scope exists, so affects.ts already installed the mark engine.
-    for (const [r, s] of affectsScopes) {
-        if (r.o?.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
-            GlobalQueue.h(e);
-            s.inherited.push(e);
-        }
+const storePark = e => {
+    for (let n = 0; n < foldList.length; n++) {
+        const t = foldList[n];
+        if (t.k === null && t.pb !== null) holdNode(getContainerNode(t), e);
+    }
+    optHooks?.park(e);
+};
+
+function getDeepNode(e) {
+    let n = e.dk;
+    if (n === null) {
+        n = e.dk = slotSignal(0, never, e, $DEEP, false);
+        noteNode(e, n, $DEEP);
+    }
+    return n;
+}
+
+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, n) {
+    // 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, n); else {
+        if (e.l & CONFIG_HELD) joinFuture(txOf(e));
+        if (snapshotCaptureActive) captureWriteSnapshot(e, e.le);
+        insertSubs(e);
+        schedule();
     }
 }
 
-const affectsScopes = new Map;
+// ---------------------------------------------------------------------------
+// clones (CoW privatization)
+const hasOwn = Object.prototype.hasOwnProperty;
+
+const lookupGetter = Object.prototype.__lookupGetter__;
+
+const lookupSetter = Object.prototype.__lookupSetter__;
 
-/** Next-store node factory for affects carriers/slots: injected by the
- * rewrite module (next targets alias the legacy field names, so everything
- * here EXCEPT node creation works on them structurally). */ let nextAffectsNodeResolver = null;
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
 
-function setNextAffectsNodeResolver(e) {
-    nextAffectsNodeResolver = e;
+function isOwnAccessor(e, n) {
+    return hasOwn.call(e, n) && (lookupGetter.call(e, n) !== undefined || lookupSetter.call(e, n) !== undefined);
 }
 
-/** Next-store optimistic view for the declaration walk (optimistic rows
- * pushed before the declaration are in motion too — legacy reads its write
- * overlays; next composes armed-node overrides). */ let nextOptimisticViewResolver = null;
+/** Shallow clone into store ownership. Plain data (grade 2) spreads; anything
+ * else copies descriptors (accessors kept, everything made configurable). */ function cloneRaw(e, n) {
+    n.sc || scanAccessorsOnce(n);
+    if (n.sc === 2) {
+        const t = {
+            ...e
+        };
+        t[$OWNER] = n;
+        return t;
+    }
+    // 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 t;
+    if (!n.a && n.kc <= e.length + 1 && Object.getPrototypeOf(e) === Array.prototype) t = e.slice(); else {
+        const r = Object.getOwnPropertyDescriptors(e);
+        for (const t of Reflect.ownKeys(r)) {
+            const o = r[t];
+            if (t === "length" && Array.isArray(e)) continue;
+            o.configurable = true;
+            if (!o.get && !o.set) o.writable = true; else n.a = true;
+        }
+        t = Array.isArray(e) ? Object.defineProperties([], r) : Object.create(Object.getPrototypeOf(e), r);
+    }
+    t[$OWNER] = n;
+    return t;
+}
 
-function setNextOptimisticViewResolver(e) {
-    nextOptimisticViewResolver = e;
+/** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, n) {
+    const t = Object.create(null);
+    for (const n of Reflect.ownKeys(e)) t[n] = e[n];
+    Object.setPrototypeOf(t, Object.prototype);
+    t[$OWNER] = n;
+    return t;
 }
 
-/** @internal birth inheritance for nodes created inside a live mark window —
- * exported for the rewrite's node factories. */ function affectsScopesLive() {
-    return affectsScopes.size > 0;
+function copyOwn(e, n, t) {
+    const r = Object.getOwnPropertyDescriptor(n, t);
+    if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, t, r); else e[t] = r.value;
 }
 
-/**
- * Snapshots the identities reachable from `value` into `scope`, reading
- * through write overlays (an optimistic row pushed before the declaration is
- * in motion too). Untracked by construction: walks raw values, never traps.
- * Every LIVE node under each reachable record — property leaves, `$TRACK`,
- * and has-nodes — collects into `found`: those are the graph edges existing
- * readers subscribed through, so the mark registers on them directly and
- * rides the status rails to everything derived. (Nodes born later inherit
- * from the scope in `getNode`.)
- */ function walkAffectsScope(e, t, o, r, 
-// Cycle guard, fresh per declaration: the scope itself can't serve — a
-// re-declaration on the same carrier unions into a scope that already
-// holds the root, and must still descend to pick up records added since.
-s) {
-    if (!isWrappable(e)) return;
-    const f = e[$TARGET] || lookupTarget(e, r);
-    // Next targets: walk the pending backing when present (a draft's writes are
-    // in motion too) and cover BOTH identities in the scope.
-        let n = f ? f.pb ?? f[STORE_VALUE] : e;
-    if (s.has(n)) return;
-    s.add(n);
-    t.scope.add(n);
-    if (f && f.pb) t.scope.add(f[STORE_VALUE]);
-    // Next optimistic families: enumerate the VISIBLE view (armed-node
-    // overrides compose membership/values the raw doesn't carry).
-        if (f && f.fam?.opt && nextOptimisticViewResolver) n = nextOptimisticViewResolver(f, n);
-    if (f) {
-        collectRecordNodes(f[STORE_NODE], o);
-        collectRecordNodes(f[STORE_HAS], o);
-        // The key-set and deep-witness nodes are record-level channels: a deep()
-        // probe reads ONLY these (one pair per record), so a declared affects
-        // scope must mark them like any property node.
-                if (f.k) o.push(f.k);
-        if (f.dk) o.push(f.dk);
-        // Carry the effective lookup into untouched descendants (family maps for
-        // projections/optimistic stores; the global next lookup otherwise).
-                r = f.fam?.map ?? r ?? storeNextLookup;
-    }
-    // Overlays are gone (next has no layer): raw enumeration; the optimistic
-    // view composition above already folded armed-node membership/values in.
-        if (Array.isArray(n)) {
-        for (let e = 0, f = n.length; e < f; e++) {
-            walkAffectsScope(n[e], t, o, r, s);
-        }
-        const e = Object.getOwnPropertySymbols(n);
-        for (let f = 0, c = e.length; f < c; f++) {
-            const c = Object.getOwnPropertyDescriptor(n, e[f]);
-            if (!c || c.get) continue;
-            walkAffectsScope(c.value, t, o, r, s);
+/** One descriptor scan per container (grade 1/2, `a`, `kc`). */ function scanAccessorsOnce(e) {
+    const n = e.v;
+    const t = Reflect.ownKeys(n);
+    let r = Object.getPrototypeOf(n) === Object.prototype;
+    for (const o of t) {
+        if (isOwnAccessor(n, o)) {
+            e.a = true;
+            r = false;
+            break;
         }
+        if (r && !propertyIsEnumerable.call(n, o)) r = false;
+    }
+    e.sc = r ? 2 : 1;
+    e.kc = t.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 n = Object.getPrototypeOf(e);
+    return n === Object.prototype || n === Array.prototype || n === null;
+};
+
+/** An overlay with many adds (or any delete) rebuilds the committed
+ * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, n) {
+    if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
+    if (e.del?.size) return true;
+    const t = e.wk;
+    if (t !== null && t !== WK_ALL && t.u === undefined && t.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    const r = e.v;
+    let o = 0;
+    for (const e of Reflect.ownKeys(n)) 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 n = e.pb;
+    if (!e.ovl) return n;
+    const t = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), n);
+    e.pb = t;
+    // The staging IS the pending backing: re-point the container node.
+        if (e.k?.ue === n) e.k.ue = t;
+    return t;
+}
+
+/** 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 n = 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 (n !== null && !isOwned(n)) {
+        // 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).
+        n = e.pb = cloneRaw(n, e);
+        const t = e.k;
+        if (t !== null && !(t.l & CONFIG_HELD)) t.ue = n;
+    } else if (n === null) {
+        const t = e.v;
+        if (!directCommit) queueFold(e);
+        if (!e.ch && !Array.isArray(t) && (e.sc !== 0 ? !e.a : scanAccessorsOnce(e)) && e.kc > OVERLAY_MIN_KEYS && isOwned(t)) {
+            n = e.pb = Object.create(t);
+            e.ovl = true;
+        } else n = e.pb = cloneRaw(t, e);
+        if (!directCommit) stageOn(e, n);
+    }
+    return n;
+}
+
+/** 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 n = e.v;
+    const t = cloneRaw(n, 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 = t;
+    e.ch = false;
+    if (e.u) {
+        privatizeCommitted(e.u);
+        const t = e.u.v;
+        const r = parentSlotKey(e, n);
+        if (t[r] === n) t[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, n) {
+    const t = e.pk;
+    const r = e.u.v;
+    if (r[t] === n || r[t] === e.v || !Array.isArray(r)) return t;
+    const o = r.indexOf(n);
+    if (o === -1) return t;
+    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, n) {
+    privatizeCommitted(e);
+    overlayOnto(e, e.v, n);
+ // 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, n, t) {
+    for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
+    if (e.del !== null) {
+        for (const t of e.del) delete n[t];
+        e.kc -= e.del.size;
+        e.del = null;
+    }
+    e.ovl = false;
+    return n;
+}
+
+/** 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, n, t = 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 = n;
     } else {
-        const e = Reflect.ownKeys(n);
-        for (let f = 0, c = e.length; f < c; f++) {
-            const c = Object.getOwnPropertyDescriptor(n, e[f]);
-            if (!c || c.get) continue;
-            walkAffectsScope(c.value, t, o, r, s);
+        // 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 = n;
+        stageOn(e, n);
+    }
+    e.v = n;
+    e.ch = n[$TARGET] !== undefined;
+    e.ovl = false;
+    e.del = null;
+    e.sc = 0;
+    e.a = false;
+    e.wk = null;
+ // adoption supersedes staged trap writes
+        const o = n[$OWNER];
+    if (o?.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
+    if (t && r !== n) notifyFold(e, r, n);
+}
+
+// ---------------------------------------------------------------------------
+// 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 n = foldIndex.get(e);
+    return n === undefined ? e.v : foldOlds[n];
+}
+
+/** 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 n = foldOlds;
+        foldList = foldSpare;
+        foldOlds = foldOldsSpare;
+        foldSpare = e;
+        foldOldsSpare = n;
+        foldIndex = null;
+        for (let t = 0; t < e.length; t++) {
+            const r = e[t];
+            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(n[t]);
+            } else foldTarget(r, n[t]);
+        }
+        e.length = 0;
+        n.length = 0;
+    }
+    if (deferredReleases.size !== 0) {
+        for (const e of deferredReleases) {
+            if (e.o === null && !slotKept(e)) {
+                deferredReleases.delete(e);
+                releaseSlot(e);
+            }
         }
     }
 }
 
-/** All live signal nodes of one record's node map (string + symbol keyed). */ function collectRecordNodes(e, t) {
-    if (!e) return;
-    for (const o of Object.keys(e)) t.push(e[o]);
-    const o = Object.getOwnPropertySymbols(e);
-    for (let r = 0, s = o.length; r < s; r++) {
-        // Another mark's carrier is its own channel — counting it here would
-        // extend that sibling scope's lifetime to this declaration's.
-        if (o[r] !== $AFFECTS) t.push(e[o[r]]);
+/** 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 n = e.O?.fam;
+    return (n?.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 n = e.O;
+    if (n.ch) {
+        const t = e.Xe;
+        const r = n.v;
+        if (n.h?.[t] === e) e.le = untrack(() => t in r); else if (n.n?.[t] === e) e.le = untrack(() => unwrapValue(r[t]));
+    }
+    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 n = directCommit;
+    directCommit = true;
+    try {
+        e();
+    } finally {
+        directCommit = n;
     }
 }
 
-/**
- * Witness live mark coverage of a record into the active isPending() probe.
- * Tracked reads don't need this — they go through real signal nodes, which
- * carry marks directly (declaration walk or birth inheritance). This covers
- * UNTRACKED probes reading through records whose nodes never materialized
- * (no observer ever subscribed, so no node exists to carry the mark).
- * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
- *
- * @internal
- */ function witnessAffectsMark(e, t) {
-    // Callers guard on `pendingCheckActive`, which only flips inside
-    // isPending() — the verdict layer is loaded and its hook installed.
-    const o = e[STORE_NODE]?.[$AFFECTS];
-    if (o?.o?.t) GlobalQueue.Bt(o);
-    if (affectsScopes.size) {
-        // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
-        // proxy — marks cover by identity of the BASE raw, so resolve the chain
-        // and check every identity along it.
-        let r = e[STORE_VALUE];
-        for (const [e, s] of affectsScopes) {
-            if (e !== o && e.o?.t && (s.key === undefined || s.key === t)) {
-                let t = r;
-                for (;;) {
-                    if (s.scope.has(t)) {
-                        GlobalQueue.Bt(e);
+/** Fold one target's pending backing into its committed home. */ function foldTarget(e, n) {
+    {
+        {
+            const t = e.k;
+            const r = e.pb;
+            if (r !== null) {
+                if (r === e.v) ; else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.De !== n)) {
+                    // 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 !== n) {
+                    // Privatized mid-batch (a child's path copy repointed us): the
+                    // owned backing takes the written keys.
+                    privatizeCommitted(e);
+                    const t = e.v;
+                    const o = e.wk;
+                    if (o !== null && o !== WK_ALL) {
+                        for (let e = o; e !== undefined; e = e.u) for (const n of e) {
+                            if (hasOwn.call(r, n)) copyOwn(t, r, n); else delete t[n];
+                        }
+                    } else {
+                        for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) copyOwn(t, r, e);
+                        for (const e of Reflect.ownKeys(n)) {
+                            if (e !== $OWNER && !hasOwn.call(r, e)) delete t[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 (t !== 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 (t.o === null) e.k = null; else if (t.le instanceof LaneView) t.le.base = e.v; else t.le = e.v;
+            }
+            if (e.v !== n && e.u) {
+                const t = parentSlotKey(e, n);
+                if (e.u.v[t] === n) {
+                    privatizeCommitted(e.u);
+                    e.u.v[t] = e.v;
+                }
+            }
+        }
+    }
+}
+
+/** 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, n, t) {
+    if (e.fam === null || !userWrite) return false;
+    if (n !== undefined) return (n.l & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
+    const r = e.k;
+    return r !== null && (r.l & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
+}
+
+/** 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 n = e.pb;
+    if (n === 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, n);
+            return;
+        }
+        // The derive's draft: new rows under guessed rows are paired with them
+        // first (D-34, #4329).
+                optHooks.pair(e, n);
+    }
+    const t = 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 : n) ? null : o;
+    if (e.fam !== null && !heldDerivationHit && i !== null) for (const n of i) if (heldDerivation(e, r?.[n], n)) {
+        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(n, i) && lookupGetter.call(n, 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(n, i);
+                const e = Object.getOwnPropertyDescriptor(t, i);
+                const r = Object.getOwnPropertyDescriptor(n, 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 : n[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 t = i ?? Reflect.ownKeys(l);
+        for (const r of t) {
+            const t = l[r];
+            if (t !== undefined) {
+                setSignal(t, r in n && !e.del?.has(r));
+                if (e.fam !== null) holdWithDerive(e, t);
+            }
+        }
+    }
+    if (e.dk !== null) {
+        if (e.del?.size) bumpDeep(e); else for (const r of i ?? Reflect.ownKeys(n)) {
+            if (r === $OWNER) continue;
+            const o = n[r];
+            const i = t[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(n)) {
+                    if (!hasOwn.call(t, e)) {
+                        r = true;
                         break;
                     }
-                    const o = t?.[$TARGET];
-                    if (o === undefined) break;
-                    const r = o.pb ?? o[STORE_VALUE];
-                    if (r === t) break;
-                    t = r;
                 }
             }
+        } else {
+            r = Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n);
         }
+        if (r) notifyContainer(u, n);
     }
 }
 
-/**
- * Resolves the store nodes an `affects()` declaration marks: with a `key`,
- * the named slot's leaf node (upserted so the mark has an addressable
- * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
- * its subtree (the edges existing readers subscribed through), with the
- * subtree's identities snapshotted into the mark's scope so nodes created
- * during the window — and untracked probes over captured proxies — resolve
- * against it (#2882).
+/** 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, n) {
+    if (e === null || typeof e !== "object" || n === null || typeof n !== "object") return false;
+    const t = lookupTarget(e, null);
+    return t !== undefined && t === lookupTarget(n, null);
+}
+
+/** Positional identity IS content for arrays (R15). */ function arrayStructureChanged(e, n) {
+    if (e.length !== n.length) return true;
+    for (let t = 0; t < n.length; t++) {
+        const r = e[t];
+        const o = n[t];
+        if (!isEqual(r, o) && !targetsEqual(r, o)) return true;
+    }
+    return false;
+}
+
+function membershipChanged(e, n) {
+    const t = Reflect.ownKeys(n);
+    if (Reflect.ownKeys(e).length - +isOwned(e) !== t.length - +isOwned(n)) return true;
+    for (const n of t) if (n !== $OWNER && !(n in e)) return true;
+    return false;
+}
+
+/** One leaf's notification for an adoption diff (descriptor-aware). */ function notifyKeyDiff(e, n, t, r, o = true) {
+    if (e.acc === true || o && hasOwn.call(r, n) && lookupGetter.call(r, n) !== undefined) {
+        e.acc = isOwnAccessor(r, n);
+        const o = Object.getOwnPropertyDescriptor(t, n);
+        const i = Object.getOwnPropertyDescriptor(r, n);
+        // 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 = t[n];
+        const i = r[n];
+        // 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 (t[$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, n, t, r, o, i) {
+    if (e.acc === true) {
+        notifyKeyDiff(e, n, o, i, false);
+        return;
+    }
+    if (!isEqual(t, r) && !targetsEqual(t, 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).
  *
- * @internal
- */ function getStoreAffectsNodes(e, t) {
-    GlobalQueue.G ||= e => {
-        const t = affectsScopes.get(e);
-        if (!t) return;
-        affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.j(t.inherited[e]);
-    };
-    if (t === undefined) {
-        const t = nextAffectsNodeResolver(e, $AFFECTS);
-        let o = affectsScopes.get(t);
-        if (!o) affectsScopes.set(t, o = {
-            scope: new Set,
-            inherited: []
-        });
-        const r = [ t ];
-        walkAffectsScope(e[$PROXY], o, r, e.fam?.map, new Set);
+ * 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, n, t) {
+    const r = e.h;
+    const o = n[$TARGET];
+    if (r !== null) {
+        for (const e of Reflect.ownKeys(r)) if (o || e in n !== e in t) setSignal(r[e], e in t);
+    }
+    const i = e.k;
+    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
+        const e = o || (Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t));
+        if (e) notifyContainer(i, t);
+    }
+}
+
+/** 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, n, t) {
+    if (e.dk !== null && n !== t) bumpDeep(e);
+    const r = e.n;
+    if (r !== null) {
+        for (const e of Reflect.ownKeys(r)) notifyKeyDiff(r[e], e, n, t);
+    }
+    notifyFoldTail(e, n, t);
+}
+
+// ---------------------------------------------------------------------------
+// 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 n = e;
+    while (n.u !== null) n = n.u;
+    return n;
+}
+
+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, n, t) {
+    if (t !== null && typeof t === "object" && t[$TARGET] !== undefined) return draftServe(e, wrap(t, e, n));
+    return t;
+}
+
+/** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, n) {
+    if (writeScopes !== null && inDraft(e)) {
+        const e = n?.[$TARGET];
+        if (e?.v !== undefined) writeScopes.add(scopeKey(e));
+    }
+    return n;
+}
+
+/** 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 n = e.k;
+    if (n !== null) return n.ue !== NOT_PENDING ? asBacking(n.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.Qe) e = e.Ke ?? 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, n, t = 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 n = ensurePB(e);
+        pendingNotify.add(e);
+        return n;
+    }
+    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 t = n !== undefined ? e.n?.[n] : undefined;
+            if (t !== undefined) {
+                if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
+            } else {
+                const t = e.k;
+                if (t !== null && (t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
+            }
+        }
+        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 (n !== undefined) {
+        const t = e.n?.[n];
+        if (t?.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 && n !== undefined && !heldKeyChanged(e, n, t)) 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 && n !== undefined && !keyChanged(e, n, t)) 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 (n !== undefined && !keyChanged(e, n, t)) 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, n, t = true) {
+    return changedBetween(e, e.k.le, e.k.ue, n, t) && !adoptChild(e, n);
+}
+
+/** 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 n = frameRaws.get(e);
+    if (n === undefined) frameRaws.set(e, n = new Set(Object.values(e)));
+    return n;
+}
+
+/** 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, n, t) {
+    return e !== null && typeof e === "object" && n !== null && typeof n === "object" && (t === null || sameKey(t(e), t(n)));
+}
+
+/** 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, n) {
+    const t = e.k;
+    const r = asBacking(t.le);
+    const o = r[n];
+    const i = t.ue[n];
+    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(t.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, n)[$TARGET];
+    if (u?.v !== o) return false;
+    adoptPB(u, i, false);
+    holdNode(getContainerNode(u), txOf(t));
+    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, n, t = true) {
+    return changedBetween(e, committed(e), e.pb, n, t);
+}
+
+function changedBetween(e, n, t, r, o) {
+    if (e.ch || t[$TARGET] !== undefined || Object.getPrototypeOf(t) !== Object.getPrototypeOf(n) || !plainProto(n)) return true;
+    if (e.del?.has(r)) return r in n;
+    const i = hasOwn.call(t, r) || e.ovl && hasOwn.call(e.v, r);
+    if (i !== hasOwn.call(n, r)) return true;
+    if (!i) return false;
+    if ((o || e.a) && (isOwnAccessor(n, r) || isOwnAccessor(t, r) || propertyIsEnumerable.call(n, r) !== propertyIsEnumerable.call(t, r))) return true;
+    const l = t[r];
+    const u = n[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, n, t) {
+    let r;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && t.fam !== null && (context === null || t.fam.node?.m & STATUS_UNINITIALIZED)) {
+        if (context !== null && tracking) link(e, context);
+        r = e.ue;
+    } else r = read(e);
+    return r === FORCE ? n : 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, n, t, 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 = t;
+    // 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, n, i);
+        if (o !== undefined) {
+            const n = nodeValue(o, t, 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 = t;
+                if (o.l & CONFIG_OVERRIDE) u = n;
+            } else u = n;
+        }
+    }
+    if (e.s) return serveShallow(e, n, 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, n, u);
+    if (o !== undefined) {
+        if (o.pxv === u && u !== undefined) return draftServe(e, o.px);
+        if (!isWrappable(u)) return u;
+        const t = wrap(u, e, n);
+        o.px = t;
+        o.pxv = u;
+        return draftServe(e, t);
+    }
+    if (!isWrappable(u)) return u;
+    return draftServe(e, wrap(u, e, n));
+}
+
+/** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, n) {
+    for (let t = e.C; t !== null; t = t.G) if (t.S === n) 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 n = e.fam.node;
+    if (n === 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 (n.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 t = context;
+        if (t !== null && t.i === EFFECT_RENDER && !(n.m & STATUS_ERROR) && n.l & CONFIG_HELD && flushTransaction !== txOf(n) && !linkedTo(t, n)) 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 && n.m & STATUS_PENDING && optHooks?.stands(e)) return;
+        read(n);
+    } else untrack(() => read(n));
+}
+
+/** 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, n) {
+    const t = e.fam?.node;
+    if (t !== undefined && t !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
+    t.l & CONFIG_HELD && n.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.
+    !(n.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
+        holdNode(n, txOf(t));
+        n.T.Ve = t.T.Ve;
+    }
+}
+
+/** 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, n, t) {
+    const r = e.v[$TARGET];
+    if (r.ch) {
+        const e = resolveChainedRaw(r, n, t);
+        return e === t ? t : wrap(e, r, n);
+    }
+    const o = lookupTarget(t, r.fam);
+    if (o !== undefined) return o.px;
+    if ((r.v[n] === t || r.pb?.[n] === t) && isWrappable(t)) return wrap(t, r, n);
+    return t;
+}
+
+/** 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 n = asBacking(read(getContainerNode(e)));
+        return optHooks && e.fam?.opt === true ? optHooks.view(e, n) : n;
+    }
+    const n = readSource(e);
+    return optHooks && optRead(e) ? optHooks.view(e, n) : n;
+}
+
+/** 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, n) {
+    let t = e.wk;
+    if (!pendingNotify.has(e)) {
+        pendingNotify.add(e);
+        if (t !== null && t !== WK_ALL) {
+            t = new Set;
+            t.u = e.wk;
+            e.wk = t;
+        }
+    }
+    if (t !== WK_ALL) (e.wk ??= new Set).add(n);
+}
+
+const traps = {
+    get(e, n, t) {
+        // One typeof gates every brand-symbol compare off the hot string path.
+        if (typeof n !== "string") {
+            if (n === $TARGET) return e;
+            if (n === $PROXY) return t;
+            if (n === $OWNER) return undefined;
+ // ownership stamp: never a user key
+                        if (n === $RECORD) return undefined;
+ // a store is no view (see `viewOf`)
+            // refresh()/isPending resolve the projection computed through $REFRESH.
+                        if (n === $REFRESH) return e.fam?.node ?? undefined;
+            if (n === $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 n = readSource(e);
+                    if (n[$TARGET] !== undefined) n[$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, n);
+        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?.[n];
+        if (writeScopes === null && !writeOverride) {
+            const t = r;
+            if (t !== undefined && t.acc !== true && (!e.ch || t.l & CONFIG_OVERRIDE)) {
+                const r = nodeValue(t, undefined, e);
+                if (r === null || typeof r !== "object") return r;
+                if (e.s) return serveShallow(e, n, r);
+                if (t.pxv === r) return t.px;
+                if (isWrappable(r)) {
+                    const o = wrap(r, e, n);
+                    t.px = o;
+                    t.pxv = r;
+                    return o;
+                }
+                return r;
+            }
+        }
+        const o = readSource(e, n);
+        // 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(n)) {
+            if (!inDraft(e) && getObserver() !== null) read(getNode(e, n));
+            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, n);
+                if (o === (e.pb ?? e.v)) i = l ? 1 : 0;
+            } else l = false;
+            if (l) {
+                if (!inDraft(e) && getObserver() !== null) read(r ?? getNode(e, n, i));
+                const l = Reflect.get(o, n, t);
+                if (e.s) return serveShallow(e, n, l);
+                return isWrappable(l) ? draftServe(e, wrap(l, e, n)) : 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 ((n === "constructor" || n === "__proto__" || n === "prototype") && !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n))) return undefined;
+        let u = o[n];
+        if (u === undefined ? !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n)) : false) {
+            // Inherited: prototype getters/methods run with the proxy receiver.
+            u = Reflect.get(o, n, t);
+            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, n, 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, n, i);
+                const t = e.n?.[n];
+                if (t) {
+                    const r = nodeValue(t, undefined, e);
+                    if (e.s) return serveShallow(e, n, r);
+                    return isWrappable(r) ? draftServe(e, wrap(r, e, n)) : r;
+                }
+            }
+            if (e.s) return serveShallow(e, n, u);
+            return isWrappable(u) ? draftServe(e, wrap(u, e, n)) : u;
+        }
+        if (typeof u === "function" && !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n))) return u;
+ // proto method
+                return serveDataKey(e, n, u, o, r, i);
+    },
+    has(e, n) {
+        if (n === $TARGET || n === $PROXY || n === $TRACK) return true;
+        if (n === $OWNER || n === $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, n);
+        if (e.fam !== null) pullFamily(e);
+        const t = readSource(e, n);
+        // 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, n);
+                const o = read(r);
+                if (!e.ch || t !== e.v) return !!o;
+                const i = n in t;
+                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 t = optHooks.has(e, n);
+                if (t !== undefined) return t;
+            }
+        }
+        return n in t && !(t === e.pb && e.del?.has(n));
+    },
+    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, n) {
+        if (n === $OWNER || n === $RECORD) return undefined;
+        const t = getObserver();
+        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.io(e, n);
+        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 = t !== null && !inDraft(e) && !writeOverride;
+        const o = r && observerHoldsContainer(e, t);
+        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 t = getHasNode(e, n);
+            const r = read(t);
+            i = readSource(e, n, true);
+            if (!r && (!e.ch || t.l & CONFIG_OVERRIDE || !(n in i))) return undefined;
+        } else i = readSource(e, n, true);
+        let l;
+        if (optHooks && !o && optRead(e)) {
+            const t = optHooks.descriptor(e, n);
+            if (t === null) return undefined;
+            l = t;
+        }
+        l ??= visibleDescriptor(e, i, n);
+        if (l === undefined) return undefined;
+        if (!(n === "length" && Array.isArray(e))) l.configurable = true;
+        return l;
+    },
+    set(e, n, t) {
+        const r = inDraft(e);
+        if (!r && !writeOverride) {
+            return true;
+        }
+        if (n === "__proto__") return true;
+ // pollution guard (core R30)
+                const o = e.s ? t : unwrapValue(t);
+        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, n));
+        if (Array.isArray(i)) {
+            touch(e, n);
+            if (n === "length") e.wk = WK_ALL; else touch(e, "length");
+        } else {
+            touch(e, n);
+            if (!(n in i)) e.kc++;
+        }
+        const l = UNSAFE_KEYS.has(n);
+        if (l || e.ovl && e.sc !== 2 && !hasOwn.call(i, n)) {
+            Object.defineProperty(i, n, {
+                value: o,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        } else i[n] = o;
+        e.del?.delete(n);
+        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, n, t) {
+        const r = inDraft(e);
+        if (!r && !writeOverride) {
+            return true;
+        }
+        if (n === "__proto__") return true;
+        if (t.get || t.set) e.a = true;
+        if ("value" in t) t = {
+            ...t,
+            value: unwrapValue(t.value)
+        };
+        const o = ensurePB(e);
+        if (e.a || !(t.enumerable && t.writable && t.configurable)) e.sc = 1;
+        touch(e, n);
+        Object.defineProperty(o, n, t);
+        e.del?.delete(n);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
+    },
+    deleteProperty(e, n) {
+        const t = inDraft(e);
+        if (!t && !writeOverride) {
+            return true;
+        }
+        const r = ensurePB(e);
+        touch(e, n);
+        // 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, n);
+        if (hasOwn.call(r, n)) {
+            delete r[n];
+            o || e.kc--;
+        }
+        if (o) (e.del ??= new Set).add(n);
+        if (!t) 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, n) {
+    const t = e.k;
+    if (t === null) return false;
+    const r = t.Ze;
+    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Ne === n.de);
+}
+
+function storeSetter(e, n, t = true) {
+    if (writeHook !== null) writeHook(e);
+    const r = e[$TARGET];
+    const o = writeScopes;
+    writeScopes = new Set;
+    writeScopes.add(scopeKey(r));
+    const i = userWrite;
+    userWrite = t;
+    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 = n(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 n of e) notifyWrites(n);
+            // 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 n of e) if (n.pb !== null) foldTarget(n, n.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 && t && 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 (t && 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, n) {
+    const t = n?.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 (t) {
+        r[$TARGET].s = true;
+        markRawIngest(e);
+    }
+    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 n = e?.[$TARGET];
+    return n?.s === true;
+}
+
+/** True when `proxy` belongs to a projection family (S3). */ function storeHasFamily(e) {
+    const n = e?.[$TARGET];
+    return n?.fam != null;
+}
+
+/** True when `proxy` belongs to an OPTIMISTIC family (S4). */ function storeHasOptimisticFamily(e) {
+    const n = e?.[$TARGET];
+    return n?.fam?.opt === true;
+}
+
+// ---------------------------------------------------------------------------
+// enumeration views (one visibility rule for the traps AND the deep walk)
+function visibleKeys(e, n) {
+    let t;
+    if (e.ovl && n === e.pb) {
+        t = Reflect.ownKeys(e.v);
+        const r = e.del;
+        if (r?.size) t = t.filter(e => !r.has(e));
+        for (const r of Reflect.ownKeys(n)) {
+            if (!hasOwn.call(e.v, r)) t.push(r);
+        }
+    } else t = Reflect.ownKeys(n);
+    // The ownership stamp is the last symbol on an owned backing: hide it.
+        for (let e = t.length - 1; e >= 0 && typeof t[e] === "symbol"; e--) {
+        if (t[e] === $OWNER) {
+            t.splice(e, 1);
+            break;
+        }
+    }
+    return t;
+}
+
+function visibleDescriptor(e, n, t) {
+    let r = Object.getOwnPropertyDescriptor(n, t);
+    if (e.ovl && n === e.pb) {
+        if (e.del?.has(t)) return undefined;
+        if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
+    }
+    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 n = e?.[$TARGET];
+    if (n?.px !== e) return e;
+    const t = new Set;
+    const childTarget = (e, n, t) => {
+        let r = lookupTarget(n, e.fam);
+        if (r === undefined) {
+            if (!isWrappable(n)) return undefined;
+            wrap(n, e, t);
+            r = lookupTarget(n, e.fam) ?? n[$TARGET];
+        }
         return r;
+    };
+    const walkT = e => {
+        if (e.fam !== null) pullFamily(e);
+        const n = enumerationSource(e);
+        if (t.has(n)) return;
+        t.add(n);
+        read(getDeepNode(e));
+        // Through a chain (#3323): every inner record's container AND deep
+        // witness — base writes bump the inner witnesses.
+                for (let n = e; n.ch; ) {
+            n = n.v[$TARGET];
+            read(getContainerNode(n));
+            read(getDeepNode(n));
+        }
+        for (const t of visibleKeys(e, n)) {
+            const r = visibleDescriptor(e, n, t);
+            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, t, o);
+            const i = childTarget(e, o, t);
+            if (i === undefined) continue;
+ // raw-marked: leaf by contract
+                        walkT(i);
+        }
+    };
+    walkT(n);
+    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 n = e?.[$TARGET];
+    return snapshotWalk(e, new Map, n?.fam ?? null);
+}
+
+function snapshotWalk(e, n, t) {
+    if (e === null || typeof e !== "object") return e;
+    let r = e;
+    for (let e = true; ;e = false) {
+        const n = r?.[$TARGET]?.v !== undefined;
+        let o = n ? r[$TARGET] : undefined;
+        if (o === undefined && t !== null) o = lookupTarget(r, t);
+        if (o === undefined) o = lookupTarget(r, null);
+        if (o === undefined) break;
+        if (e && !n && t !== null && o.fam !== t) {
+            const e = t.map.get(o.px);
+            if (e !== undefined) o = e;
+        }
+        if (o.fam !== null) t = 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;
     }
-    const o = e.n?.[t] ?? nextAffectsNodeResolver(e, t);
-    // Keyed marks resolve by identity too (#2904): another store family's
-    // proxy can share this record's raw (a derived store swaps its backing to
-    // the source's raw when its projection lands), and reads through it never
-    // touch this target's node map. Scope is exactly the owning record's raw,
-    // narrowed to this key for witness and birth inheritance.
-        let r = affectsScopes.get(o);
-    if (!r) affectsScopes.set(o, r = {
-        scope: new Set,
-        inherited: [],
-        key: t
-    });
-    r.scope.add(e[STORE_VALUE]);
-    if (e.pb) r.scope.add(e.pb);
-    return [ o ];
-}
-
-export { $AFFECTS, $PROXY, $TARGET, $TRACK, STORE_HAS, STORE_NODE, STORE_VALUE, affectsScopesLive, getStoreAffectsNodes, getWriteOverride, inheritAffectsMarks, isRawValue, isWrappable, markRawIngest, markRawOne, nextAffectsNodeResolver, nextOptimisticViewResolver, ownEnumerableKeys, rawValuesUsed, setNextAffectsNodeResolver, setNextOptimisticViewResolver, setWriteOverride, witnessAffectsMark };
+    if (!isWrappable(r)) return r;
+    const o = n.get(r);
+    if (o !== undefined) return o;
+    if (isOwned(r)) {
+        const e = Array.isArray(r);
+        const o = e ? [] : Object.create(Object.getPrototypeOf(r));
+        n.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, n, t) : 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;
+    }
+    n.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, n, t);
+        if (u !== l) {
+            if (i === null) {
+                i = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                n.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, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, resolveChainedRaw, runDirect, sameKey, sameRow, snapshot, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetter, targetsEqual, unwrapValue, userWriting, wrap };