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

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

@@ -1,6 +1,6 @@
-import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
-import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed } from "../../core/core.js";
+import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, context } from "../../core/core.js";
 
 import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, setStoreCommitHook } from "../../core/scheduler.js";
 
@@ -193,7 +193,7 @@ function getNode(e, t, n) {
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(o).De = NOT_PENDING;
+            ext(o).Pe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         // A node born inside a live mark's identity scope inherits the mark
@@ -226,7 +226,7 @@ function getHasNode(e, t, n) {
         }, e.fam?.node ?? undefined);
         o.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(o).De = NOT_PENDING;
+            ext(o).Pe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
@@ -247,7 +247,7 @@ function getKeySetNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
+            ext(n).Pe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
@@ -267,7 +267,7 @@ function getDeepNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
+            ext(n).Pe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
@@ -350,8 +350,22 @@ function cloneRaw(e, t) {
 }
 
 function ensurePB(e) {
-    if (activeTransition !== null) foldBatches.set(e, activeTransition);
     let t = e.pb;
+    // Truth-staged backing hand-off (#3164 fold): a TENTATIVE draft opening on
+    // a target whose pending backing is truth-staged (a landing folded into a
+    // retaining transaction — it carries a foldBatches stamp) must not share
+    // the container. Tentative writes would pollute staged truth, and the
+    // tentative discard (notifyOptimisticWrites nulls pb) would destroy the
+    // landing. Park the staged backing and open a fresh draft seeded from the
+    // optimistic view below; the tentative discard restores it. The
+    // tentativePBs guard scopes this to draft OPEN: the draft's own backing
+    // (foldBatches-stamped by its first write when an action's transition is
+    // ambient) must not be parked by its own later writes.
+        if (t !== null && !tentativePBs.has(t) && e.fam?.opt === true && !projectionWriteActive && !getWriteOverride() && foldBatches.has(e)) {
+        stagedTruthPB.set(e, t);
+        t = e.pb = null;
+    }
+    if (activeTransition !== null) foldBatches.set(e, activeTransition);
     if (t === null) {
         // Prototype-chain overlay (#3044): plain-data non-array containers
         // outside projection/optimistic families open drafts in O(1) — own keys
@@ -369,18 +383,19 @@ function ensurePB(e) {
         // seed from committed truth — seeding overrides there would fold a lane
         // value into the committed home ("authority wins at reveal" would break).
                 if (e.fam?.opt && !projectionWriteActive && !getWriteOverride()) {
+            tentativePBs.add(t);
             const n = e.n;
             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?.Pe);
                 }
             }
             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?.Pe)) delete t[e];
                 }
             }
         }
@@ -406,7 +421,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)?.fn === true) return e.ht = e.hv = null;
+    if (t !== PLAIN_HOLD && currentTransition(t)?.sn === true) return e.ht = e.hv = null;
     return e.hv;
 }
 
@@ -491,6 +506,17 @@ function queueFold(e) {
  * Refreshed on every write; resolved through currentTransition at drain
  * (transitions merge — same rule as heldMaskView). */ const foldBatches = new WeakMap;
 
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */ const stagedTruthPB = new WeakMap;
+
+/** Backings opened by TENTATIVE drafts (optimistic user setters): ensurePB's
+ * truth-park must not fire against the draft's own container on its second
+ * and later writes (the first write stamps foldBatches whenever an action's
+ * transition is ambient). Entries die with their draft — tentative backings
+ * are consumed at setter exit. */ const tentativePBs = new WeakSet;
+
 /** Committed-time privatization for parent-chain slot updates (path copying). */ function privatizeCommitted(e) {
     if (ownedRaw.has(e.v)) return;
     const t = cloneRaw(e.v, e);
@@ -525,7 +551,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).fn === false) {
+                if (currentTransition(e).sn === false) {
                     foldOlds.set(t, n);
                     continue;
                 }
@@ -549,7 +575,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.Re !== NOT_PENDING) {
                         r = true;
                         break;
                     }
@@ -723,15 +749,15 @@ function drainFolds() {
             // projection recompute can run before the prior fold commits) — the
             // node's OWN current value is the true old side, and setSignal's
             // internal equality already checks exactly that.
-                        const f = e.del !== null && e.del.has(o) ? undefined : t[o];
-            setSignal(i, () => f);
+                        const l = e.del !== null && e.del.has(o) ? undefined : t[o];
+            setSignal(i, () => l);
         }
     }
-    const f = e.h;
-    if (f !== null) {
-        const n = o ?? Reflect.ownKeys(f);
+    const l = e.h;
+    if (l !== null) {
+        const n = o ?? Reflect.ownKeys(l);
         for (const r of n) {
-            const n = f[r];
+            const n = l[r];
             if (n !== undefined) setSignal(n, r in t && !(e.del !== null && e.del.has(r)));
         }
     }
@@ -781,7 +807,13 @@ function drainFolds() {
     //   IMMEDIATE — landed truth shows to untracked readers even while a
     //   downstream consumer's own async still holds the effect-level reveal
     //   (spec-async "verdicts never inherit consumers' in-flight state").
-        if (e.fam !== null && e.pb !== null && getWriteOverride()) {
+    //   EXCEPT under an active transaction (#3164 fold): a landing riding a
+    //   retaining transaction (the optimistic module's aroundWrite binds it)
+    //   stages instead — ensurePB stamped foldBatches, so the backing commits
+    //   with the transaction and the reveal is atomic at settle. The pinned
+    //   immediate-commit contract is stated over the no-transaction microtask
+    //   posture, which `activeTransition === null` is exactly.
+        if (e.fam !== null && e.pb !== null && getWriteOverride() && activeTransition === null) {
         // Landed truth (post-await write-override): immediately visible to every
         // reader — any staged held view is superseded.
         if (e.ht !== null) e.ht = e.hv = null;
@@ -849,9 +881,9 @@ i = true) {
             if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
             return;
         }
-        const f = i?.value;
-        const l = o?.value;
-        if (!isEqual(f, l) && !targetsEqual(f, l)) setSignal(e, typeof l === "function" ? () => l : l);
+        const l = i?.value;
+        const f = o?.value;
+        if (!isEqual(l, f) && !targetsEqual(l, f)) setSignal(e, typeof f === "function" ? () => f : f);
     } else {
         const i = n[t];
         const o = r[t];
@@ -976,7 +1008,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ct ? e.Ot : e;
+    const t = e.Gt ? e.Dt : e;
     return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -987,7 +1019,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * committed to them regardless of staged writes. */ function inForbiddenScope() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ct ? e.Ot : e;
+    const t = e.Gt ? e.Dt : e;
     return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -998,7 +1030,7 @@ 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._e != null && n._e.fn !== true) return true;
+        if (n.Re !== NOT_PENDING && n.Ae != null && n.Ae.sn !== true) return true;
     }
     return false;
 }
@@ -1012,20 +1044,52 @@ function readSource(e) {
         const t = heldMaskView(e);
         if (t !== null) return t;
     }
-    // Signal-parity visibility (core read(): owner-context reads serve
-    // _pendingValue, context-free reads serve committed — effects recompute
-    // BEFORE commitPendingNodes in the flush, so the pending view must be
-    // servable). Drafts (setter window OR projection write-override) and
-    // owner-context reads see the pending backing; context-free reads see
-    // committed. Node reads apply the same rule, so both homes agree.
-        if (e.pb !== null && (inDraft(e) || getWriteOverride() || inOwnerContext() || 
+    return pendingBackingVisible(e, false) ? e.pb : e.v;
+}
+
+/** The single pb-vs-committed visibility decision (#3147), shared by per-key
+ * backing reads (readSource) and deep()/snapshot composition (snapshotWalk)
+ * so the two reader families can never disagree about a HELD landing.
+ *
+ * Signal-parity visibility (core read(): owner-context reads serve
+ * _pendingValue, context-free reads serve committed — effects recompute
+ * BEFORE commitPendingNodes in the flush, so the pending view must be
+ * servable). Drafts (setter window OR projection write-override) and
+ * owner-context reads see the pending backing; context-free reads see
+ * committed. Node reads apply the same rule, so all homes agree.
+ *
+ * `speculative` is deep()/snapshot's posture: an untrack/deep PEEK that sees
+ * 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 && !foldHeld(e) && !inForbiddenScope())) return e.pb;
-    return e.v;
+    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope());
+}
+
+/** #3164 fold: HELD truth on an optimistic family — a pending backing
+ * stamped by a live transition that retains optimism — is masked from
+ * ordinary readers (they keep committed until the transaction's reveal);
+ * the authoritative postures and latest() tunnel through. Un-stamped
+ * backings and optimism-free transitions keep ordinary mid-batch/
+ * speculation visibility. */ function heldTruthMasked(e) {
+    if (e.fam?.opt !== true || latestReadActive || authoritativeServe()) return false;
+    const t = foldBatches.get(e);
+    // opt families are only created by createOptimisticStore, whose module
+    // install populates optHooks — the assertion holds by construction.
+        return t !== undefined && optHooks.retainsOptimism(t);
 }
 
 const hasOwn = Object.prototype.hasOwnProperty;
@@ -1057,7 +1121,27 @@ 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;
+    return e.o?.Pe !== undefined && e.o?.Pe !== 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;
+}
+
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */ function authoritativeServe() {
+    return projectionWriteActive || getWriteOverride() || authoritativeRead();
 }
 
 /** Context-aware node view for reads outside tracking: active override >
@@ -1069,7 +1153,17 @@ function isOwnAccessor(e, t) {
  * 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.
-    const n = hasActiveOverride(e) ? unwrapOverride(e.o?.De) : e.Pe !== NOT_PENDING && (latestReadActive || inOwnerContext()) ? e.Pe : t;
+    // 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?.Pe) : e.Re !== 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.Re : t;
     return n === FORCE ? t : n;
 }
 
@@ -1079,7 +1173,7 @@ function isOwnAccessor(e, t) {
  * node is linked only for adoption-swap notification, its value never
  * shadows the live chain. */ function serveDataKey(e, t, n, r, i) {
     const o = e.ch && r === e.v;
-    let f = n;
+    let l = n;
     // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
     // (backing ± presence overrides) for both length and indices makes torn
     // iteration impossible (a length node's value rides different visibility
@@ -1094,15 +1188,20 @@ function isOwnAccessor(e, t) {
                 read(getNode(e, t, n));
             }
         }
-        return optHooks.optimisticView(e, r).length;
+        // 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;
     }
     if (inDraft(e)) {
         // Optimistic drafts before their first write have no pending backing yet;
         // reads must still see the live optimistic view (compose, not clobber —
         // #2951). Once ensurePB runs, the seeded clone carries the view.
-        if (e.fam?.opt && e.pb === null) {
+        // AUTHORITATIVE drafts (projection derive) never overlay — ensurePB's
+        // seeding rule, applied to the read side (#3108).
+        if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
+            if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
         }
     } else {
         if (i !== undefined) {
@@ -1114,28 +1213,28 @@ function isOwnAccessor(e, t) {
                 // parity): READ_SLOW = a global read window or non-plain node.
                 let e = readNodeFast(i);
                 if (e === READ_SLOW) e = read(i);
-                if (!o || hasActiveOverride(i)) f = e === FORCE ? n : e;
+                if (!o || hasActiveOverride(i)) l = e === FORCE ? n : e;
             } else if (!o || hasActiveOverride(i)) {
-                f = nodeValue(i, n);
+                l = nodeValue(i, n);
             }
         } else if (getObserver() !== null) {
             read(getNode(e, t, n));
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
-        if (e.s) return serveShallow(e, t, f);
+        if (e.s) return serveShallow(e, t, l);
     if (i !== undefined) {
         // Wrap cache (see getNode): only wrappables are ever cached, so a hit
         // skips isWrappable too — pointer-compare replaces both checks.
-        if (i.pxv === f && f !== undefined) return draftServe(e, i.px);
-        if (!isWrappable(f)) return f;
-        const n = wrapNext(f, e, t);
+        if (i.pxv === l && l !== undefined) return draftServe(e, i.px);
+        if (!isWrappable(l)) return l;
+        const n = wrapNext(l, e, t);
         i.px = n;
-        i.pxv = f;
+        i.pxv = l;
         return draftServe(e, n);
     }
-    if (!isWrappable(f)) return f;
-    return draftServe(e, wrapNext(f, e, t));
+    if (!isWrappable(l)) return l;
+    return draftServe(e, wrapNext(l, e, t));
 }
 
 /** §6c store-wide status gate for reads that DON'T flow through a node:
@@ -1269,15 +1368,15 @@ const traps = {
         // that is own on NEITHER.
                 const o = e.ovl && r === e.pb;
         if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return undefined;
-        let f = r[t];
-        if (f === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
+        let l = r[t];
+        if (l === 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;
+            l = Reflect.get(r, t, n);
+            if (typeof l === "function") return l;
  // proto methods untracked
             // 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 (l === undefined && !inDraft(e)) {
                 if (getObserver() !== null) read(getNode(e, t, undefined));
                 const n = e.n?.[t];
                 if (n) {
@@ -1285,16 +1384,19 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (f === undefined && inDraft(e) && e.fam?.opt && e.pb === null) {
+            } else if (l === undefined && inDraft(e) && e.fam?.opt && e.pb === null && 
+            // AUTHORITATIVE drafts (landing folds) never seed from overrides —
+            // 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 && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
             }
-            if (e.s) return serveShallow(e, t, f);
-            return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
+            if (e.s) return serveShallow(e, t, l);
+            return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
         }
-        if (typeof f === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return f;
+        if (typeof l === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return l;
  // proto method
-                return serveDataKey(e, t, f, r, i);
+                return serveDataKey(e, t, l, r, i);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
@@ -1307,15 +1409,17 @@ const traps = {
         if (!inDraft(e)) {
             if (getObserver() !== null) {
                 const n = getHasNode(e, t, r);
-                const i = read(n);
+                // Authoritative-view readers get the right answer for free: core read()
+                // skips the override arm for them, so nv is authoritative presence.
+                                const i = read(n);
                 if (hasActiveOverride(n)) r = !!i;
-            } else {
+            } else if (!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?.Pe);
             }
-        } else if (e.fam?.opt && e.pb === null) {
+        } else if (e.fam?.opt && e.pb === null && !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?.Pe);
         }
         return r;
     },
@@ -1338,14 +1442,15 @@ const traps = {
         // Optimistic membership overlay: presence-node overrides add/remove keys
         // (per-transaction lifecycle rides the nodes — §6, FINDING-2's fix).
         // Draft reads before the first write overlay too (pb, once created, is
-        // seeded with the view).
-                if (e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
+        // seeded with the view). Authoritative-view reads (until()'s predicate,
+        // truth-author drafts) skip the overlay.
+                if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
             let t = null;
             for (const r of Reflect.ownKeys(e.h)) {
                 const i = e.h[r];
                 if (!hasActiveOverride(i)) continue;
                 t ??= new Set(n);
-                if (unwrapOverride(i.o?.De)) t.add(r); else t.delete(r);
+                if (unwrapOverride(i.o?.Pe)) t.add(r); else t.delete(r);
             }
             if (t !== null) return [ ...t ];
         }
@@ -1360,10 +1465,10 @@ const traps = {
             if (e.del !== null && e.del.has(t)) return undefined;
             if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
         }
-        if (e.fam?.opt && !inDraft(e)) {
+        if (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
             const n = e.h?.[t];
             if (n !== undefined && hasActiveOverride(n)) {
-                if (!unwrapOverride(n.o?.De)) return undefined;
+                if (!unwrapOverride(n.o?.Pe)) return undefined;
  // opt delete
                                 if (r === undefined) {
                     const n = e.n?.[t];
@@ -1399,23 +1504,23 @@ const traps = {
         // passes through by reference (#2932; markRawOne skips proxies), while
         // deep stores unwrap to raw backings.
                 const o = e.s ? n : unwrapValue(n);
-        const f = ensurePB(e);
+        const l = ensurePB(e);
         pendingNotify.add(e);
         // Array length writes implicitly delete indices — the written-keys bound
         // can't see them, so poison to the full scan for this batch. Index
         // writes implicitly GROW length, so arrays always record it alongside.
-                const l = pcOf(e);
-        if (Array.isArray(f)) {
-            if (t === "length") l.wk = WK_ALL; else if (l.wk !== WK_ALL) {
-                const e = l.wk ??= new Set;
+                const f = pcOf(e);
+        if (Array.isArray(l)) {
+            if (t === "length") f.wk = WK_ALL; else if (f.wk !== WK_ALL) {
+                const e = f.wk ??= new Set;
                 e.add(t);
                 e.add("length");
             }
-        } else if (l.wk !== WK_ALL) (l.wk ??= new Set).add(t);
+        } else if (f.wk !== WK_ALL) (f.wk ??= new Set).add(t);
         // Own data keys literally named "prototype"/"constructor" land as data —
         // defineProperty sidesteps a proto-chain setter named the same.
                 if (UNSAFE_KEYS.has(t)) {
-            Object.defineProperty(f, t, {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
@@ -1427,14 +1532,14 @@ const traps = {
         // Overlay first-write DEFINES the own key: assignment through the proto
         // chain would reject on a non-writable committed property (the clone
         // path normalized descriptors for exactly this — R51 parity).
-                if (e.ovl && !hasOwn.call(f, t)) {
-            Object.defineProperty(f, t, {
+                if (e.ovl && !hasOwn.call(l, t)) {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else f[t] = o;
+        } else l[t] = o;
         if (e.del !== null) e.del.delete(t);
         // Shallow ingest: written records are sticky raw-marked (one entity is
         // never both deep-wrapped and raw — R41/#2932, shared invariant).
@@ -1464,8 +1569,8 @@ const traps = {
         };
         const o = ensurePB(e);
         pendingNotify.add(e);
-        const f = pcOf(e);
-        if (f.wk !== WK_ALL) (f.wk ??= new Set).add(t);
+        const l = pcOf(e);
+        if (l.wk !== WK_ALL) (l.wk ??= new Set).add(t);
         Object.defineProperty(o, t, n);
         if (e.del !== null) e.del.delete(t);
         if (i) notifyWrites(e);
@@ -1603,15 +1708,15 @@ function createStoreNext(e, t = false) {
             if (o === null || typeof o !== "object") continue;
             // Stored proxies (chained slots) resolve through their own target;
             // raw children through the family map, created on first visit.
-                        let f = o[$TARGET] ?? r.get(o);
-            if (f === undefined) {
+                        let l = o[$TARGET] ?? r.get(o);
+            if (l === undefined) {
                 if (!isWrappable(o)) continue;
                 wrapNext(o, e, n);
-                f = r.get(o);
-                if (f === undefined) continue;
+                l = r.get(o);
+                if (l === undefined) continue;
  // raw-marked: leaf by contract
                         }
-            walkT(f);
+            walkT(l);
         }
     };
     walkT(t);
@@ -1648,12 +1753,17 @@ function snapshotWalk(e, t, n) {
         if (e === undefined) break;
         if (e.fam !== null) n = e.fam;
         if (e.fam?.opt === true) (i ??= []).push(e);
+        // 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 t = pendingBackingVisible(e, true);
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
-                if (e.ovl) materializePB(e);
-        const t = e.pb ?? e.v;
-        if (t === r) break;
-        r = t;
+                if (t && e.ovl) materializePB(e);
+        const o = t ? e.pb : e.v;
+        if (o === r) break;
+        r = o;
     }
     if (!isWrappable(r)) return r;
     // Optimistic families: compose the visible view; a composed view is a fresh
@@ -1665,15 +1775,15 @@ function snapshotWalk(e, t, n) {
             const i = t.get(r);
             if (i !== undefined) return i;
             const o = Array.isArray(e);
-            const f = o ? [] : Object.create(Object.getPrototypeOf(e));
-            t.set(r, f);
+            const l = o ? [] : Object.create(Object.getPrototypeOf(e));
+            t.set(r, l);
             for (const r of Reflect.ownKeys(e)) {
                 if (o && r === "length") continue;
                 const i = e[r];
-                f[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
+                l[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
             }
-            if (o) f.length = e.length;
-            return f;
+            if (o) l.length = e.length;
+            return l;
         }
     }
     const o = t.get(r);
@@ -1688,16 +1798,16 @@ function snapshotWalk(e, t, n) {
         t.set(r, i);
         for (const o of Reflect.ownKeys(r)) {
             if (e && o === "length") continue;
-            const f = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !f.enumerable) continue;
-            if (f.get || f.set) {
-                Object.defineProperty(i, o, f);
+            const l = Object.getOwnPropertyDescriptor(r, o);
+            if (typeof o === "symbol" && !l.enumerable) continue;
+            if (l.get || l.set) {
+                Object.defineProperty(i, o, l);
                 continue;
             }
-            const l = f.value;
-            const u = l !== null && typeof l === "object" ? snapshotWalk(l, t, n) : l;
-            if (f.enumerable && f.writable && f.configurable) i[o] = u; else Object.defineProperty(i, o, {
-                ...f,
+            const f = l.value;
+            const u = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
+            if (l.enumerable && l.writable && l.configurable) i[o] = u; else Object.defineProperty(i, o, {
+                ...l,
                 value: u
             });
         }
@@ -1707,22 +1817,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 f = null;
+    let l = 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 l = snapshotWalk(o, t, n);
-        if (l !== o) {
-            if (f === null) {
-                f = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                t.set(r, f);
+        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);
             }
-            f[e] = l;
+            l[e] = f;
         }
     }
-    return f ?? r;
+    return l ?? r;
 }
 
-export { adoptPB, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };