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

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

@@ -1,8 +1,8 @@
-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";
 
@@ -121,11 +121,11 @@ function wrapNext(e, t = null, n = null, r = t?.fam ?? null) {
     if (rawValuesUsed && isRawValue(e)) return e;
     const i = lookupTarget(e, r);
     if (i !== undefined) return i.px;
-    const o = e[$TARGET];
-    if (o !== undefined && o.px === e) {
+    const l = e[$TARGET];
+    if (l !== undefined && l.px === e) {
         // Foreign-family proxies re-wrap into THIS family (writes stay isolated);
         // same-family and plain-store proxies pass through.
-        if (r === null || o.fam === r) return e;
+        if (r === null || l.fam === r) return e;
         return createTarget(e, t, n, r).px;
     }
     return createTarget(e, t, n, r).px;
@@ -153,7 +153,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.Ut, e, t);
+    return isEqual(e, t) || sameLogicalSlot(this.Wt, e, t);
 };
 
 // Shared slot-node unobserved handler (create-floor diet): registered once;
@@ -162,8 +162,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.Ut;
-    const n = e.xt;
+    // 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.ve !== NOT_PENDING) return deferSlotRelease(e);
+    const t = e.Wt;
+    const n = e.qt;
     if (t.n && t.n[n] === e) {
         delete t.n[n];
         t.nc--;
@@ -181,8 +186,8 @@ function getNode(e, t, n,
 // callers), 0/1 = probed.
 r = -1) {
     const i = e.n ??= Object.create(null);
-    let o = i[t];
-    if (o === undefined) {
+    let l = i[t];
+    if (l === undefined) {
         // Born holding (#3330 store twin): a key first read while a live
         // transaction holds an ADOPTION on this target (adoptPB's `ht`) is
         // created as if it had existed when the hold was notified — the adopted
@@ -191,11 +196,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 o = heldFoldTransition(e);
+        let f = heldAdoptionTransition(e);
+        if (f !== null) n = e.hv[t]; else if ((f = o) !== 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
@@ -206,7 +215,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 = l = 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.
@@ -214,25 +223,25 @@ r = -1) {
         // 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).be = NOT_PENDING;
-            f.T |= CONFIG_OPTIMISTIC;
+            ext(s).Ce = NOT_PENDING;
+            s.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(f, e.v, t);
-        if (l !== null) stageHeldKey(f, e.v[t], l);
-        i[t] = o;
+                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(s, e.v, t);
+        if (f !== null) stageHeldKey(s, o !== null ? e.del !== null && e.del.has(t) ? undefined : e.pb[t] : e.v[t], f);
+        i[t] = l;
         e.nc++;
         markDescendants(e);
     }
-    return o;
+    return l;
 }
 
 /** The live transaction holding an adoption on `target` (adoptPB's `ht`;
  * 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.ft === false ? t : null;
+    return t.Tt === false ? t : null;
 }
 
 /**
@@ -248,11 +257,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.me, t)) return;
-    e.Ge = t;
-    e.ge = n;
-    n.$t.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.Tt === 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.Qe, t)) return;
+    e.ve = t;
+    e.Ge = n;
+    n.Ot.push(e);
 }
 
 function sameLogicalSlot(e, t, n) {
@@ -265,22 +317,28 @@ function getHasNode(e, t, n) {
     const r = e.h ??= Object.create(null);
     let i = r[t];
     if (i === undefined) {
-        const o = i = signal(n, {
+        const l = i = signal(n, {
             equals: isEqual,
             unobserved() {
-                if (o.o?.t) return;
-                if (e.h && e.h[t] === o) {
+                if (l.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(l) || l.ve !== NOT_PENDING) return deferSlotRelease(l);
+                if (e.h && e.h[t] === l) {
                     delete e.h[t];
-                    unlinkFirewallChild(o);
+                    unlinkFirewallChild(l);
                 }
             }
         }, e.fam?.node ?? undefined);
-        o.T |= CONFIG_OWNED_WRITE;
+        l.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(o).be = NOT_PENDING;
-            o.T |= CONFIG_OPTIMISTIC;
+            ext(l).Ce = NOT_PENDING;
+            l.T |= CONFIG_OPTIMISTIC;
         }
-        if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
+        if (affectsScopesLive()) inheritAffectsMarks(l, e.v, t);
         r[t] = i;
         markDescendants(e);
     }
@@ -301,7 +359,7 @@ function getKeySetNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).be = NOT_PENDING;
+            ext(n).Ce = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
@@ -324,7 +382,7 @@ function getDeepNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).be = NOT_PENDING;
+            ext(n).Ce = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
@@ -486,14 +544,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?.be);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Ce);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.be)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Ce)) delete t[e];
                 }
             }
         }
@@ -517,7 +575,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)?.ft === true) return e.ht = e.hv = null;
+    if (t !== PLAIN_HOLD && currentTransition(t)?.Tt === true) return e.ht = e.hv = null;
     return e.hv;
 }
 
@@ -721,7 +779,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).ft === false) {
+                if (currentTransition(e).Tt === false) {
                     foldOlds.set(t, n);
                     continue;
                 }
@@ -733,8 +791,8 @@ function drainFolds() {
             // node (transition-held) re-queues the target for the settling flush.
                         let r = false;
             const i = t.pb;
-            const o = t.n;
-            if (o !== null) {
+            const l = t.n;
+            if (l !== null) {
                 // 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).
@@ -742,10 +800,10 @@ function drainFolds() {
                 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.
-                !plainProto(t.ovl ? t.v : i) ? Reflect.ownKeys(o) : e;
+                !plainProto(t.ovl ? t.v : i) ? Reflect.ownKeys(l) : e;
                 for (const e of n) {
-                    const t = o[e];
-                    if (t !== undefined && t.Ge !== NOT_PENDING) {
+                    const t = l[e];
+                    if (t !== undefined && t.ve !== NOT_PENDING) {
                         r = true;
                         break;
                     }
@@ -887,20 +945,20 @@ function drainFolds() {
     // bound never engages for overlay writes (every plain-object setter batch
     // would full-scan: the exact selection-map workload wk exists for; jf
     // `select` regressed 2x on this).
-        const o = i === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : t) ? null : i;
+        const l = i === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : t) ? null : i;
     if (r !== null) {
-        const i = o ?? Reflect.ownKeys(r);
-        for (const o of i) {
-            const i = r[o];
+        const i = l ?? Reflect.ownKeys(r);
+        for (const l of i) {
+            const i = r[l];
             if (i === undefined) continue;
             // Per-key accessor handling: the node's cached flag plus ONE getter
             // probe on the incoming side (getters arriving via merge/adoption).
             // Setter-only props read as data (value undefined) so lookupSetter is
             // not consulted on this hot path; prototype getters never own nodes.
-                        if (i.acc === true || hasOwn.call(t, o) && lookupGetter.call(t, o) !== undefined) {
-                i.acc = isOwnAccessor(t, o);
-                const e = Object.getOwnPropertyDescriptor(n, o);
-                const r = Object.getOwnPropertyDescriptor(t, o);
+                        if (i.acc === true || hasOwn.call(t, l) && lookupGetter.call(t, l) !== undefined) {
+                i.acc = isOwnAccessor(t, l);
+                const e = Object.getOwnPropertyDescriptor(n, l);
+                const r = Object.getOwnPropertyDescriptor(t, l);
                 if (e && (e.get || e.set) || r && (r.get || r.set)) {
                     if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(i, () => FORCE);
                     continue;
@@ -912,26 +970,26 @@ 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 o = e.del !== null && e.del.has(l) ? undefined : t[l];
+            setSignal(i, () => o);
         }
     }
-    const l = e.h;
-    if (l !== null) {
-        const n = o ?? Reflect.ownKeys(l);
+    const o = e.h;
+    if (o !== null) {
+        const n = l ?? Reflect.ownKeys(o);
         for (const r of n) {
-            const n = l[r];
+            const n = o[r];
             if (n !== undefined) setSignal(n, r in t && !(e.del !== null && e.del.has(r)));
         }
     }
     // Deep-witness (dk): setter writes must notify a deep() subscriber even on
     // keys with no node. O(written/pb keys) equality only when a witness exists.
         if (e.dk !== null) {
-        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of o ?? Reflect.ownKeys(t)) {
+        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of l ?? Reflect.ownKeys(t)) {
             if (r === $OWNER) continue;
             const i = t[r];
-            const o = n[r];
-            if (i !== null && typeof i === "object" ? !targetsEqual(o, i) : !isEqual(o, i)) {
+            const l = n[r];
+            if (i !== null && typeof i === "object" ? !targetsEqual(l, i) : !isEqual(l, i)) {
                 bumpDeep(e);
                 break;
             }
@@ -1041,23 +1099,23 @@ i = true) {
     if (e.acc === true || i && hasOwn.call(r, t) && lookupGetter.call(r, t) !== undefined) {
         e.acc = isOwnAccessor(r, t);
         const i = Object.getOwnPropertyDescriptor(n, t);
-        const o = Object.getOwnPropertyDescriptor(r, t);
-        if (i && (i.get || i.set) || o && (o.get || o.set)) {
+        const l = Object.getOwnPropertyDescriptor(r, t);
+        if (i && (i.get || i.set) || l && (l.get || l.set)) {
             // Accessor involved: never invoke; force-notify on shape change so
             // subscribers re-read (and re-track) through the trap.
-            if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
+            if (i?.get !== l?.get || i?.set !== l?.set || i?.value !== l?.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 o = i?.value;
+        const f = l?.value;
+        if (!isEqual(o, f) && !targetsEqual(o, f)) setSignal(e, typeof f === "function" ? () => f : f);
     } else {
         const i = n[t];
-        const o = r[t];
+        const l = r[t];
         // Direct value write when not a function (setSignal treats functions as
         // updaters) — saves a closure allocation per changed key on the fold
         // hot path.
-                if (!isEqual(i, o) && !targetsEqual(i, o)) setSignal(e, typeof o === "function" ? () => o : o);
+                if (!isEqual(i, l) && !targetsEqual(i, l)) setSignal(e, typeof l === "function" ? () => l : l);
     }
 }
 
@@ -1069,9 +1127,9 @@ i = true) {
 /** Fused-walk per-key notification with values already in hand: the caller
  * fetched both sides and handled the identity skip; this applies the
  * accessor branch (cached flag only — reconcile channel) or the plain
- * equality/identity-gated write. */ function notifyKeyValue(e, t, n, r, i, o) {
+ * equality/identity-gated write. */ function notifyKeyValue(e, t, n, r, i, l) {
     if (e.acc === true) {
-        notifyKeyDiff(e, t, i, o, false);
+        notifyKeyDiff(e, t, i, l, false);
         return;
     }
     // The pre-compare is NOT redundant with the node's equals: setSignal parks
@@ -1200,22 +1258,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() {
-    const e = getOwner();
-    if (e === null) return false;
-    const t = e.gt ? e.bt : 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() {
+ * / 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.gt ? e.bt : e;
-    return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
+    return e === null ? null : e.xt ? e.Qt ?? null : e;
 }
 
 /** A pending fold is transition-held when any written node's parked value is
@@ -1225,19 +1273,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.Ge !== NOT_PENDING && n.ge != null && n.ge.ft !== true) return true;
+        if (n.ve !== NOT_PENDING && n.Ge != null && n.Ge.Tt !== 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.T & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(t === PLAIN_HOLD ? null : currentTransition(t), e)) return n;
+        }
     }
     return pendingBackingVisible(e, false) ? e.pb : e.v;
 }
@@ -1257,21 +1310,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.T & 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
@@ -1316,11 +1376,6 @@ 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?.be !== undefined && e.o?.be !== 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:
@@ -1348,19 +1403,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?.be) : e.Ge !== 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.Ge : 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.ve !== NOT_PENDING ? e.ve : t; else if (latestReadActive) n = visibleOverride(e) ? unwrapOverride(e.o?.Ce) : e.ve !== NOT_PENDING ? e.ve : 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.Te || e, t);
     return n === FORCE ? t : n;
 }
 
@@ -1391,15 +1444,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, o = -1) {
-    const l = e.ch && r === e.v;
+ * shadows the live chain. */ function serveDataKey(e, t, n, r, i, l = -1) {
+    const o = e.ch && r === e.v;
     let f = 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 && !l && Array.isArray(r)) {
+        if (t === "length" && e.fam?.opt === true && !o && Array.isArray(r)) {
         if (!inDraft(e)) {
             const r = e.n?.length;
             if (r !== undefined) {
@@ -1411,7 +1464,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;
@@ -1421,31 +1474,31 @@ 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?.be);
+            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Ce);
         }
     } 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, l);
+            // 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 (!o || hasActiveOverride(i)) f = r === FORCE ? n : r;
+        } else if (i !== undefined && (!o || hasActiveOverride(i))) {
+            f = nodeValue(i, n);
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
         if (e.s) return serveShallow(e, t, f);
-    if (e.ch && !l && f !== null && typeof f === "object" && f[$TARGET] === undefined) f = resolveChainedRaw(e, t, f);
+    if (e.ch && !o && f !== null && typeof f === "object" && f[$TARGET] === undefined) f = resolveChainedRaw(e, t, f);
     if (i !== undefined) {
         // Wrap cache (see getNode): only wrappables are ever cached, so a hit
         // skips isWrappable too — pointer-compare replaces both checks.
@@ -1581,18 +1634,18 @@ const traps = {
         // 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;
+                let l = -1;
         {
-            let l;
-            if (i !== undefined) l = i.acc === true; else if (!inDraft(e) && getObserver() !== null) {
-                l = isOwnAccessor(r, t);
-                if (r === (e.pb ?? e.v)) o = l ? 1 : 0;
-            } else l = false;
-            if (l) {
-                if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined, o));
-                const l = Reflect.get(r, t, n);
-                if (e.s) return serveShallow(e, t, l);
-                return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
+            let o;
+            if (i !== undefined) o = i.acc === true; else if (!inDraft(e) && getObserver() !== null) {
+                o = isOwnAccessor(r, t);
+                if (r === (e.pb ?? e.v)) l = o ? 1 : 0;
+            } else o = false;
+            if (o) {
+                if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined, l));
+                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;
             }
         }
         // Plain-data fast path: no descriptor allocation per read.
@@ -1602,10 +1655,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 l = e.ovl && r === e.pb;
-        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t))) return undefined;
+                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;
         let f = r[t];
-        if (f === undefined ? !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t)) : false) {
+        if (f === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
             f = Reflect.get(r, t, n);
             if (typeof f === "function") return f;
@@ -1613,7 +1666,7 @@ 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 (f === undefined && !inDraft(e)) {
-                if (getObserver() !== null) read(getNode(e, t, undefined, o));
+                if (getObserver() !== null) read(getNode(e, t, undefined, l));
                 const n = e.n?.[t];
                 if (n) {
                     const r = nodeValue(n, undefined);
@@ -1625,14 +1678,14 @@ 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?.be);
+                if (n !== undefined && visibleOverride(n)) f = unwrapOverride(n.o?.Ce);
             }
             if (e.s) return serveShallow(e, t, f);
             return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
         }
-        if (typeof f === "function" && !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t))) return f;
+        if (typeof f === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return f;
  // proto method
-                return serveDataKey(e, t, f, r, i, o);
+                return serveDataKey(e, t, f, r, i, l);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
@@ -1652,11 +1705,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?.be);
+                if (n !== undefined && visibleOverride(n)) r = !!unwrapOverride(n.o?.Ce);
             }
         } else if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.be);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Ce);
         }
         return r;
     },
@@ -1668,13 +1721,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
@@ -1691,13 +1761,13 @@ const traps = {
         // Shallow slots store what was written VERBATIM — another store's proxy
         // 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 l = e.s ? n : unwrapValue(n);
+        const o = 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.
-                if (Array.isArray(l)) {
+                if (Array.isArray(o)) {
             if (t === "length") e.wk = WK_ALL; else if (e.wk !== WK_ALL) {
                 const n = e.wk ??= new Set;
                 n.add(t);
@@ -1709,13 +1779,13 @@ const traps = {
             // sees through an overlay to the committed keys, so this counts keys
             // NEW to the container. Deletes are not un-counted (a stale high
             // count only picks the overlay a little early).
-                        if (!(t in l)) e.kc++;
+                        if (!(t in o)) e.kc++;
         }
         // 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, {
-                value: o,
+            Object.defineProperty(o, t, {
+                value: l,
                 writable: true,
                 enumerable: true,
                 configurable: true
@@ -1728,18 +1798,18 @@ const traps = {
         // path normalized descriptors for exactly this — R51 parity). A
         // plain-data-graded backing (sc 2, owned: every slot writable) takes the
         // bare assignment — it lands as an own key on the overlay all the same.
-                if (e.ovl && e.sc !== 2 && !hasOwn.call(l, t)) {
-            Object.defineProperty(l, t, {
-                value: o,
+                if (e.ovl && e.sc !== 2 && !hasOwn.call(o, t)) {
+            Object.defineProperty(o, t, {
+                value: l,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else l[t] = o;
+        } else o[t] = l;
         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).
-                if (e.s && o !== null && typeof o === "object") markRawOne(o);
+                if (e.s && l !== null && typeof l === "object") markRawOne(l);
         // Override-mode (post-await draft) writes have no setter exit — notify
         // per-op (setSignal equality-gates repeats).
                 if (i) notifyWrites(e);
@@ -1756,14 +1826,14 @@ const traps = {
             ...n,
             value: unwrapValue(n.value)
         };
-        const o = ensurePB(e);
+        const l = ensurePB(e);
         // A non-default data descriptor (or an accessor) leaves the plain-data
         // grade: the key reaches the committed backing as defined, so the spread
         // clone and bare-assignment paths no longer describe it.
                 if (e.a || !(n.enumerable && n.writable && n.configurable)) e.sc = 1;
         pendingNotify.add(e);
         if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
-        Object.defineProperty(o, t, n);
+        Object.defineProperty(l, t, n);
         if (e.del !== null) e.del.delete(t);
         if (i) notifyWrites(e);
         return true;
@@ -1786,20 +1856,22 @@ 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;
     writeScopes.add(scopeKey(r));
     writing++;
-    let o;
+    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.
-        o = t(e);
+        l = t(e);
     } finally {
         writing--;
         writeScopes = i;
@@ -1811,15 +1883,15 @@ const traps = {
             for (const t of e) notifyWrites(t);
         }
     }
-    if (o !== undefined && o !== e && isWrappable(o)) {
+    if (l !== undefined && l !== e && isWrappable(l)) {
         // Returned replacement: on an optimistic family (outside authoritative
         // writes) the replacement is itself an optimistic edit — diff it against
         // the visible view as engine writes (reverts at settle). Otherwise it is
         // an adoption of the incoming object (unowned).
         if (r.fam?.opt && !projectionWriteActive && !getWriteOverride()) {
-            optHooks.notifyOptimisticWrites(r, unwrapValue(o));
+            optHooks.notifyOptimisticWrites(r, unwrapValue(l));
         } else {
-            adoptPB(r, unwrapValue(o));
+            adoptPB(r, unwrapValue(l));
         }
     }
     if (writing === 0 && heldAdoptions.size) stageHeldAdoptions();
@@ -1906,11 +1978,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 l = e.h[i];
+            if (!(r ? hasActiveOverride(l) : visibleOverride(l))) continue;
             t ??= new Set(n);
-            if (unwrapOverride(i.o?.be)) t.add(r); else t.delete(r);
+            if (unwrapOverride(l.o?.Ce)) t.add(i); else t.delete(i);
         }
         if (t !== null) return [ ...t ];
     }
@@ -1929,8 +2002,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?.be)) return undefined;
+        if (t !== undefined && visibleOverride(t)) {
+            if (!unwrapOverride(t.o?.Ce)) return undefined;
  // opt delete
                         if (r === undefined) {
                 const t = e.n?.[n];
@@ -2003,23 +2076,23 @@ function createStoreNext(e, t = false) {
                 continue;
  // accessors track through their own reads when invoked
                         }
-            let o = i.value;
+            let l = i.value;
             // An active value override on an optimistic node shadows the backing's
             // child (an optimistic replacement `d[i] = {...}`) — follow what reads
             // serve, as nodeValue's leading arm does.
                         if (r) {
                 const t = e.n?.[n];
-                if (t !== undefined && hasActiveOverride(t) && !authoritativeServe()) o = unwrapOverride(t.o.be);
+                if (t !== undefined && hasActiveOverride(t) && !authoritativeServe()) l = unwrapOverride(t.o.Ce);
             }
-            if (o === null || typeof o !== "object") continue;
+            if (l === null || typeof l !== "object") continue;
             // Through a chain the descriptor yields the INNERMOST raw: resolve it to
             // the inner family's proxy so this level wraps the chained `view[i]` the
             // get trap serves, never a fresh non-chained wrapper of the base raw.
-                        if (e.ch && o[$TARGET] === undefined) o = resolveChainedRaw(e, n, o);
-            const l = childTarget(e, o, n);
-            if (l === undefined) continue;
+                        if (e.ch && l[$TARGET] === undefined) l = resolveChainedRaw(e, n, l);
+            const o = childTarget(e, l, n);
+            if (o === undefined) continue;
  // raw-marked: leaf by contract
-                        walkT(l);
+                        walkT(o);
         }
     };
     walkT(t);
@@ -2051,31 +2124,31 @@ function snapshotWalk(e, t, n) {
         let i = null;
     for (let e = true; ;e = false) {
         const t = r?.[$TARGET]?.v !== undefined;
-        let o = t ? r[$TARGET] : undefined;
-        if (o === undefined && n !== null) o = lookupTarget(r, n);
-        if (o === undefined) o = lookupTarget(r, null);
-        if (o === undefined) break;
+        let l = t ? r[$TARGET] : undefined;
+        if (l === undefined && n !== null) l = lookupTarget(r, n);
+        if (l === undefined) l = lookupTarget(r, null);
+        if (l === undefined) break;
         // Entering a level from a RAW below a chained family: the raw resolves to
         // the INNER store's target, but this family's wrapper for it — keyed by
         // the inner proxy, §7b — is where the outer overrides live. Start from
         // the wrapper so they compose (#3323: a nested optimistic write on a view
         // row was served by reads but missing from deep()/snapshot()). Entry only:
         // the descent then runs wrapper → inner → raw and terminates.
-                if (e && !t && n !== null && o.fam !== n) {
-            const e = n.map.get(o.px);
-            if (e !== undefined) o = e;
+                if (e && !t && n !== null && l.fam !== n) {
+            const e = n.map.get(l.px);
+            if (e !== undefined) l = e;
         }
-        if (o.fam !== null) n = o.fam;
-        if (o.fam?.opt === true) (i ??= []).push(o);
+        if (l.fam !== null) n = l.fam;
+        if (l.fam?.opt === true) (i ??= []).push(l);
         // The shared visibility decision (#3147): the speculative peek serves
         // pending staging, but a HELD landing is masked to committed exactly as
         // it is for per-key readers — the two families must answer alike while
         // a transaction holds store landings.
-                const l = pendingBackingVisible(o, true);
+                const o = pendingBackingVisible(l, true);
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
-                if (l && o.ovl) materializePB(o);
-        const f = l ? o.pb : o.v;
+                if (o && l.ovl) materializePB(l);
+        const f = o ? l.pb : l.v;
         if (f === r) break;
         r = f;
     }
@@ -2088,20 +2161,20 @@ function snapshotWalk(e, t, n) {
         if (e !== r) {
             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 l = Array.isArray(e);
+            const o = l ? [] : Object.create(Object.getPrototypeOf(e));
+            t.set(r, o);
             for (const r of Reflect.ownKeys(e)) {
-                if (o && r === "length" || r === $OWNER) continue;
+                if (l && r === "length" || r === $OWNER) continue;
                 const i = e[r];
-                l[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
+                o[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
             }
-            if (o) l.length = e.length;
-            return l;
+            if (l) o.length = e.length;
+            return o;
         }
     }
-    const o = t.get(r);
-    if (o !== undefined) return o;
+    const l = t.get(r);
+    if (l !== undefined) return l;
     // OWNED (written) subtrees snapshot as copies (§7b: identity is only for
     // subtrees "unmodified relative to source"): non-enumerable symbols are
     // excluded (recon-snap R29), and the copy registers BEFORE descent so
@@ -2110,18 +2183,18 @@ function snapshotWalk(e, t, n) {
         const e = Array.isArray(r);
         const i = e ? [] : Object.create(Object.getPrototypeOf(r));
         t.set(r, i);
-        for (const o of Reflect.ownKeys(r)) {
-            if (e && o === "length" || o === $OWNER) continue;
-            const l = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !l.enumerable) continue;
-            if (l.get || l.set) {
-                Object.defineProperty(i, o, l);
+        for (const l of Reflect.ownKeys(r)) {
+            if (e && l === "length" || l === $OWNER) continue;
+            const o = Object.getOwnPropertyDescriptor(r, l);
+            if (typeof l === "symbol" && !o.enumerable) continue;
+            if (o.get || o.set) {
+                Object.defineProperty(i, l, o);
                 continue;
             }
-            const f = l.value;
+            const f = o.value;
             const s = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
-            if (l.enumerable && l.writable && l.configurable) i[o] = s; else Object.defineProperty(i, o, {
-                ...l,
+            if (o.enumerable && o.writable && o.configurable) i[l] = s; else Object.defineProperty(i, l, {
+                ...o,
                 value: s
             });
         }
@@ -2131,22 +2204,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 o = 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 = i.value;
+        if (l === null || typeof l !== "object") continue;
+        const f = snapshotWalk(l, t, n);
+        if (f !== l) {
+            if (o === null) {
+                o = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                t.set(r, o);
             }
-            l[e] = f;
+            o[e] = f;
         }
     }
-    return l ?? r;
+    return o ?? 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 };