@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.7

package/dist/prod/store/next/store.js

@@ -1,6 +1,6 @@
 import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
-import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, context } from "../../core/core.js";
+import { setSlotUnobserved, setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, slotSignal, context } from "../../core/core.js";
 
 import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, setStoreCommitHook } from "../../core/scheduler.js";
 
@@ -10,8 +10,6 @@ import { $TARGET, isWrappable, markRawIngest, $PROXY, getWriteOverride, markRawO
 
 import { storeNextLookup, optHooks, ownedRaw, markDescendants, devAssertNeverUserMutation } from "./target.js";
 
-import { patchHooks, rowHooks } from "./patch-hooks.js";
-
 /**
  * Store rewrite — increment 2: plain deep stores with pending-backing writes.
  * Contract: INTERNALS-STORE-STATE.md.
@@ -44,9 +42,9 @@ import { patchHooks, rowHooks } from "./patch-hooks.js";
  *
  * 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 — write-side patch-channel
- * state lives inside the single `pc` extension (see target.ts), never as
- * new named fields here. */
+ * 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;
@@ -62,29 +60,18 @@ function TargetShape() {
     this.a = undefined;
     this.sc = undefined;
     this.nc = undefined;
-    this.adopted = undefined;
+    this.ab = undefined;
     this.fam = undefined;
     this.s = undefined;
     this.ovl = undefined;
     this.del = undefined;
-    this.pc = undefined;
+    this.wk = undefined;
     this.hv = undefined;
     this.ht = undefined;
 }
 
 TargetShape.prototype = Object.prototype;
 
-/** Lazily allocate the patch-channel extension (one literal shape). */ function pcOf(e) {
-    return e.pc ?? (e.pc = {
-        sp: null,
-        p: null,
-        ro: null,
-        wk: null,
-        qa: null,
-        qe: null
-    });
-}
-
 function createTarget(e, t, n, r = t?.fam ?? null) {
     // The proxy target carries the array exotic class when the value is an
     // array, so Array.isArray(proxy) is true; the fields live on it directly.
@@ -101,7 +88,7 @@ function createTarget(e, t, n, r = t?.fam ?? null) {
     i.h = null;
     i.k = null;
     i.dk = null;
-    i.pc = null;
+    i.wk = null;
     i.u = t;
     i.pk = n;
     i.px = null;
@@ -109,7 +96,7 @@ function createTarget(e, t, n, r = t?.fam ?? null) {
     i.a = false;
     i.sc = false;
     i.nc = 0;
-    i.adopted = false;
+    i.ab = null;
     i.fam = r;
     i.s = false;
     i.ovl = false;
@@ -155,55 +142,68 @@ function wrapNext(e, t = null, n = null, r = t?.fam ?? null) {
 
 // ---------------------------------------------------------------------------
 // nodes: pure subscription points (values used only for equality gating)
-function getNode(e, t, n) {
-    const r = e.n ??= Object.create(null);
-    let i = r[t];
-    if (i === undefined) {
-        const o = i = signal(n, {
-            // 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).
-            equals: (t, n) => isEqual(t, n) || sameLogicalSlot(e, t, n),
-            unobserved() {
-                // A live affects() mark keeps the node addressable (sweep parity).
-                if (o.o?.t) return;
-                if (e.n && e.n[t] === o) {
-                    delete e.n[t];
-                    e.nc--;
-                }
-            }
-        }, 
-        // Projection nodes carry the projection computed as their firewall:
-        // reads through them link the derive's status/lifecycle (§7b).
-        e.fam?.node ?? undefined);
-        // Store nodes are ownedWrite: the setter carries the owned-scope write
-        // guard; node-level setSignals are internal notification machinery.
-                o.T |= CONFIG_OWNED_WRITE;
-        // Accessor-ness resolved ONCE per node (no per-object descriptor scan):
-        // accessor keys serve through Reflect.get with the proxy receiver.
-                o.acc = isOwnAccessor(e.pb ?? e.v, t);
-        // Wrap cache: the proxy last served for this key and the raw it wrapped.
-        // Raw-as-truth stores raw in nodes, so every object read needs a wrapper;
-        // one pointer compare (pxv === value) replaces the per-read WeakMap
-        // lookup in wrapNext — the dominant read-path cost vs legacy, whose
-        // nodes stored pre-wrapped values. A replaced child fails the compare
-        // and re-wraps; at most one stale proxy is pinned until the next read.
-                o.px = undefined;
-        o.pxv = undefined;
+// Shared slot-node equality (create-floor diet): ONE function for every
+// store node — `this` is the node (method-call convention at every _equals
+// site), `_host` is the baked-in target backref. Logical-slot equality:
+// values resolving to the same child target are the same slot
+// (privatization/adoption swap raw identity without changing the logical
+// value — only changed leaves notify, R9).
+const slotNodeEquals = function(e, t) {
+    return isEqual(e, t) || sameLogicalSlot(this.ht, e, t);
+};
+
+// Shared slot-node unobserved handler (create-floor diet): registered once;
+// the core sweep dispatches CONFIG_SLOT_NODE nodes here instead of holding a
+// per-node closure in a per-node NodeExtension.
+setSlotUnobserved(e => {
+    // A live affects() mark keeps the node addressable (sweep parity).
+    if (e.o?.t) return;
+    const t = e.ht;
+    const n = e.Ht;
+    if (t.n && t.n[n] === e) {
+        delete t.n[n];
+        t.nc--;
+    }
+});
+
+function getNode(e, t, 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.
+r = -1) {
+    const i = e.n ??= Object.create(null);
+    let o = i[t];
+    if (o === undefined) {
+        // Create-floor diet: slotSignal bakes the whole node into one literal —
+        // no options object, no equals/unobserved closures, no NodeExtension,
+        // no post-construction expandos (acc + the wrap cache px/pxv are
+        // pre-shaped fields: the proxy last served for this key and the raw it
+        // wrapped — one pointer compare replaces the per-read WeakMap lookup in
+        // wrapNext). ownedWrite rides the literal's config: the setter carries
+        // the owned-scope write guard; node-level setSignals are internal
+        // notification machinery. Projection nodes carry the projection
+        // computed as their firewall: reads through them link the derive's
+        // status/lifecycle (§7b).
+        const f = o = slotSignal(n, slotNodeEquals, e, t, 
+        // Accessor-ness resolved ONCE per node (no per-object descriptor
+        // scan on reads): accessor keys serve through Reflect.get with the
+        // proxy receiver.
+        r === -1 ? isOwnAccessor(e.pb ?? e.v, t) : r === 1, e.fam?.node ?? undefined);
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(o).Pe = NOT_PENDING;
-            o.T |= CONFIG_OPTIMISTIC;
+            ext(f).Pe = NOT_PENDING;
+            f.T |= CONFIG_OPTIMISTIC;
         }
         // A node born inside a live mark's identity scope inherits the mark
         // (the declaration walk could only cover nodes existing then).
-                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
-        r[t] = i;
+                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(f, e.v, t);
+        i[t] = o;
         e.nc++;
         markDescendants(e);
     }
-    return i;
+    return o;
 }
 
 function sameLogicalSlot(e, t, n) {
@@ -305,10 +305,12 @@ function cloneRaw(e, t) {
     return Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
 }
 
-/** Scanned plainness for patch admission (patchableRaw): runs the one-time
- * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
- * trustworthy before a scan (it starts false and is discovered lazily). */ function targetIsPlain(e) {
-    return e.sc ? !e.a : scanAccessorsOnce(e);
+/** Copy own `key` from `from` onto `to`. A plain data slot (enumerable,
+ * writable, configurable, no accessor) is a bare assignment — the common case
+ * and the cheap one; anything else goes through defineProperty so accessors
+ * and attribute flags survive the copy. */ function copyOwn(e, t, n) {
+    const r = Object.getOwnPropertyDescriptor(t, n);
+    if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, n, r); else e[n] = r.value;
 }
 
 /** One-time own-accessor scan (Annex-B probes, no descriptor allocation);
@@ -333,10 +335,7 @@ function cloneRaw(e, t) {
     if (!e.ovl) return;
     const t = e.pb;
     const n = cloneRaw(e.v, e);
-    for (const e of Reflect.ownKeys(t)) {
-        const r = Object.getOwnPropertyDescriptor(t, e);
-        if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(n, e, r); else n[e] = r.value;
-    }
+    for (const e of Reflect.ownKeys(t)) copyOwn(n, t, e);
     if (e.del !== null) {
         for (const t of e.del) delete n[t];
         e.del = null;
@@ -439,7 +438,18 @@ function ensurePB(e) {
     if (!n) {
         queueFold(e);
  // records the pre-batch old before we swap
-                e.adopted = true;
+        // Diff base = the view the nodes were last told (#3296). A draft's
+        // setter-exit notifications already moved them to its pending backing,
+        // so a later adoption diffs against THAT — against committed, a key the
+        // draft changed and the adoption restores would never re-notify. An
+        // adoption with no draft leaves nodes where they were: keep an existing
+        // base, else the pre-batch committed (foldOlds' entry itself stays the
+        // committed identity for the path-copy CAS). Eager callers read t.pb
+        // directly; this hand-off exists because pb is gone by drain time.
+                if (e.pb !== null) {
+            if (e.ovl) materializePB(e);
+            e.ab = e.pb;
+        } else e.ab ??= foldOlds.get(e);
         // #3074/#3075: a projection recompute deriving from uncommitted inputs
         // swaps the backing SPECULATIVELY — committed-visibility readers must
         // keep the pre-hold view until the hold resolves (a source held by a
@@ -467,7 +477,7 @@ function ensurePB(e) {
     e.del = null;
     e.sc = false;
     e.a = false;
-    if (e.pc !== null) e.pc.wk = null;
+    e.wk = null;
  // adoption supersedes staged trap writes
         e.v = t;
     e.ch = t[$TARGET] !== undefined;
@@ -517,20 +527,56 @@ function queueFold(e) {
  * transition is ambient). Entries die with their draft — tentative backings
  * are consumed at setter exit. */ const tentativePBs = new WeakSet;
 
+/** A draft read composes the live optimistic view until the draft has opened
+ * its OWN view-seeded backing (ensurePB seeds that clone from the view and
+ * registers it in tentativePBs; from then on reads must see the draft's
+ * writes, not the overrides they superseded). A pending backing that exists
+ * for any other reason is not that clone — a truth landing staged into a
+ * retaining transaction (#3164 fold) is authoritative truth WITHOUT the
+ * live overrides. ensurePB parks such a backing on the draft's first WRITE
+ * and reseeds from the view, but the reads that precede that write went to
+ * the staged truth: `votes++` read base, wrote base+1, and the override it
+ * emitted landed on the value already displayed — a second in-flight
+ * increment made after a sibling's landing was invisible (#2951's compose
+ * half, one landing later). */ function draftSeesOverrides(e) {
+    return e.pb === null || !tentativePBs.has(e.pb);
+}
+
 /** Committed-time privatization for parent-chain slot updates (path copying). */ function privatizeCommitted(e) {
     if (ownedRaw.has(e.v)) return;
-    const t = cloneRaw(e.v, e);
-    ownedRaw.add(t);
-    storeNextLookup.set(t, e);
-    e.v = t;
+    const t = e.v;
+    const n = cloneRaw(t, e);
+    ownedRaw.add(n);
+    // Register in the target's OWN registration map (#3284): family targets
+    // (derived stores, projections, optimistic) resolve children through
+    // fam.map — a clone parked only in the global lookup makes the next parent
+    // read miss, wrap a fresh target, and orphan every node (subscribers) on
+    // this one.
+        (e.fam?.map ?? storeNextLookup).set(n, e);
+    e.v = n;
     e.ch = false;
     if (e.u) {
         privatizeCommitted(e.u);
         devAssertNeverUserMutation(e.u.v);
-        e.u.v[e.pk] = e.v;
+        e.u.v[parentSlotKey(e, t)] = e.v;
     }
 }
 
+/** Resolve the slot this child currently occupies in its parent's committed
+ * backing (#3282). `pk` is stamped at wrap time and arrays MOVE: a reverse/
+ * unshift/splice relocates the raw, and a fold that re-points the wrap-time
+ * slot writes the clone over whichever row lives there now. Objects never
+ * move keys, so the stamp is authoritative; for arrays, verify and re-locate
+ * by identity when stale (fold-time only — never on a read path). */ function parentSlotKey(e, t) {
+    const n = e.pk;
+    const r = e.u.v;
+    if (r[n] === t || !Array.isArray(r)) return n;
+    const i = r.indexOf(t);
+    if (i === -1) return n;
+    e.pk = i;
+    return i;
+}
+
 function drainFolds() {
     if (foldOlds.size === 0) return;
     const e = [ ...foldOlds ];
@@ -540,11 +586,6 @@ function drainFolds() {
         // is committing the batch the pull ran ahead of. Transition holds stay —
         // they clear when their transition is done (heldMaskView).
         if (t.ht === PLAIN_HOLD) t.ht = t.hv = null;
-        // Eager (write-override) family folds swap pb -> v at notifyWrites'
-        // tail: by the time this drain runs they carry no pb, and their
-        // structural ops must emit at the fold-commit site below (the clone
-        // branch never sees them). Re-audit blocker 4.
-                const e = t.pb === null;
         if (t.pb !== null) {
             // #3089: a fold written under a still-running transition defers to
             // that transition's settle (the write-time stamp covers unobserved
@@ -568,7 +609,7 @@ function drainFolds() {
                 // Only written keys can hold (their nodes took the setSignal); the
                 // wk bound keeps this O(written) — see notifyWrites. Same fallback
                 // rules as the notify (WK_ALL / accessors / non-plain prototypes).
-                const e = t.pc !== null ? t.pc.wk : null;
+                const e = t.wk;
                 const n = e === null || e === WK_ALL || t.a === true || 
                 // Overlay pbs chain to the COMMITTED object (#3044) — plainness is
                 // the committed container's prototype, not the overlay's.
@@ -596,10 +637,7 @@ function drainFolds() {
                 // — the never-mutate-user-data contract holds.
                 privatizeCommitted(t);
                 const e = t.v;
-                for (const t of Reflect.ownKeys(i)) {
-                    const n = Object.getOwnPropertyDescriptor(i, t);
-                    if (n.get || n.set || !n.enumerable || !n.writable || !n.configurable) Object.defineProperty(e, t, n); else e[t] = n.value;
-                }
+                for (const t of Reflect.ownKeys(i)) copyOwn(e, i, t);
                 if (t.del !== null) {
                     for (const n of t.del) delete e[n];
                     t.del = null;
@@ -607,67 +645,78 @@ function drainFolds() {
                 (t.fam?.map ?? storeNextLookup).delete(i);
                 t.pb = null;
                 t.ovl = false;
-                if (t.pc !== null) t.pc.wk = null;
+                t.wk = null;
+ // written-keys window closes with the fold commit
+                        } else if (t.v !== n) {
+                // Privatized mid-batch (#3271): an earlier fold in this drain
+                // path-copied THROUGH this target — privatizeCommitted cloned the
+                // committed backing, re-pointed the parent slot at the clone, and
+                // stitched the descendant's fold into it. The draft's pb predates
+                // that: swapping it in would clobber the descendant's fold, and the
+                // parent CAS below (still comparing against `old`) would fail and
+                // orphan this fold entirely — a projection draft writing descendant-
+                // then-ancestor silently lost the ancestor write. Merge the batch's
+                // writes onto the current container instead (the parent slot already
+                // points at it). privatize first: an adopt-then-write batch can land
+                // here with an unowned adoptee as t.v.
+                privatizeCommitted(t);
+                const e = t.v;
+                const r = t.wk;
+                if (r !== null && r !== WK_ALL) {
+                    // The trap records every write/delete key — apply exactly those.
+                    for (const t of r) {
+                        if (hasOwn.call(i, t)) copyOwn(e, i, t); else delete e[t];
+                    }
+                } else {
+                    // Array length write poisoned the bound (WK_ALL) — value-diff
+                    // against the pre-batch old. Slots the draft never touched hold
+                    // the same raw reference in both, so descendant folds stay put.
+                    // Not copyOwn: the plain-value write is GATED on "the draft changed
+                    // this slot" — an untouched slot in pb holds the pre-batch reference,
+                    // and writing it back would clobber a descendant fold stitched into v.
+                    for (const t of Reflect.ownKeys(i)) {
+                        const r = Object.getOwnPropertyDescriptor(i, t);
+                        if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, t, r); else if (r.value !== n[t] || !hasOwn.call(n, t)) e[t] = r.value;
+                    }
+                    for (const t of Reflect.ownKeys(n)) {
+                        if (!hasOwn.call(i, t)) delete e[t];
+                    }
+                }
+                (t.fam?.map ?? storeNextLookup).delete(i);
+                t.pb = null;
+                t.wk = null;
  // written-keys window closes with the fold commit
                         } else {
-                // Setter-channel structural ops: a fold that changes an array's shape
-                // (push/splice/permutation through the setter — the reconcile walk
-                // never queues here) is a structural visibility transition for any
-                // registered list driver. Identity-keyed; aligned folds emit nothing.
-                // Family targets defer to their own adoption emission (fam reconcile).
-                // Arrays always fold on this clone branch (overlay is non-array only).
-                // Family setter drafts (writable projection push/splice through the
-                // masked setter) fold on this branch too and the fold IS their
-                // visibility moment — emit unless the structure already rode another
-                // channel: adoption folds (reconcile walk emitted ops) and
-                // optimistic families (lane-timed override channel). Re-audit
-                // blocker 4.
-                if (t.pc !== null && t.pc.ro !== null && !t.adopted && t.fam?.opt !== true && Array.isArray(i) && Array.isArray(t.v)) rowHooks.emitSetterRowOps(t, t.v, i);
                 t.v = i;
                 t.ch = false;
  // pb is always a plain clone
                                 t.pb = null;
-                if (t.pc !== null) t.pc.wk = null;
+                t.wk = null;
  // written-keys window closes with the fold commit
                         }
         }
-        if (t.v === n) {
-            // A no-op adoption (A -> B -> A before flush) still consumed its walk:
-            // clear the flag or every later setter row-op gate (!t.adopted) stays
-            // failed and a driven family list freezes (re-audit 5, P1-1).
-            t.adopted = false;
-            continue;
-        }
-        // Patch channel (fold-commit site): family targets emit HERE — the fold
-        // IS their visibility moment (held folds re-queued above emit when they
-        // actually commit) — and so do PLAIN fold-adopted targets (setter-
-        // returned root replacements, chained-store swaps: adoptions WITHOUT a
-        // reconcile walk, so no walk-site emission ever happened — re-audit 2,
-        // P1-2). Plain eager targets emitted at their walk/setter sites already.
-                if (t.pc !== null && (t.fam !== null || t.adopted)) {
-            // Structural ops for folds whose structure rode no other channel:
-            // eager-folded family SETTER drafts (write-override swaps pb -> v at
-            // notifyWrites' tail — the clone branch never sees them; adoption
-            // folds re-emitting would double the walk's ops) and PLAIN fold
-            // adoptions (no walk at all). Optimistic families ride the override
-            // channel (lane-timed ops + revert RESYNC) — never re-emit here.
-            if (t.pc.ro !== null && t.fam?.opt !== true && (t.fam !== null ? e && !t.adopted : t.adopted) && Array.isArray(t.v) && Array.isArray(n)) rowHooks.emitSetterRowOps(t, n, t.v);
-            if (t.pc.p !== null) {
-                // Accessor demotion at the fold-commit seam is DEV-ONLY (see the
-                // reconcile seam note: prod never pays per-adoption scans).
-                patchHooks.emitPatchLocal(t, t.v, n);
+        const e = t.ab;
+        t.ab = null;
+        if (t.v !== n) {
+            // Path copying (CAS: see the eager-fold twin above). Slot resolved by
+            // identity (#3282): an array move relocated the raw, so the wrap-time
+            // pk may point at a sibling — a raw-slot CAS there both failed to
+            // re-point AND (via privatizeCommitted's unguarded write) clobbered
+            // the sibling.
+            if (t.u) {
+                const e = parentSlotKey(t, n);
+                if (t.u.v[e] === n) {
+                    privatizeCommitted(t.u);
+                    devAssertNeverUserMutation(t.u.v);
+                    t.u.v[e] = t.v;
+                }
             }
         }
-        // Path copying (CAS: see the eager-fold twin above).
-                if (t.u && t.u.v[t.pk] === n) {
-            privatizeCommitted(t.u);
-            devAssertNeverUserMutation(t.u.v);
-            t.u.v[t.pk] = t.v;
-        }
-        if (t.adopted) {
-            t.adopted = false;
-            notifyFold(t, n, t.v);
-        }
+        // Adoption notify against the base the nodes were last told (#3296). A
+        // no-op adoption (A -> B -> A before flush, no draft) has base === v and
+        // nothing to say; a draft superseded by an adoption back to the SAME raw
+        // still has (base = pending backing) !== v and must notify.
+                if (e !== null && e !== t.v) notifyFold(t, e, t.v);
     }
 }
 
@@ -717,7 +766,7 @@ function drainFolds() {
     // 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).
-        const i = e.pc !== null ? e.pc.wk : null;
+        const i = e.wk;
     // Overlay pbs chain to the COMMITTED object (#3044): a prototype-overlay
     // draft is plain data on its own layer, but its getPrototypeOf is the
     // committed container — judge plainness by the COMMITTED prototype or the
@@ -749,15 +798,15 @@ function drainFolds() {
             // projection recompute can run before the prior fold commits) — the
             // node's OWN current value is the true old side, and setSignal's
             // internal equality already checks exactly that.
-                        const l = e.del !== null && e.del.has(o) ? undefined : t[o];
-            setSignal(i, () => l);
+                        const f = e.del !== null && e.del.has(o) ? undefined : t[o];
+            setSignal(i, () => f);
         }
     }
-    const l = e.h;
-    if (l !== null) {
-        const n = o ?? Reflect.ownKeys(l);
+    const f = e.h;
+    if (f !== null) {
+        const n = o ?? Reflect.ownKeys(f);
         for (const r of n) {
-            const n = l[r];
+            const n = f[r];
             if (n !== undefined) setSignal(n, r in t && !(e.del !== null && e.del.has(r)));
         }
     }
@@ -791,12 +840,6 @@ function drainFolds() {
         }
         if (r) setSignal(e.k, e => e + 1);
     }
-    // Patch channel (setter site): a committed write transitions this record —
-    // queue its patches and bubble to ancestors (targeted nested writes must
-    // reach the row patch, §4b). One number compare when no patches exist.
-    // Family targets skip this site: their visibility moment is the FOLD
-    // commit (drainFolds emits), not the recompute/draft write.
-        if (e.fam === null && patchHooks !== null && patchHooks.hasPatches()) patchHooks.emitPatch(e, t, n);
     // Projection backing folds split by channel (two pinned contracts):
     // - sync-derive drafts (recompute body): NEVER eager — a downstream async
     //   hold can form LATER in the same flush and the leaf must stay at stale
@@ -821,10 +864,14 @@ function drainFolds() {
         e.pb = null;
         e.v = t;
         e.ch = false;
-        if (e.u && e.u.v[e.pk] === n) {
-            privatizeCommitted(e.u);
-            devAssertNeverUserMutation(e.u.v);
-            e.u.v[e.pk] = t;
+        if (e.u) {
+            // Identity-resolved slot (#3282) — see drainFolds' path-copy twin.
+            const r = parentSlotKey(e, n);
+            if (e.u.v[r] === n) {
+                privatizeCommitted(e.u);
+                devAssertNeverUserMutation(e.u.v);
+                e.u.v[r] = t;
+            }
         }
     }
 }
@@ -881,9 +928,9 @@ i = true) {
             if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
             return;
         }
-        const l = i?.value;
-        const f = o?.value;
-        if (!isEqual(l, f) && !targetsEqual(l, f)) setSignal(e, typeof f === "function" ? () => f : f);
+        const f = i?.value;
+        const l = o?.value;
+        if (!isEqual(f, l) && !targetsEqual(f, l)) setSignal(e, typeof l === "function" ? () => l : l);
     } else {
         const i = n[t];
         const o = r[t];
@@ -1008,7 +1055,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Gt ? e.Dt : e;
+    const t = e.Dt ? e.Pt : e;
     return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -1019,7 +1066,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * committed to them regardless of staged writes. */ function inForbiddenScope() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Gt ? e.Dt : e;
+    const t = e.Dt ? e.Pt : e;
     return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -1171,15 +1218,15 @@ function isOwnAccessor(e, t) {
  * holds, lanes ride the node); backing otherwise. Chained backings (§7b: the
  * backing IS another store's proxy) serve the read-through value — the outer
  * node is linked only for adoption-swap notification, its value never
- * shadows the live chain. */ function serveDataKey(e, t, n, r, i) {
-    const o = e.ch && r === e.v;
+ * shadows the live chain. */ function serveDataKey(e, t, n, r, i, o = -1) {
+    const f = e.ch && r === e.v;
     let l = n;
     // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
     // (backing ± presence overrides) for both length and indices makes torn
     // iteration impossible (a length node's value rides different visibility
     // rails than index overrides mid-settle). The node still carries
     // subscriptions; its value is never served here.
-        if (t === "length" && e.fam?.opt === true && !o && Array.isArray(r)) {
+        if (t === "length" && e.fam?.opt === true && !f && Array.isArray(r)) {
         if (!inDraft(e)) {
             const r = e.n?.length;
             if (r !== undefined) {
@@ -1199,7 +1246,7 @@ function isOwnAccessor(e, t) {
         // #2951). Once ensurePB runs, the seeded clone carries the view.
         // AUTHORITATIVE drafts (projection derive) never overlay — ensurePB's
         // seeding rule, applied to the read side (#3108).
-        if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
+        if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.n?.[t];
             if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
         }
@@ -1213,12 +1260,14 @@ function isOwnAccessor(e, t) {
                 // parity): READ_SLOW = a global read window or non-plain node.
                 let e = readNodeFast(i);
                 if (e === READ_SLOW) e = read(i);
-                if (!o || hasActiveOverride(i)) l = e === FORCE ? n : e;
-            } else if (!o || hasActiveOverride(i)) {
+                if (!f || hasActiveOverride(i)) l = e === FORCE ? n : e;
+            } else if (!f || hasActiveOverride(i)) {
                 l = nodeValue(i, n);
             }
         } else if (getObserver() !== null) {
-            read(getNode(e, t, n));
+            // First tracked read: create + link, and let the wrap-cache branch
+            // below populate px/pxv so read #2 skips wrapNext (slice 2).
+            read(i = getNode(e, t, n, o));
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
@@ -1320,8 +1369,11 @@ const traps = {
         // tracked read of a present data key — the dbmon/uibench effect re-read
         // shape. Skips serveDataKey's frame, the FORCE compare (only accessor
         // keys ever hold the sentinel), and isWrappable for primitives.
-                if (e.ch === false && writeScopes === null) {
-            const n = e.n?.[t];
+        // ONE node-map lookup serves this block and the accessor probe below
+        // (nothing between them creates nodes).
+                const i = e.n?.[t];
+        if (e.ch === false && writeScopes === null) {
+            const n = i;
             if (n !== undefined && n.acc !== true && getObserver() !== null) {
                 let r = readNodeFast(n);
                 if (r === READ_SLOW) r = read(n);
@@ -1349,14 +1401,22 @@ const traps = {
         // absent-key/accessor subscriptions for every store read during any
         // derive, leaving nested projections permanently dependency-less when
         // their sources hadn't materialized yet (#3037).
-                const i = e.n?.[t];
+        // First-read dedupe (create-floor slice 2): remember the probe verdict —
+        // node creation downstream reuses it instead of re-scanning the
+        // descriptor, but only when the probed object IS the one getNode would
+        // scan (pb ?? v).
+                let o = -1;
         {
-            const o = i !== undefined ? i.acc === true : !inDraft(e) && getObserver() !== null && isOwnAccessor(r, t);
-            if (o) {
-                if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined));
-                const o = Reflect.get(r, t, n);
-                if (e.s) return serveShallow(e, t, o);
-                return isWrappable(o) ? draftServe(e, wrapNext(o, e, t)) : o;
+            let f;
+            if (i !== undefined) f = i.acc === true; else if (!inDraft(e) && getObserver() !== null) {
+                f = isOwnAccessor(r, t);
+                if (r === (e.pb ?? e.v)) o = f ? 1 : 0;
+            } else f = false;
+            if (f) {
+                if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined, o));
+                const f = Reflect.get(r, t, n);
+                if (e.s) return serveShallow(e, t, f);
+                return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
             }
         }
         // Plain-data fast path: no descriptor allocation per read.
@@ -1366,10 +1426,10 @@ const traps = {
         // backings chain to the committed backing, so "own in the view" means
         // own on either layer (ownInView) — a genuine prototype method is one
         // that is own on NEITHER.
-                const o = e.ovl && r === e.pb;
-        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return undefined;
+                const f = e.ovl && r === e.pb;
+        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t))) return undefined;
         let l = r[t];
-        if (l === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
+        if (l === undefined ? !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
             l = Reflect.get(r, t, n);
             if (typeof l === "function") return l;
@@ -1377,14 +1437,14 @@ const traps = {
             // Reading a currently-absent own key subscribes to it (R12) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
                         if (l === undefined && !inDraft(e)) {
-                if (getObserver() !== null) read(getNode(e, t, undefined));
+                if (getObserver() !== null) read(getNode(e, t, undefined, o));
                 const n = e.n?.[t];
                 if (n) {
                     const r = nodeValue(n, undefined);
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (l === undefined && inDraft(e) && e.fam?.opt && e.pb === null && 
+            } else if (l === undefined && inDraft(e) && e.fam?.opt && draftSeesOverrides(e) && 
             // AUTHORITATIVE drafts (landing folds) never seed from overrides —
             // the caller's optimism is not truth (has-trap twin below).
             !authoritativeServe()) {
@@ -1394,9 +1454,9 @@ const traps = {
             if (e.s) return serveShallow(e, t, l);
             return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
         }
-        if (typeof l === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return l;
+        if (typeof l === "function" && !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t))) return l;
  // proto method
-                return serveDataKey(e, t, l, r, i);
+                return serveDataKey(e, t, l, r, i, o);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
@@ -1417,7 +1477,7 @@ const traps = {
                 const n = e.h?.[t];
                 if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
             }
-        } else if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
+        } else if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.h?.[t];
             if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
         }
@@ -1444,7 +1504,7 @@ const traps = {
         // Draft reads before the first write overlay too (pb, once created, is
         // seeded with the view). Authoritative-view reads (until()'s predicate,
         // truth-author drafts) skip the overlay.
-                if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
+                if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || draftSeesOverrides(e))) {
             let t = null;
             for (const r of Reflect.ownKeys(e.h)) {
                 const i = e.h[r];
@@ -1504,23 +1564,22 @@ const traps = {
         // passes through by reference (#2932; markRawOne skips proxies), while
         // deep stores unwrap to raw backings.
                 const o = e.s ? n : unwrapValue(n);
-        const l = ensurePB(e);
+        const f = ensurePB(e);
         pendingNotify.add(e);
         // Array length writes implicitly delete indices — the written-keys bound
         // can't see them, so poison to the full scan for this batch. Index
         // writes implicitly GROW length, so arrays always record it alongside.
-                const f = pcOf(e);
-        if (Array.isArray(l)) {
-            if (t === "length") f.wk = WK_ALL; else if (f.wk !== WK_ALL) {
-                const e = f.wk ??= new Set;
-                e.add(t);
-                e.add("length");
+                if (Array.isArray(f)) {
+            if (t === "length") e.wk = WK_ALL; else if (e.wk !== WK_ALL) {
+                const n = e.wk ??= new Set;
+                n.add(t);
+                n.add("length");
             }
-        } else if (f.wk !== WK_ALL) (f.wk ??= new Set).add(t);
+        } else if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         // Own data keys literally named "prototype"/"constructor" land as data —
         // defineProperty sidesteps a proto-chain setter named the same.
                 if (UNSAFE_KEYS.has(t)) {
-            Object.defineProperty(l, t, {
+            Object.defineProperty(f, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
@@ -1532,14 +1591,14 @@ const traps = {
         // Overlay first-write DEFINES the own key: assignment through the proto
         // chain would reject on a non-writable committed property (the clone
         // path normalized descriptors for exactly this — R51 parity).
-                if (e.ovl && !hasOwn.call(l, t)) {
-            Object.defineProperty(l, t, {
+                if (e.ovl && !hasOwn.call(f, t)) {
+            Object.defineProperty(f, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else l[t] = o;
+        } else f[t] = o;
         if (e.del !== null) e.del.delete(t);
         // Shallow ingest: written records are sticky raw-marked (one entity is
         // never both deep-wrapped and raw — R41/#2932, shared invariant).
@@ -1554,14 +1613,7 @@ const traps = {
         const i = !r && getWriteOverride();
         if (!r && !i) return true;
         if (t === "__proto__") return true;
-        if (n.get || n.set) {
-            e.a = true;
-            // Accessor demotion (re-audit blocker 3): a record that acquires an
-            // accessor after patch registration stops being patchable — pull its
-            // patches and re-drive them as tracked effect fallbacks. Hooks are
-            // installed whenever pc.p exists (registration installs them).
-                        if (e.pc !== null && e.pc.p !== null) patchHooks.demoteToEffects(e);
-        }
+        if (n.get || n.set) e.a = true;
         // Unwrap before ensurePB (see the set trap: self-reference materializes).
                 if ("value" in n) n = {
             ...n,
@@ -1569,8 +1621,7 @@ const traps = {
         };
         const o = ensurePB(e);
         pendingNotify.add(e);
-        const l = pcOf(e);
-        if (l.wk !== WK_ALL) (l.wk ??= new Set).add(t);
+        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         Object.defineProperty(o, t, n);
         if (e.del !== null) e.del.delete(t);
         if (i) notifyWrites(e);
@@ -1582,8 +1633,7 @@ const traps = {
         if (!n && !r) return true;
         const i = ensurePB(e);
         pendingNotify.add(e);
-        const o = pcOf(e);
-        if (o.wk !== WK_ALL) (o.wk ??= new Set).add(t);
+        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         delete i[t];
         // A prototype overlay cannot shadow a delete of a committed key —
         // record it aside (#3044); reads/has/ownKeys/commit consult the set.
@@ -1647,6 +1697,10 @@ function createStoreNext(e, t = false) {
     return [ n, setter ];
 }
 
+// ---------------------------------------------------------------------------
+// snapshot (next targets): the backing IS the plain raw graph — zero copy.
+// Sees pending (R27) by reading pb. Chained/owned-copy caching lands with the
+// utilities increment; this covers the createStore-suite contract.
 /** 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) {
@@ -1696,8 +1750,24 @@ function createStoreNext(e, t = false) {
         read(getKeySetNode(e));
         read(getDeepNode(e));
         const r = e.fam?.map ?? storeNextLookup;
-        for (const n of Reflect.ownKeys(t)) {
-            const i = Object.getOwnPropertyDescriptor(t, n);
+        // Overlay pending backings chain to the committed object (#3044): their
+        // OWN keys are only this batch's writes. A bare ownKeys walk mid-flush
+        // (effects recompute before the fold commits) missed every untouched
+        // child, so the re-subscribing effect dropped those records from its
+        // dependency set — later child edits never notified it (#3283). Merge
+        // committed keys, minus deletes, exactly as the ownKeys trap does.
+                let i = Reflect.ownKeys(t);
+        if (e.ovl && t === e.pb) {
+            const t = Reflect.ownKeys(e.v);
+            const n = e.del;
+            const r = n !== null && n.size !== 0 ? t.filter(e => !n.has(e)) : t;
+            for (const t of i) {
+                if (!hasOwn.call(e.v, t)) r.push(t);
+            }
+            i = r;
+        }
+        for (const n of i) {
+            const i = Object.getOwnPropertyDescriptor(t, n) ?? Object.getOwnPropertyDescriptor(e.v, n);
             if (i === undefined) continue;
             if (i.get || i.set) {
                 e.a = true;
@@ -1708,15 +1778,15 @@ function createStoreNext(e, t = false) {
             if (o === null || typeof o !== "object") continue;
             // Stored proxies (chained slots) resolve through their own target;
             // raw children through the family map, created on first visit.
-                        let l = o[$TARGET] ?? r.get(o);
-            if (l === undefined) {
+                        let f = o[$TARGET] ?? r.get(o);
+            if (f === undefined) {
                 if (!isWrappable(o)) continue;
                 wrapNext(o, e, n);
-                l = r.get(o);
-                if (l === undefined) continue;
+                f = r.get(o);
+                if (f === undefined) continue;
  // raw-marked: leaf by contract
                         }
-            walkT(l);
+            walkT(f);
         }
     };
     walkT(t);
@@ -1775,15 +1845,15 @@ function snapshotWalk(e, t, n) {
             const i = t.get(r);
             if (i !== undefined) return i;
             const o = Array.isArray(e);
-            const l = o ? [] : Object.create(Object.getPrototypeOf(e));
-            t.set(r, l);
+            const f = o ? [] : Object.create(Object.getPrototypeOf(e));
+            t.set(r, f);
             for (const r of Reflect.ownKeys(e)) {
                 if (o && r === "length") continue;
                 const i = e[r];
-                l[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
+                f[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
             }
-            if (o) l.length = e.length;
-            return l;
+            if (o) f.length = e.length;
+            return f;
         }
     }
     const o = t.get(r);
@@ -1798,17 +1868,17 @@ function snapshotWalk(e, t, n) {
         t.set(r, i);
         for (const o of Reflect.ownKeys(r)) {
             if (e && o === "length") continue;
-            const l = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !l.enumerable) continue;
-            if (l.get || l.set) {
-                Object.defineProperty(i, o, l);
+            const f = Object.getOwnPropertyDescriptor(r, o);
+            if (typeof o === "symbol" && !f.enumerable) continue;
+            if (f.get || f.set) {
+                Object.defineProperty(i, o, f);
                 continue;
             }
-            const f = l.value;
-            const u = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
-            if (l.enumerable && l.writable && l.configurable) i[o] = u; else Object.defineProperty(i, o, {
-                ...l,
-                value: u
+            const l = f.value;
+            const s = l !== null && typeof l === "object" ? snapshotWalk(l, t, n) : l;
+            if (f.enumerable && f.writable && f.configurable) i[o] = s; else Object.defineProperty(i, o, {
+                ...f,
+                value: s
             });
         }
         if (e && i.length !== r.length) i.length = r.length;
@@ -1817,22 +1887,22 @@ function snapshotWalk(e, t, n) {
     // UNOWNED (shared/user) subtrees keep identity unless a descendant
     // substituted; copy-on-substitution preserves the documented CoW contract.
         t.set(r, r);
-    let l = null;
+    let f = null;
     for (const e of Reflect.ownKeys(r)) {
         const i = Object.getOwnPropertyDescriptor(r, e);
         if (!i || i.get || i.set) continue;
         const o = i.value;
         if (o === null || typeof o !== "object") continue;
-        const f = snapshotWalk(o, t, n);
-        if (f !== o) {
-            if (l === null) {
-                l = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                t.set(r, l);
+        const l = snapshotWalk(o, t, n);
+        if (l !== o) {
+            if (f === null) {
+                f = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                t.set(r, f);
             }
-            l[e] = f;
+            f[e] = l;
         }
     }
-    return l ?? r;
+    return f ?? r;
 }
 
-export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetsEqual, unwrapValue, wrapNext };