@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/observe/store/next/store.js

@@ -1,10 +1,10 @@
 import { attrHooks } from "../../core/attribution-hooks.js";
 
-import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_HELD_TRUTH, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
-import { setSlotUnobserved, setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, unlinkFirewallChild, ext, setLatestReadActive, prepareComputed, slotSignal, context } from "../../core/core.js";
+import { setSlotUnobserved, setSignal, isEqual, read, hasActiveOverride, pendingCheckActive, visibleOverride, latestReadActive, readNodeFast, READ_SLOW, signal, unlinkFirewallChild, ext, ownsHold, setLatestReadActive, prepareComputed, slotSignal, serve, stale, recordStaleReplay, enterStagedRead, context } from "../../core/core.js";
 
-import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, setStoreCommitHook } from "../../core/scheduler.js";
+import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, deferSlotRelease, setStoreCommitHook } from "../../core/scheduler.js";
 
 import "../../core/invariants.js";
 
@@ -157,7 +157,7 @@ function wrapNext(e, t = null, n = null, r = t?.fam ?? null) {
 // (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.rn, e, t);
+    return isEqual(e, t) || sameLogicalSlot(this.dn, e, t);
 };
 
 // Shared slot-node unobserved handler (create-floor diet): registered once;
@@ -166,8 +166,13 @@ const slotNodeEquals = function(e, t) {
 setSlotUnobserved(e => {
     // A live affects() mark keeps the node addressable (sweep parity).
     if (e.o?.t) return;
-    const t = e.rn;
-    const n = e._n;
+    // An active override or a staged write is state only the node holds (an
+    // optimistic signal keeps its override whether or not anything reads it —
+    // store parity, posture-store-parity S7): defer the release to the flush
+    // that resolves it (the scheduler's transient-node sweep).
+        if (hasActiveOverride(e) || e._e !== NOT_PENDING) return deferSlotRelease(e);
+    const t = e.dn;
+    const n = e.En;
     if (t.n && t.n[n] === e) {
         delete t.n[n];
         t.nc--;
@@ -195,11 +200,15 @@ r = -1) {
         // (stageHeldKey). Its held-adoption notification (stageHeldAdoptions)
         // ran before the node existed and the drain has nothing left to say.
         // Without this the node was born from whichever view its first reader
-        // saw and never learned the other. (The held-FOLD twin — a setter's
-        // write to an unobserved key landing only in the pending backing — is
-        // #3336's, and lands with #3337.)
-        const l = heldAdoptionTransition(e);
-        if (l !== null) n = e.hv[t];
+        // saw and never learned the other. Two kinds of hold, one rule (#3336):
+        //  - a held FOLD (pb): a setter's write to an unobserved key landed only
+        //    in the pending backing; committed is `v[key]`, staged is `pb[key]`
+        //    (undefined for a deleted key);
+        //  - a held ADOPTION (ht): the adopted value already swapped into `v`;
+        //    committed is the held view `hv[key]`, staged is `v[key]`.
+        const l = heldFoldTransition(e);
+        let f = heldAdoptionTransition(e);
+        if (f !== null) n = e.hv[t]; else if ((f = l) !== null) n = e.v[t];
         // 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
@@ -210,7 +219,7 @@ r = -1) {
         // 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, 
+                const s = 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.
@@ -220,17 +229,20 @@ r = -1) {
         // "signal". Gated on the engine being installed — node creation is
         // the hottest store path, and the disabled cost must stay one null
         // check (nodes created before enable() stay generically named).
-                if (attrHooks !== null) f._name = "store." + String(t);
+                if (attrHooks !== null) {
+            s._name = "store." + String(t);
+            stampNodeOwner(s, e);
+        }
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(f).De = NOT_PENDING;
-            f.T |= CONFIG_OPTIMISTIC;
+            ext(s).Ne = NOT_PENDING;
+            s.C |= 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(f, e.v, t);
-        if (l !== null) stageHeldKey(f, e.v[t], l);
+                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(s, e.v, t);
+        if (f !== null) stageHeldKey(s, l !== null ? e.del !== null && e.del.has(t) ? undefined : e.pb[t] : e.v[t], f);
         i[t] = o;
         e.nc++;
         markDescendants(e);
@@ -242,7 +254,7 @@ r = -1) {
  * a latest()-pull PLAIN_HOLD is not a transaction), else null. */ function heldAdoptionTransition(e) {
     if (e.ht === null || e.ht === PLAIN_HOLD || heldMaskView(e) === null) return null;
     const t = currentTransition(e.ht);
-    return t.Ut === false ? t : null;
+    return t.yt === false ? t : null;
 }
 
 /**
@@ -258,11 +270,54 @@ r = -1) {
  * setSignal: it is not a new write (it staged with the adoption's batch) and
  * it walks no subscriber (the node has none yet). Transition-stamped now, as
  * `runFolded` does — no parked-flush pass will stamp it.
- */ function stageHeldKey(e, t, n) {
-    if (slotNodeEquals.call(e, e.ge, t)) return;
-    e.Pe = t;
-    e.Ee = n;
-    n.tn.push(e);
+ */
+/** The live transaction holding `target`'s pending backing (the #3089
+ * write-time stamp, resolved through merges), else null. */ function liveFoldTransition(e) {
+    if (e.pb === null) return null;
+    const t = foldBatches.get(e);
+    if (t === undefined) return null;
+    const n = currentTransition(t);
+    return n.yt === false ? n : null;
+}
+
+/** liveFoldTransition for node materialization (stageHeldKey). Inside the
+ * draft the backing is the setter's working copy, not a flushed hold — its
+ * nodes take their writes at setter exit (notifyWrites). Optimistic families
+ * hold at the backing: tentative writes are node overrides over a discarded
+ * clone, and a truth-staged landing is masked from ordinary readers by
+ * heldTruthMasked — neither is a plain staged write to mirror. Chained
+ * backings serve the inner store's live value, never a node value. */ function heldFoldTransition(e) {
+    if (e.ch || e.fam?.opt === true || inDraft(e)) return null;
+    return liveFoldTransition(e);
+}
+
+/**
+ * Rule 1 at the backing, the hold half (core serve()'s stale-of-foreign and
+ * A29 arms, for a container instead of a node): given the transaction
+ * holding what a reader `c` (a pass; callers serve context-free readers the
+ * committed container themselves) is about to be served, is the STAGED
+ * container its to see? Its own hold, or none — yes. A foreign hold — a
+ * stale pass (render effect) keeps the committed frame and is recorded for
+ * replay at the hold's commit (recordStaleReplay, A15 / A26); a deriving
+ * pass takes the staged world and enters the transaction (enterStagedRead,
+ * A29). Shared by both hold kinds: a setter's fold (committed `v`, staged
+ * `pb`, the write-time stamp) and an adoption under a transaction
+ * (committed = the held view `hv`, staged = the adopted `v`, #3074).
+ */ function holdVisible(e, t) {
+    if (e === null || ownsHold(e)) return true;
+    if (stale) {
+        recordStaleReplay(e, t);
+        return false;
+    }
+    enterStagedRead(null, e);
+    return true;
+}
+
+function stageHeldKey(e, t, n) {
+    if (slotNodeEquals.call(e, e.Ae, t)) return;
+    e._e = t;
+    e.Te = n;
+    n.sn.push(e);
 }
 
 function sameLogicalSlot(e, t, n) {
@@ -271,6 +326,29 @@ function sameLogicalSlot(e, t, n) {
     return r !== undefined && r === lookupTarget(n, e.fam);
 }
 
+/**
+ * Observe-tier: the owner each store root was created under. The proxy
+ * cannot carry `_owner` itself (`registerGraph`'s stamp is swallowed by the
+ * set trap outside a draft), so the root target keys it here and the store's
+ * nodes copy it into `_owner` as they are created — an `OBSERVE.exclude`d
+ * panel's store nodes are then excluded subjects, exactly like its signals.
+ * Both ends are gated with the naming on the engine being installed: node
+ * creation is the hottest store path, store creation is next, and the
+ * disabled cost of each stays one null check. A store created before
+ * `enable()` therefore has no recorded owner and its nodes are never excluded
+ * subjects — the same boundary the naming draws; a panel enables first.
+ */ const storeOwners = new WeakMap;
+
+function storeRootOwner(e) {
+    let t = e;
+    while (t.u !== null) t = t.u;
+    return storeOwners.get(t);
+}
+
+function stampNodeOwner(e, t) {
+    e.nt = storeRootOwner(t) ?? null;
+}
+
 function getHasNode(e, t, n) {
     const r = e.h ??= Object.create(null);
     let i = r[t];
@@ -279,16 +357,23 @@ function getHasNode(e, t, n) {
             equals: isEqual,
             unobserved() {
                 if (o.o?.t) return;
+                // The structural twin of the value slot's rule (setSlotUnobserved,
+                // S7): an optimistic add/delete lives on this presence node as its
+                // override — releasing it with the override on would let `in`,
+                // `Object.keys` and descriptors fall back to committed structure
+                // while the action is live. Defer to the flush that resolves it.
+                                if (hasActiveOverride(o) || o._e !== NOT_PENDING) return deferSlotRelease(o);
                 if (e.h && e.h[t] === o) {
                     delete e.h[t];
                     unlinkFirewallChild(o);
                 }
             }
         }, e.fam?.node ?? undefined);
-        o.T |= CONFIG_OWNED_WRITE;
+        o.C |= CONFIG_OWNED_WRITE;
+        if (attrHooks !== null) stampNodeOwner(o, e);
         if (e.fam?.opt) {
-            ext(o).De = NOT_PENDING;
-            o.T |= CONFIG_OPTIMISTIC;
+            ext(o).Ne = NOT_PENDING;
+            o.C |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
         r[t] = i;
@@ -309,10 +394,11 @@ function getKeySetNode(e) {
                 }
             }
         }, e.fam?.node ?? undefined);
-        n.T |= CONFIG_OWNED_WRITE;
+        n.C |= CONFIG_OWNED_WRITE;
+        if (attrHooks !== null) stampNodeOwner(n, e);
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
-            n.T |= CONFIG_OPTIMISTIC;
+            ext(n).Ne = NOT_PENDING;
+            n.C |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
         markDescendants(e);
@@ -332,10 +418,11 @@ function getDeepNode(e) {
                 }
             }
         }, e.fam?.node ?? undefined);
-        n.T |= CONFIG_OWNED_WRITE;
+        n.C |= CONFIG_OWNED_WRITE;
+        if (attrHooks !== null) stampNodeOwner(n, e);
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
-            n.T |= CONFIG_OPTIMISTIC;
+            ext(n).Ne = NOT_PENDING;
+            n.C |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
         e.dk = t;
@@ -496,14 +583,14 @@ function ensurePB(e) {
             if (n !== null) {
                 for (const e of Reflect.ownKeys(n)) {
                     const r = n[e];
-                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.De);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Ne);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.De)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Ne)) delete t[e];
                 }
             }
         }
@@ -527,7 +614,7 @@ function ensurePB(e) {
  * foldHeld's node stamps). */ function heldMaskView(e) {
     const t = e.ht;
     if (t === null) return null;
-    if (t !== PLAIN_HOLD && currentTransition(t)?.Ut === true) return e.ht = e.hv = null;
+    if (t !== PLAIN_HOLD && currentTransition(t)?.yt === true) return e.ht = e.hv = null;
     return e.hv;
 }
 
@@ -731,7 +818,7 @@ function drainFolds() {
             // keys; observed keys also hit the pending-node held check below).
             const e = foldBatches.get(t);
             if (e !== undefined) {
-                if (currentTransition(e).Ut === false) {
+                if (currentTransition(e).yt === false) {
                     foldOlds.set(t, n);
                     continue;
                 }
@@ -755,7 +842,7 @@ function drainFolds() {
                 !plainProto(t.ovl ? t.v : i) ? Reflect.ownKeys(o) : e;
                 for (const e of n) {
                     const t = o[e];
-                    if (t !== undefined && t.Pe !== NOT_PENDING) {
+                    if (t !== undefined && t._e !== NOT_PENDING) {
                         r = true;
                         break;
                     }
@@ -857,31 +944,32 @@ function drainFolds() {
  */ function reportReplacedContainers(e, t, n, r) {
     const i = r ?? Reflect.ownKeys(n);
     const o = Array.isArray(n);
+    const l = storeRootOwner(e);
     for (const r of i) {
         if (o && r === "length" || r === $OWNER) continue;
         if (e.del !== null && e.del.has(r)) continue;
         const i = unwrapValue(t[r]);
-        const l = unwrapValue(n[r]);
-        if (i === null || l === null || typeof i !== "object" || typeof l !== "object" || i === l || targetsEqual(i, l)) continue;
+        const f = unwrapValue(n[r]);
+        if (i === null || f === null || typeof i !== "object" || typeof f !== "object" || i === f || targetsEqual(i, f)) continue;
         // Leaf census on the store side: leaves read through a draft are proxies
         // of the committed raws, so identity must be judged on unwrapped values.
-                const f = Array.isArray(l);
-        if (f !== Array.isArray(i)) continue;
-        let s;
-        let u = 0;
-        if (f) {
-            s = l.length;
-            if (s > REPLACED_CENSUS_MAX) continue;
+                const s = Array.isArray(f);
+        if (s !== Array.isArray(i)) continue;
+        let u;
+        let a = 0;
+        if (s) {
+            u = f.length;
+            if (u > REPLACED_CENSUS_MAX) continue;
             const e = new Set;
             for (const t of i) e.add(unwrapValue(t));
-            for (const t of l) if (e.has(unwrapValue(t))) u++;
+            for (const t of f) if (e.has(unwrapValue(t))) a++;
         } else {
-            const e = Object.keys(l);
-            s = e.length;
-            if (s > REPLACED_CENSUS_MAX) continue;
-            for (const t of e) if (sameLeaf(i[t], l[t])) u++;
+            const e = Object.keys(f);
+            u = e.length;
+            if (u > REPLACED_CENSUS_MAX) continue;
+            for (const t of e) if (sameLeaf(i[t], f[t])) a++;
         }
-        attrHooks.storeReplaced(storePath(e) + "." + String(r), f, s, u, f ? i.length : Object.keys(i).length);
+        attrHooks.storeReplaced(storePath(e) + "." + String(r), s, u, a, s ? i.length : Object.keys(i).length, l);
     }
 }
 
@@ -1260,22 +1348,12 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * observer) decides pending visibility, with Roots resolving to their parent
  * computed (#2687 — untracked reads inside mapArray Roots see in-flight
  * values mid-flush). CHILDREN_FORBIDDEN execution scopes (createTrackedEffect
- * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
+ * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */
+/** Core read()'s reader: the current computation, a root reading as its
+ * parent computed (`context` persists under untrack — an untracked read
+ * inside an effect is still that effect's read). */ function readerContext() {
     const e = getOwner();
-    if (e === null) return false;
-    const t = e.$t ? e.ln : e;
-    return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
-}
-
-/** CHILDREN_FORBIDDEN execution scope (createTrackedEffect / onSettled
- * callbacks). Distinct from context-free: these scopes get committed
- * visibility even against a projection's authoritative-elect pending
- * backing (#3082) — parity with signals, where core read() serves
- * committed to them regardless of staged writes. */ function inForbiddenScope() {
-    const e = getOwner();
-    if (e === null) return false;
-    const t = e.$t ? e.ln : e;
-    return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
+    return e === null ? null : e.cn ? e.fn ?? null : e;
 }
 
 /** A pending fold is transition-held when any written node's parked value is
@@ -1285,19 +1363,24 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     if (t === null) return false;
     for (const e of Reflect.ownKeys(t)) {
         const n = t[e];
-        if (n.Pe !== NOT_PENDING && n.Ee != null && n.Ee.Ut !== true) return true;
+        if (n._e !== NOT_PENDING && n.Te != null && n.Te.yt !== true) return true;
     }
     return false;
 }
 
 function readSource(e) {
-    // Held view first (#3074): an adoption staged under a live hold serves the
-    // pre-hold committed backing to committed-visibility readers. Speculative
-    // readers — drafts, write-override, owner-context computeds recomputing
-    // inside the transaction, and latest() reads — see the adopted backing.
-    if (e.ht !== null && !latestReadActive && !inDraft(e) && !getWriteOverride() && !inOwnerContext()) {
-        const t = heldMaskView(e);
-        if (t !== null) return t;
+    // Adoption hold first (#3074): an adoption staged under a live transaction
+    // (or a latest()-pull, PLAIN_HOLD) serves the pre-hold committed view to
+    // committed-visibility readers — context-free and children-forbidden ones,
+    // and stale passes off a foreign hold. Drafts, write-override and latest()
+    // see the adopted backing.
+    const t = e.ht;
+    if (t !== null && !latestReadActive && !inDraft(e) && !getWriteOverride()) {
+        const n = heldMaskView(e);
+        if (n !== null) {
+            const e = readerContext();
+            if (e === null || e.C & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(t === PLAIN_HOLD ? null : currentTransition(t), e)) return n;
+        }
     }
     return pendingBackingVisible(e, false) ? e.pb : e.v;
 }
@@ -1317,21 +1400,28 @@ function readSource(e) {
  * ordinary pending staging regardless of owner context (the documented
  * divergence from context-free per-key reads) — but never through a hold:
  * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t) {
-    return e.pb !== null && (inDraft(e) || getWriteOverride() || 
-    // Owner-context (and speculative-peek) readers see the pending
-    // backing — EXCEPT held truth on an optimistic family (#3164 fold):
-    // a live pb on an opt family outside the draft/write-override windows
-    // is a staged landing (tentative drafts never outlive their setter),
-    // and only the authoritative postures and latest() see it (the
-    // backing-level twin of core read()'s A17-for-held-truth arm;
-    // ordinary readers keep committed until the transaction's reveal).
-    (t || inOwnerContext()) && !heldTruthMasked(e) || 
-    // A projection's pending backing is authoritative-elect: serve it to
-    // context-free readers too UNLESS a transition is holding the node
-    // commits (downstream async hold — stale committed is the contract)
-    // or the reader is a CHILDREN_FORBIDDEN scope, which never observes
-    // its own unsettled write (#3082, signal parity per #3006).
-    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope());
+    if (e.pb === null) return false;
+    // The writer's own channels compose on the pending backing regardless.
+        if (inDraft(e) || getWriteOverride()) return true;
+    // HELD truth on an optimistic family (#3164 fold) is masked from ordinary
+    // readers until the transaction's reveal (the backing-level twin of core
+    // serve()'s CONFIG_HELD_TRUTH arm; authoritative postures and latest()
+    // tunnel through inside heldTruthMasked).
+        if (heldTruthMasked(e)) return false;
+    const n = readerContext();
+    if (n === null || n.C & CONFIG_CHILDREN_FORBIDDEN) {
+        // No pass, or a children-forbidden one: the committed frame (A32) —
+        // except the speculative peek (deep()/snapshot()), which sees ordinary
+        // pending staging but never through a live foreign hold, and a
+        // projection's pending backing, authoritative-elect for context-free
+        // readers UNLESS a transition holds the node commits (downstream async
+        // hold — stale committed is the contract; the write-time stamp covers
+        // keys with no node, #3336) or the scope is children-forbidden (#3082).
+        const r = liveFoldTransition(e);
+        if (t) return r === null || ownsHold(r);
+        return e.fam !== null && n === null && !foldHeld(e) && r === null;
+    }
+    return holdVisible(liveFoldTransition(e), n);
 }
 
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
@@ -1376,18 +1466,13 @@ function isOwnAccessor(e, t) {
     }
 }
 
-/** Active optimistic override on an armed node (armed slot idles at
- * NOT_PENDING; undefined = unarmed plain node). */ function hasActiveOverride(e) {
-    return e.o?.De !== undefined && e.o?.De !== NOT_PENDING;
-}
-
 /** The reading computation is until()'s authoritative-view predicate — same
  * source of truth as core read()'s A17 carve-out (`context`, which persists
  * under untrack). optimisticView()'s composition gate consults exactly this:
  * write-side machinery (patch emission, tentative re-application) must keep
  * composing even when it runs inside an authoritative-write bracket. */ function authoritativeRead() {
     const e = context;
-    return e !== null && (e.T & CONFIG_AUTHORITATIVE_READ) !== 0;
+    return e !== null && (e.C & CONFIG_AUTHORITATIVE_READ) !== 0;
 }
 
 /** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
@@ -1408,19 +1493,17 @@ function isOwnAccessor(e, t) {
  * reader that forced it (backing commits eagerly; node values fold at flush).
  * FORCE sentinels never surface (they only bump subscribers of accessor
  * keys, which are served by the trap, not the node). */ function nodeValue(e, t) {
-    // latest() sees the in-flight parked value like an owner-context reader
-    // does (#3075) — signal/memo parity for store-node-backed keys.
-    // Authoritative-view reads (until()'s predicate) skip the override arm
-    // only: staged pending values are authoritative, overrides are the
-    // caller's optimism.
-    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.De) : e.Pe !== NOT_PENDING && (latestReadActive || 
-    // Owner-context pending visibility — except HELD truth (#3164,
-    // see CONFIG_HELD_TRUTH: fold-staged or entangle-stolen
-    // confirming truth), which only authoritative/latest readers
-    // see (core read()'s A17-for-held-truth twin; ordinary readers
-    // keep committed until the transaction's reveal — latest() is
-    // exempted by the leading arm above).
-    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Pe : t;
+    // Store-only tunnels, ahead of Rule 1: truth authors (authoritativeServe —
+    // the projection derive's draft, the write-override continuation) see
+    // staged truth and never an override; latest() reaching this untracked
+    // path for a store key sees the in-flight parked value like an
+    // owner-context reader does (#3075), the visible override first.
+    let n;
+    if (authoritativeServe()) n = e._e !== NOT_PENDING ? e._e : t; else if (latestReadActive) n = visibleOverride(e) ? unwrapOverride(e.o?.Ne) : e._e !== NOT_PENDING ? e._e : t;
+    // Otherwise the one slow selection core read() uses (serve): override,
+    // lane gate, A28, readerSeesCommitted / A29 — with the BACKING as the
+    // committed value (single-home rule, O6).
+     else n = serve(e, readerContext(), e.ne || e, t);
     return n === FORCE ? t : n;
 }
 
@@ -1471,7 +1554,7 @@ function isOwnAccessor(e, t) {
         // Truth authors read the backing's own length — an optimistic row from
         // the caller's transaction must not shift where the author's next write
         // lands (#3108).
-                return (authoritativeServe() ? r : optHooks.optimisticView(e, r)).length;
+                return (authoritativeServe() ? r : optHooks.optimisticView(e, r, inDraft(e))).length;
     }
     if (inDraft(e)) {
         // Optimistic drafts before their first write have no pending backing yet;
@@ -1481,26 +1564,26 @@ function isOwnAccessor(e, t) {
         // seeding rule, applied to the read side (#3108).
         if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
+            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Ne);
         }
     } else {
-        if (i !== undefined) {
-            // §7b: a lane value on the outer node SHADOWS read-through — an active
-            // override pierces the chained gate; otherwise chained backings always
-            // serve the live inner value.
-            if (getObserver() !== null) {
-                // read()'s plain-signal fast path hoisted over the call (legacy trap
-                // parity): READ_SLOW = a global read window or non-plain node.
-                let e = readNodeFast(i);
-                if (e === READ_SLOW) e = read(i);
-                if (!l || hasActiveOverride(i)) f = e === FORCE ? n : e;
-            } else if (!l || hasActiveOverride(i)) {
-                f = nodeValue(i, n);
-            }
-        } else if (getObserver() !== null) {
-            // 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));
+        // §7b: a lane value on the outer node SHADOWS read-through — an active
+        // override pierces the chained gate; otherwise chained backings always
+        // serve the live inner value.
+        if (getObserver() !== null) {
+            // First tracked read: create + link (the wrap-cache branch below
+            // populates px/pxv so read #2 skips wrapNext, slice 2). The value is
+            // served THROUGH the node from this read on — a node born under a held
+            // fold carries the hold (getNode, #3336), and the backing it was read
+            // from does not.
+            if (i === undefined) i = getNode(e, t, n, o);
+            // read()'s plain-signal fast path hoisted over the call (legacy trap
+            // parity): READ_SLOW = a global read window or non-plain node.
+                        let r = readNodeFast(i);
+            if (r === READ_SLOW) r = read(i);
+            if (!l || hasActiveOverride(i)) f = r === FORCE ? n : r;
+        } else if (i !== undefined && (!l || hasActiveOverride(i))) {
+            f = nodeValue(i, n);
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
@@ -1685,7 +1768,7 @@ const traps = {
             // the caller's optimism is not truth (has-trap twin below).
             !authoritativeServe()) {
                 const n = e.n?.[t];
-                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
+                if (n !== undefined && visibleOverride(n)) f = unwrapOverride(n.o?.Ne);
             }
             if (e.s) return serveShallow(e, t, f);
             return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
@@ -1712,11 +1795,11 @@ const traps = {
                 if (hasActiveOverride(n)) r = !!i;
             } else if (!authoritativeServe()) {
                 const n = e.h?.[t];
-                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
+                if (n !== undefined && visibleOverride(n)) r = !!unwrapOverride(n.o?.Ne);
             }
         } else if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Ne);
         }
         return r;
     },
@@ -1728,13 +1811,30 @@ const traps = {
     },
     getOwnPropertyDescriptor(e, t) {
         if (t === $OWNER) return undefined;
-        const n = visibleDescriptor(e, readSource(e), t);
-        if (n === undefined) return undefined;
+        // A descriptor read is a PRESENCE read: it subscribes to the key's
+        // presence node and witnesses affects()/isPending() exactly as `in` does
+        // (structural oracle, 2026-09-17 — the trap read no node before, so a
+        // render effect inspecting a key through getOwnPropertyDescriptor never
+        // re-ran for an optimistic add or delete, and an isPending() probe over
+        // it witnessed nothing). The value it reports rides the value node's
+        // view through visibleDescriptor.
+                if (pendingCheckActive) witnessAffectsMark(e, t);
+        if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
+        const n = readSource(e);
+        const r = visibleDescriptor(e, n, t);
+        if (!inDraft(e) && getObserver() !== null) {
+            // The node is born from the source's presence (as `has` births it),
+            // not the override-adjusted answer.
+            let r = t in n;
+            if (r && e.del !== null && n === e.pb && e.del.has(t)) r = false;
+            read(getHasNode(e, t, r));
+        }
+        if (r === undefined) return undefined;
         // Array targets carry a real non-configurable `length` the proxy
         // invariant forces us to report faithfully; everything else reports
         // configurable via target indirection (core R51).
-                if (!(t === "length" && Array.isArray(e))) n.configurable = true;
-        return n;
+                if (!(t === "length" && Array.isArray(e))) r.configurable = true;
+        return r;
     },
     set(e, t, n) {
         // Writes require the target's draft scope OR the projection write
@@ -1846,8 +1946,10 @@ const traps = {
 
 /** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
  * emits write-time notifications at outermost exit, applies returned
- * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
- * projection recomputes legitimately write from inside their computed. */ function storeSetterNext(e, t, n = true) {
+ * replacements as adoptions. `guard=false` skips the dev guards (owned-scope
+ * write, thenable result) — projection recomputes legitimately write from
+ * inside their computed, and their async derive is handled by the recompute,
+ * not returned through here. */ function storeSetterNext(e, t, n = true) {
     const r = e[$TARGET];
     const i = writeScopes;
     writeScopes = new Set;
@@ -1895,7 +1997,18 @@ function createStoreNext(e, t = false) {
         n[$TARGET].s = true;
         markRawIngest(e);
     }
-    registerGraph(n, getOwner());
+    {
+        const e = getOwner();
+        // Dev-tier graph registration (owner signal lists, onGraph); the
+        // `_owner` write itself never reaches the proxy, see storeOwners.
+                registerGraph(n, e);
+        // Only once the engine is installed, like the node stamping it feeds: a
+        // WeakMap.set per fresh store is a growing ephemeron table (~+35% on the
+        // 2000-store create+commit shape, CodSpeed −11.7% on #3380's first cut)
+        // and, disabled, buys nothing — a store created before enable() has no
+        // excluded owner to inherit either way.
+                if (attrHooks !== null) storeOwners.set(n[$TARGET], e);
+    }
     const setter = e => storeSetterNext(n, e);
     return [ n, setter ];
 }
@@ -1967,11 +2080,12 @@ function createStoreNext(e, t = false) {
     }
     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];
-            if (!hasActiveOverride(i)) continue;
+        const r = inDraft(e);
+        for (const i of Reflect.ownKeys(e.h)) {
+            const o = e.h[i];
+            if (!(r ? hasActiveOverride(o) : visibleOverride(o))) continue;
             t ??= new Set(n);
-            if (unwrapOverride(i.o?.De)) t.add(r); else t.delete(r);
+            if (unwrapOverride(o.o?.Ne)) t.add(i); else t.delete(i);
         }
         if (t !== null) return [ ...t ];
     }
@@ -1990,8 +2104,8 @@ function createStoreNext(e, t = false) {
     }
     if (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
         const t = e.h?.[n];
-        if (t !== undefined && hasActiveOverride(t)) {
-            if (!unwrapOverride(t.o?.De)) return undefined;
+        if (t !== undefined && visibleOverride(t)) {
+            if (!unwrapOverride(t.o?.Ne)) return undefined;
  // opt delete
                         if (r === undefined) {
                 const t = e.n?.[n];
@@ -2070,7 +2184,7 @@ function createStoreNext(e, t = false) {
             // serve, as nodeValue's leading arm does.
                         if (r) {
                 const t = e.n?.[n];
-                if (t !== undefined && hasActiveOverride(t) && !authoritativeServe()) o = unwrapOverride(t.o.De);
+                if (t !== undefined && hasActiveOverride(t) && !authoritativeServe()) o = unwrapOverride(t.o.Ne);
             }
             if (o === null || typeof o !== "object") continue;
             // Through a chain the descriptor yields the INNERMOST raw: resolve it to
@@ -2210,4 +2324,4 @@ function snapshotWalk(e, t, n) {
     return l ?? r;
 }
 
-export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, heldMaskView, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, heldMaskView, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetsEqual, unwrapValue, visibleOverride, wrapNext };