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

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settlePendingSource, settleErroredDependents } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, STATUS_PENDING, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, CONFIG_DIRECT_COMMIT, OVERRIDE_UNDEFINED, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_AUTHORITATIVE_READ, CONFIG_HELD_TRUTH, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_FW_CHILDREN, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_MANUAL_WRITE, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, EFFECT_USER, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, CONFIG_DIRECT_COMMIT, OVERRIDE_UNDEFINED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_INPUTS_PUBLISHED, CONFIG_AUTHORITATIVE_READ, CONFIG_OVERRIDE_SUPERSEDED, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_HELD_TRUTH, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_MANUAL_WRITE, CONFIG_FW_CHILDREN, CONFIG_SLOT_NODE, STORE_SNAPSHOT_PROPS } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -8,15 +8,29 @@ import { trimStaleDeps, link, dormantNodes } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeapHeight, enqueueSub, markNode, markHeap, insertIntoHeap } from "./heap.js";
 
-import { GlobalQueue, bumpNotifyEpoch, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, runInTransition, schedule, notifyEpoch, dirtyQueue, projectionWriteActive, reaskArmed, armReaskClear } from "./scheduler.js";
+import { GlobalQueue, bumpNotifyEpoch, activeTransition, globalQueue, clock, currentTransition, insertSubs, queuePendingNode, runInTransition, schedule, notifyEpoch, dirtyQueue, projectionWriteActive, reaskArmed, armReaskClear } from "./scheduler.js";
 
 import "./invariants.js";
 
 import { disposeChildren, markDisposal, inheritId } from "./owner.js";
 
-GlobalQueue.Fe = recompute;
+// The heap's per-node step. A tracked effect's heap visit is its compute
+// phase — empty, like a user effect whose compute reads nothing — and hands
+// the callback to the user queue. Routing the wake through the heap, rather
+// than straight into the queue at notify time, is what orders the run after
+// the commit regardless of which phase the write came from: a write in a
+// render-effect callback stages its value for the next pass, but a wake pushed
+// directly into the user queue ran in the SAME pass, read the old value, and
+// nothing re-notified it when the value landed (#3291).
+GlobalQueue.Fe = e => {
+    if (e.Ce === EFFECT_TRACKED) {
+        deleteFromHeap(e, queueFor(e));
+        e.He = true;
+        e.C.enqueue(EFFECT_USER, e.Ve);
+    } else recompute(e);
+};
 
-GlobalQueue.He = disposeChildren;
+GlobalQueue.We = disposeChildren;
 
 let tracking = false;
 
@@ -48,8 +62,8 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.Ve) return true;
-        e = e.ke;
+        if (e.Me) return true;
+        e = e.qe;
     }
     return false;
 }
@@ -60,20 +74,20 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.Ve = true;
+    e.Me = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.Ve = false;
+    e.Me = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.xe;
+    let t = e.Ye;
     while (t) {
-        if (t.Ve) {
-            t = t.Le;
+        if (t.Me) {
+            t = t.Ze;
             continue;
         }
         if (t.oe) {
@@ -82,19 +96,19 @@ function releaseSubtree(e) {
             if (e.ie & REACTIVE_SNAPSHOT_STALE) {
                 e.ie &= ~REACTIVE_SNAPSHOT_STALE;
                 e.ie |= REACTIVE_DIRTY;
-                if (dirtyQueue.Qe > e.Me) dirtyQueue.Qe = e.Me;
+                if (dirtyQueue.Ke > e.Be) dirtyQueue.Ke = e.Be;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.Le;
+        t = t.Ze;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.o?.We;
+            delete e.o?.ze;
             // StoreNode targets share one pre-initialized hidden class (see
             // createStoreProxy) — assign undefined instead of deleting, and only
             // when present so signal-node sources don't grow the field.
@@ -108,12 +122,12 @@ function clearSnapshots() {
 function recompute(e, t = false) {
     // §12d: any recompute can clean a marked subscriber — invalidate skips.
     bumpNotifyEpoch();
-    const n = e.ge;
+    const n = e.Ce;
     if (!t) {
-        if (e.Ae && (!n || activeTransition) && activeTransition !== e.Ae) globalQueue.initTransition(e.Ae);
+        if (e.ge && (!n || activeTransition) && activeTransition !== e.ge) globalQueue.initTransition(e.ge);
         deleteFromHeap(e, queueFor(e));
         if (e.o !== null) {
-            e.o.Ie = null;
+            e.o.Pe = null;
             // Supersede is where an iterator flight dies (#3122): close it now.
             // Its cleanup(close) registration may sit in a zombie-deferred
             // disposal list that a held transition only drains when the
@@ -122,49 +136,50 @@ function recompute(e, t = false) {
                         releaseFlightTeardown(e);
         }
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.Ae || n === EFFECT_TRACKED) disposeChildren(e); else if (e.xe !== null || e.Ge !== null) {
+                if (e.ge || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Ye !== null || e.we !== null) {
             markDisposal(e);
             const t = ext(e);
-            t.qe = e.Ge;
-            t.Ye = e.xe;
-            e.Ge = null;
-            e.xe = null;
-            e.Ze = 0;
+            t.Je = e.we;
+            t.Xe = e.Ye;
+            e.we = null;
+            e.Ye = null;
+            e.$e = 0;
         } else ;
     }
     let i = !!(e.ie & REACTIVE_OPTIMISTIC_DIRTY);
-    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.Pe !== NOT_PENDING && e.o?.Pe !== undefined;
-    const l = !!(e.S & STATUS_UNINITIALIZED);
-    // Outgoing error, captured before the compute clears status: if this run
-    // recovers to an unchanged value, dependents still holding this object must
-    // be swept (settleErroredDependents, #2949).
+    const l = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.be !== NOT_PENDING && e.o?.be !== undefined;
+    const u = !!(e.S & STATUS_UNINITIALIZED);
+    // Capture both error and pending status before the compute clears them.
+    // A conditional can drop its pending source and recover to an unchanged
+    // value, leaving blocked dependents outside that source’s settle walk.
         const o = e.S & STATUS_ERROR ? e.o?._ : undefined;
+    const s = e.S & STATUS_PENDING ? e.o?.le : undefined;
     // Pending SOURCE-hood, captured before the compute clears status: a node
     // whose own flight parked dependents self-registers in _pendingSources
     // (notifyStatus, isSource). If this recompute supersedes that flight and
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const s = e.o?.le?.has(e);
+        const a = e.o?.le?.has(e);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const a = (e.ie & REACTIVE_REASK) !== 0;
+        const r = (e.ie & REACTIVE_REASK) !== 0;
     // Captured before the compute clears it on a sync landing: if that landing
     // is transition-held below, the window must stay open until the hold
     // commits (commitPendingNode) — a closed window plus a held value reads as
     // a pending frame to live observers of the verdict (#2990).
-        const r = e.Ne;
-    const c = context;
+        const c = e.Ae;
+    const _ = context;
     context = e;
-    e.je = null;
-    e.Ke++;
+    e.et = null;
+    e.tt++;
     e.ie = REACTIVE_RECOMPUTING_DEPS;
-    e.Te = clock;
-    let _ = e.Re === NOT_PENDING ? e.be : e.Re;
-    let f = e.Me;
+    e._e = clock;
+    let f = e.Ge === NOT_PENDING ? e.me : e.Ge;
+    let E = e.Be;
     let I = false;
-    let E = tracking;
-    let N = currentOptimisticLane;
+    let N = tracking;
+    let T = currentOptimisticLane;
     tracking = true;
     // A computed's fn establishes its OWN dependencies, so it must never run
     // inside a latest() read window: read() short-circuits through the
@@ -172,54 +187,61 @@ function recompute(e, t = false) {
     // computed) inside latest(fn) came out permanently dependency-less (#2926).
     // latestRead() already suspends the flag for its pull-recomputes; this
     // covers creation-time computes and flushes that run inside the window.
-        const T = latestReadActive;
+        const d = latestReadActive;
     latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (i) {
-        const t = GlobalQueue.Be(e, true);
+        const t = GlobalQueue.nt(e, true);
         if (t) currentOptimisticLane = t;
         // `false` = wake-only lane demotion: recompute plain so a mid-tick
         // latest()/isPending() pull stages instead of direct-committing (#3009).
         // The predicate lives with the engine (recomputeLane).
          else if (t === false) i = false;
-    } else if (activeTransition && !t && activeTransition.ze.length) {
+    } else if (activeTransition && !t && activeTransition.it.length) {
         // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
         // child propagates. Walk deps once and inherit the OPT lane so this node
         // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.Be(e, false);
+        const t = GlobalQueue.nt(e, false);
         if (t) {
             i = true;
             currentOptimisticLane = t;
         }
     }
     const S = n && n !== EFFECT_USER;
-    const d = stale;
+    const A = stale;
     if (S) stale = true;
+    // An effect recorded for this transaction's commit replay (it once read a
+    // node the transaction held and showed the committed value) and now
+    // recomputing UNDER the transaction sees its staged view: the value this
+    // run produces is applied by the commit itself, and the stale recording
+    // would publish the frame a second time. Drop it; the reads below re-record
+    // if they are served the committed view again (a lane's committed read).
+        if (n && activeTransition !== null && activeTransition.lt.size) activeTransition.lt.delete(e);
     try {
         if (!false && e.T & CONFIG_SYNC) {
-            _ = e.oe(_);
-            if (e.o !== null) e.o.Ie = null;
-            e.Ne = false;
+            f = e.oe(f);
+            if (e.o !== null) e.o.Pe = null;
+            e.Ae = false;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
             // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.o?.Ie;
-            const n = e.oe(_);
+            const t = e.o?.Pe;
+            const n = e.oe(f);
             const i = typeof n === "object" && n !== null;
-            const u = e.o?.Ie !== t;
-            _ = u || !i ? n : handleAsync(e, n);
-            if (!u && !i) {
-                if (e.o !== null) e.o.Ie = null;
+            const l = e.o?.Pe !== t;
+            f = l || !i ? n : handleAsync(e, n);
+            if (!l && !i) {
+                if (e.o !== null) e.o.Pe = null;
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight (inFlightChanged — projections) clears when
                 // its internal handleAsync lands.
-                                e.Ne = false;
+                                e.Ae = false;
             }
         }
         // On a status-free node clearStatus is a guaranteed no-op: every field
@@ -229,10 +251,10 @@ function recompute(e, t = false) {
                 if (e.S !== 0 || e.o !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
         // is their sticky presence mark).
-                if (e.T & CONFIG_HAS_LANE && e.o?.Je) GlobalQueue.Xe(e);
+                if (e.T & CONFIG_HAS_LANE && e.o?.Oe) GlobalQueue.ut(e);
     } catch (t) {
         const n = t instanceof NotReadyError;
-        if (n && e.Ne) {
+        if (n && e.Ae) {
             // Loading window with an unready sync dependency: register for the
             // source's settle (the settlePendingSource walk runs off
             // _pendingSources + _blocked alone) but take NO read-visible pending
@@ -244,22 +266,22 @@ function recompute(e, t = false) {
         } else {
             // Track pending async in the lane (not the lane's source — it creates the lane
             // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-            if (n && currentOptimisticLane) GlobalQueue.$e(e);
+            if (n && currentOptimisticLane) GlobalQueue.ot(e);
             let i = false;
             if (n) {
-                ext(e).fe = true;
-                if (GlobalQueue.et !== null) i = GlobalQueue.et(e, a);
+                ext(e).de = true;
+                if (GlobalQueue.st !== null) i = GlobalQueue.st(e, r);
             }
-            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Je : undefined);
+            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Oe : undefined);
             // The replacement source is fully propagated now. If no new flight
             // re-owned self, retire the superseded flight and its dependent copies.
-                        if (n && s && !e.o?.Ie) settlePendingSource(e);
+                        if (n && a && !e.o?.Pe) settlePendingSource(e);
             if (i) GlobalQueue.k(e);
         }
     } finally {
-        tracking = E;
-        latestReadActive = T;
-        if (S) stale = d;
+        tracking = N;
+        latestReadActive = d;
+        if (S) stale = A;
         // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
         // landed beneath this pass on a link it had already validated. The wipe
         // below must not key off DIRTY/CHECK — the read-time pull protocol
@@ -267,14 +289,20 @@ function recompute(e, t = false) {
         // bookkeeping, and those marks are correctly discarded here.
                 I = (e.ie & REACTIVE_MISSED_WAKE) !== 0;
         e.ie = REACTIVE_NONE | (t ? e.ie & REACTIVE_SNAPSHOT_STALE : 0);
-        context = c;
+        context = _;
     }
     if (!e.o?._) {
         trimStaleDeps(e);
-        const a = u ? unwrapOverride(e.o?.Pe) : e.Re === NOT_PENDING ? e.be : e.Re;
-        let c = false;
+        // INV-11 (#3330): the equality gate compares against the slot this run
+        // publishes to. An override-covered node publishes the override; a lane
+        // recompute (OPT-dirty) direct-commits `_value` — the lane's own reveal
+        // schedule — so a transaction-held `_pendingValue` that already equals
+        // the new result is not "unchanged": the screen still shows `_value`.
+        // Only a transaction-staged run compares against `_pendingValue`.
+                const r = l ? unwrapOverride(e.o?.be) : i || e.Ge === NOT_PENDING ? e.me : e.Ge;
+        let _ = false;
         try {
-            c = !n && l || !e.pe || !e.pe(a, _);
+            _ = !n && u || !e.ve || !e.ve(r, f);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -287,14 +315,37 @@ function recompute(e, t = false) {
         // its runner — happen here instead. `!create` matches the previous `initialized`
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
-                if (n && c) {
-            e.tt = !e.o?._;
+                if (n && _) {
+            e.He = !e.o?._;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.C.enqueue(n, e.nt ??= GlobalQueue.it.bind(null, e));
+                        if (!t) {
+                e.C.enqueue(n, e.rt ??= GlobalQueue.ct.bind(null, e));
+                // Contested effect (#3322). Effects don't entangle transactions (a
+                // shared effect is not shared state), yet they have one value slot:
+                // when this write commits under a different transaction
+                // (`activeTransition`, null = mainline) than the one that produced the
+                // previous value (`_valueTransition`), that view is gone. Rather than
+                // merge the two, each commit re-derives the effect against its own
+                // committed world (Transition._contested, re-dirtied by
+                // finalizePureQueue ahead of the heap run). The previous owner always
+                // needs it if still live: its commit is silent (staging already
+                // notified) and the value it computed is gone. The new owner needs it
+                // too, for the same reason, unless it is mainline — mainline publishes
+                // what it computes. A previous owner that was mainline, or already
+                // committed, left nothing to protect.
+                                let t = e._t;
+                if (t !== activeTransition) {
+                    e._t = activeTransition;
+                    if (t !== null && (t = currentTransition(t)) !== activeTransition && !t.ft) {
+                        (t.Et ??= []).push(e);
+                        if (activeTransition !== null) (activeTransition.Et ??= []).push(e);
+                    }
+                }
+            }
         }
-        if (e.o?._) ; else if (c) {
-            const l = u ? e.o?.Pe : undefined;
+        if (e.o?._) ; else if (_) {
+            const u = l ? e.o?.be : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
             // values directly — the pending round-trip (queuePendingNode +
@@ -304,48 +355,62 @@ function recompute(e, t = false) {
             // their own held transition: their applies deliver on a microtask,
             // not the stashed queues, so a staged value would hand the immediate
             // apply stale state — see CONFIG_DIRECT_COMMIT.
-            n && (activeTransition !== e.Ae || activeTransition === null || e.T & CONFIG_DIRECT_COMMIT) || i) {
-                e.be = _;
+            n && (activeTransition !== e.ge || activeTransition === null || e.T & CONFIG_DIRECT_COMMIT) || i) {
+                e.me = f;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
-                                if (u && i) {
-                    ext(e).Pe = _ === undefined ? OVERRIDE_UNDEFINED : _;
-                    e.Re = NOT_PENDING;
+                                if (l && i) {
+                    ext(e).be = f === undefined ? OVERRIDE_UNDEFINED : f;
+                    e.Ge = NOT_PENDING;
                 }
             } else {
-                e.Re = _;
+                e.Ge = f;
                 // A window landing that gets held re-opens the window until the hold
                 // commits — the verdict's held-value branch is window-gated (#2990).
-                                if (r) e.Ne = true;
+                                if (c) e.Ae = true;
                 // Transition-held sync recompute is a write path like setSignal/asyncWrite,
                 // so sync derivations of held sources stay visible to isPending()/latest()
                 // (#2831). Both companion writes are transition-scoped (optimistic) and
                 // auto-revert/re-derive at commit. Skipped for plain flushes where the
                 // pending value commits before effects run.
-                                if ((activeTransition || e.Ae) && GlobalQueue.Ue !== null) GlobalQueue.Ue(e, _);
+                                if ((activeTransition || e.ge) && GlobalQueue.pe !== null) GlobalQueue.pe(e, f);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.u !== null && (!u || i || e.o?.Pe !== l)) insertSubs(e, i || u);
-        } else if (u) {
+                        if (e.u !== null && (!l || i || e.o?.be !== u)) insertSubs(e, i || l);
+            // A18 supersession, sync twin of asyncWrite's override branch (#3331):
+            // this pass published truth that differs from the override (the gate
+            // compared against it) into the transaction-held slot. Whether the
+            // source is this node's own async or an upstream node it derives from
+            // synchronously makes no difference — "the source recomputed". The
+            // override stays displayed until the commit; the graph moves to the
+            // staged truth now (plain channel, lane demoted). Ordering: "a new
+            // value from the source" postdates the override — an override written
+            // in this same tick (optimisticWrite stamps `_overrideTime`) is the
+            // newer intent over whatever this pass derives from the batch's staged
+            // inputs, and is not superseded by it.
+             else if (l && !i && e.o.It !== clock) GlobalQueue.ye(e, f);
+        } else if (l) {
             // Unchanged value (equals the override) recomputed while the override
             // is active: _value may still be stale, so hold the authoritative value
             // for commit on its own transition's schedule — invisibly (A17/A18).
-            if (e.Re === NOT_PENDING) queuePendingNode(e);
-            e.Re = _;
-            if (r) e.Ne = true;
+            if (e.Ge === NOT_PENDING) queuePendingNode(e);
+            e.Ge = f;
+            if (c) e.Ae = true;
  // see the held branch above (#2990)
-            // A authoritative-view reader (until()) observed this node past its
-            // override — and "authoritative arrival equal to the override" is
-            // exactly the acknowledgment it waits for. Wake those readers only;
-            // A17 silence holds for every ordinary subscriber. (Hook installed by
-            // until(), the only setter of the gating bit.)
-                        if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue.he(e);
-        } else if (e.Me != f) {
-            for (let t = e.u; t !== null; t = t.ae) {
-                insertIntoHeapHeight(t.ce, queueFor(t.ce));
+            // A confirmation after a supersession restores the override as the
+            // graph's value and notifies; a plain confirmation wakes only an
+            // authoritative-view reader (until()'s predicate, refresh()'s waiter)
+            // that observed this node past its override — "authoritative arrival
+            // equal to the override" is exactly the acknowledgment it waits for;
+            // A17 silence holds for every ordinary subscriber. Both live in the
+            // engine's supersedeOverride.
+                        GlobalQueue.ye(e, f);
+        } else if (e.Be != E) {
+            for (let t = e.u; t !== null; t = t.Te) {
+                insertIntoHeapHeight(t.Ie, queueFor(t.Ie));
             }
         }
         // Silent recovery: errored → unchanged value fires no notification, but
@@ -353,21 +418,26 @@ function recompute(e, t = false) {
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
-                if (o !== undefined && !c && !e.o?._) settleErroredDependents(e, o);
+                if (!_ && !e.o?._) {
+            if (o !== undefined) settleErroredDependents(e, o);
+            // Self-registration (this node's own superseded flight) is the #3181
+            // sweep's business below — retiring it here too would walk twice.
+                        if (s) for (const t of s) if (t !== e) settlePendingSource(e, t);
+        }
         // #3181: a synchronous settle supersedes the old landing callback, so
         // recompute owns its pending-source sweep. An uninitialized node without
         // a replacement source still has no truth to reveal and must stay parked.
-                if (s && !(e.S & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
+                if (a && !(e.S & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
     }
-    currentOptimisticLane = N;
-    const A = e.Re !== NOT_PENDING || e.o !== null && (e.o.Ye !== null || e.o.qe !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    currentOptimisticLane = T;
+    const C = e.Ge !== NOT_PENDING || e.o !== null && (e.o.Xe !== null || e.o.Je !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
     // under the override (A17). Revert no longer commits anything, so an
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        A && (!t || e.S & STATUS_PENDING) && (!e.Ae || u) && queuePendingNode(e);
-    e.Ae && n && activeTransition !== e.Ae && runInTransition(e.Ae, () => recompute(e));
+        C && (!t || e.S & STATUS_PENDING) && (!e.ge || l) && queuePendingNode(e);
+    e.ge && n && activeTransition !== e.ge && runInTransition(e.ge, () => recompute(e));
     // Missed-wake reschedule (see the finally above): values this pass read
     // before the nested commit are stale, so run again now that the heap will
     // accept the node. Equality gates stop same-value landings from cascading,
@@ -388,9 +458,9 @@ function updateIfNecessary(e) {
     // would resurrect it (#2983) — readers serve its last value.
     if (e.ie & (REACTIVE_RECOMPUTING_DEPS | REACTIVE_DISPOSED)) return;
     if (e.ie & REACTIVE_CHECK) {
-        for (let t = e.ut; t; t = t.lt) {
-            const n = t.ot;
-            const i = n.st || n;
+        for (let t = e.fe; t; t = t.ae) {
+            const n = t.Se;
+            const i = n.ce || n;
             if (i.oe) {
                 updateIfNecessary(i);
             }
@@ -399,7 +469,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?._ && e.Te < clock && !e.o?.Ie) {
+    if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?._ && e._e < clock && !e.o?.Pe) {
         recompute(e);
     }
     e.ie = e.ie & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
@@ -411,45 +481,53 @@ function computed(e, t) {
     // `T | undefined` node is a real commit #0. The typeof guard tolerates
     // non-object option values that older call shapes force through `as any`.
         const i = t !== null && typeof t === "object" && "loadingValue" in t;
-    const u = {
+    // Two literals, one per tier, selected at build time (the observe flag is
+    // a literal after replacement; the untaken branch is dead code). The observe
+    // literal is the prod literal plus its `_name` slot — a slot in the
+    // boilerplate, because a post-construction `self._name = …` forces a
+    // hidden-class transition and an out-of-object property store on EVERY node
+    // (measured: the whole of the observe tier's creation overhead). Keep the
+    // two in sync — the dist artifact test pins observe's key set to prod's
+    // plus `_name`.
+        const l = {
         id: inheritId(t, n, context),
         T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        pe: t?.equals ?? isEqual,
-        Ge: null,
+        ve: t?.equals ?? isEqual,
+        we: null,
         C: context?.C ?? globalQueue,
-        we: context?.we ?? defaultContext,
-        Ze: 0,
+        xe: context?.xe ?? defaultContext,
+        $e: 0,
         oe: e,
-        be: i ? t.loadingValue : undefined,
-        Me: 0,
-        rt: undefined,
-        ct: null,
-        ut: null,
-        je: null,
-        Ke: 0,
+        me: i ? t.loadingValue : undefined,
+        Be: 0,
+        Nt: undefined,
+        Tt: null,
+        fe: null,
+        et: null,
+        tt: 0,
         u: null,
-        _t: null,
-        ke: context,
-        Le: null,
-        ft: null,
-        xe: null,
+        dt: null,
+        qe: context,
+        Ze: null,
+        St: null,
+        Ye: null,
         ie: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
         S: i ? 0 : STATUS_UNINITIALIZED,
-        Te: clock,
-        Re: NOT_PENDING,
-        Ae: null,
-        It: -1,
-        Ne: i,
+        _e: clock,
+        Ge: NOT_PENDING,
+        ge: null,
+        At: -1,
+        Ae: i,
         // Cold machinery (async/transition/optimistic/verdict slots) lives one
         // hop away in the lazily-allocated extension — the core literal MUST
         // stay under V8's in-object boundary (§12: past ~39 fields every
         // allocation spills to a backing store and creation cost ~4x's).
         o: null
     };
-    if (t?.unobserved) ext(u).Et = t.unobserved;
-    setupComputedNode(u, t);
-    return u;
+    if (t?.unobserved) ext(l).Ct = t.unobserved;
+    setupComputedNode(l, t);
+    return l;
 }
 
 /** Lazily allocate a node's cold extension (ONE shape for signals and
@@ -457,26 +535,28 @@ function computed(e, t) {
  * this; hot paths read `el._x?._field` gated by the _config presence bits.
  * Never call ext() just to store a field's default. */ function ext(e) {
     return e.o ??= {
-        Pe: undefined,
-        Nt: undefined,
-        Je: undefined,
-        ye: undefined,
-        Ce: undefined,
-        Tt: undefined,
+        be: undefined,
+        Ot: undefined,
+        It: 0,
+        Rt: 0,
+        Oe: undefined,
+        Le: undefined,
+        Qe: undefined,
+        Gt: undefined,
         t: 0,
-        Ie: null,
-        Ee: null,
+        Pe: null,
+        De: null,
         _: undefined,
-        fe: undefined,
+        de: undefined,
         le: undefined,
         h: undefined,
-        De: false,
+        Ue: false,
         i: null,
-        Et: undefined,
-        We: undefined,
-        qe: null,
-        Ye: null,
-        St: undefined
+        Ct: undefined,
+        ze: undefined,
+        Je: null,
+        Xe: null,
+        Dt: undefined
     };
 }
 
@@ -485,43 +565,49 @@ function computed(e, t) {
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
- */ function createEffectNode(e, t, n, i, u) {
-    const l = u?.transparent ?? false;
-    const o = {
-        id: inheritId(u, l, context),
-        T: (l ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (u?.dt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        pe: false,
-        Ge: null,
+ */ function createEffectNode(e, t, n, i, l) {
+    const u = l?.transparent ?? false;
+    // Prod and observe boilerplates — see computed() for why the observe tier
+    // gets its `_name` as a literal slot rather than a write after the fact.
+    // The default label is the node kind (tracked effects relabel their computed
+    // in trackedEffect); the wrappers in signals.ts no longer spread a name into
+    // the options to get it.
+        const o = {
+        id: inheritId(l, u, context),
+        T: (u ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (l?.Pt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ve: false,
+        we: null,
         C: context?.C ?? globalQueue,
-        we: context?.we ?? defaultContext,
-        Ze: 0,
+        xe: context?.xe ?? defaultContext,
+        $e: 0,
         oe: e,
-        be: undefined,
-        Me: 0,
-        rt: undefined,
-        ct: null,
-        ut: null,
-        je: null,
-        Ke: 0,
+        me: undefined,
+        Be: 0,
+        Nt: undefined,
+        Tt: null,
+        fe: null,
+        et: null,
+        tt: 0,
         u: null,
-        _t: null,
-        ke: context,
-        Le: null,
-        ft: null,
-        xe: null,
+        dt: null,
+        qe: context,
+        Ze: null,
+        St: null,
+        Ye: null,
         ie: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
-        Te: clock,
-        Re: NOT_PENDING,
-        Ae: null,
-        It: -1,
-        Ne: false,
-        tt: false,
-        At: undefined,
-        Ot: t,
-        Ct: n,
-        Rt: undefined,
-        ge: i,
+        _e: clock,
+        Ge: NOT_PENDING,
+        ge: null,
+        At: -1,
+        Ae: false,
+        He: false,
+        Ft: undefined,
+        ht: t,
+        vt: n,
+        Ht: undefined,
+        Ce: i,
+        _t: null,
         o: null
     };
     // Effects dispatch status through the SHARED notifier (statusNotifierOf,
@@ -529,7 +615,7 @@ function computed(e, t) {
     // allocation on EVERY effect at creation (an alloc + 19 field stores,
     // +23% effect creation, caught by the creation benches). Only genuinely
     // per-node channels (boundaries) live on _x.
-        if (u?.unobserved) ext(o).Et = u.unobserved;
+        if (l?.unobserved) ext(o).Ct = l.unobserved;
     setupComputedNode(o, lazyOptions);
     return o;
 }
@@ -552,7 +638,7 @@ function setEffectStatusNotify(e) {
  * per-node field did when every effect carried one. */ function statusNotifierOf(e) {
     const t = e.o?.h;
     if (t !== undefined) return t;
-    return e.ge ? effectStatusNotify ?? undefined : undefined;
+    return e.Ce ? effectStatusNotify ?? undefined : undefined;
 }
 
 const lazyOptions = {
@@ -560,24 +646,24 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.ct = e;
-    const n = context?.Gt ? context.Dt : context;
+    e.Tt = e;
+    const n = context?.gt ? context.bt : context;
     if (context) {
-        const t = context.xe;
+        const t = context.Ye;
         if (t === null) {
-            context.xe = e;
+            context.Ye = e;
         } else {
-            e.Le = t;
-            t.ft = e;
-            context.xe = e;
+            e.Ze = t;
+            t.St = e;
+            context.Ye = e;
         }
     }
-    if (n) e.Me = n.Me + 1;
-    if (GlobalQueue.Pt !== null) GlobalQueue.Pt(e);
+    if (n) e.Be = n.Be + 1;
+    if (GlobalQueue.kt !== null) GlobalQueue.kt(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
         if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
-            ext(e).We = e.be === undefined ? NO_SNAPSHOT : e.be;
+            ext(e).ze = e.me === undefined ? NO_SNAPSHOT : e.me;
             e.T |= CONFIG_HAS_SNAPSHOT;
             snapshotSources.add(e);
         }
@@ -585,48 +671,128 @@ function setupComputedNode(e, t) {
 }
 
 function signal(e, t, n = null) {
+    // Prod and observe boilerplates — see computed(). The observe literal adds
+    // `_name` and `_owner` (the creating owner, stamped by registerGraph for
+    // createSignal nodes so ownerPath can locate signal subjects; null here,
+    // and staying null on internal signals — one shape either way).
     const i = {
-        pe: t?.equals ?? isEqual,
+        ve: t?.equals ?? isEqual,
         T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0),
-        be: e,
+        me: e,
         u: null,
-        _t: null,
-        Te: clock,
-        st: n,
-        Se: n?.o?.i || null,
-        Re: NOT_PENDING,
+        dt: null,
+        _e: clock,
+        ce: n,
+        Ee: n?.o?.i || null,
+        Vt: null,
+        Ge: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
         // typed error-retry gating); _fn/_statusFlags read falsy-identically as
         // missing properties on the shared paths (undefined masks to 0).
-        Ae: null,
-        It: -1,
+        ge: null,
+        At: -1,
         o: null
     };
-    if (t?.unobserved) ext(i).Et = t.unobserved;
-    if (n) {
-        ext(n).i = i;
-        n.T |= CONFIG_FW_CHILDREN;
-    }
+    if (t?.unobserved) ext(i).Ct = t.unobserved;
+    if (n) linkFirewallChild(n, i);
     if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
-        ext(i).We = e === undefined ? NO_SNAPSHOT : e;
+        ext(i).ze = e === undefined ? NO_SNAPSHOT : e;
         i.T |= CONFIG_HAS_SNAPSHOT;
         snapshotSources.add(i);
     }
     return i;
 }
 
+// ---------------------------------------------------------------------------
+// SLOT SIGNALS (store leaves) — the create-floor diet. Store mounts
+// materialize one signal per touched leaf (~13 × rows on dbmon), so per-node
+// allocations are mount bytes: the generic path costs an options object, an
+// equals closure, an unobserved closure, a NodeExtension to hold it, and
+// three post-construction expandos (acc/px/pxv → hidden-class transitions).
+// slotSignal bakes everything into ONE literal: `_host`/`_key` backrefs
+// replace the closures (equals is a method call — `this` is the node; the
+// unobserved sweep dispatches CONFIG_SLOT_NODE to one shared hook), and the
+// store's wrap-cache fields are pre-shaped.
+/** The shared slot-node unobserved handler — a live binding read directly by
+ * the sweep sites (no wrapper frame, no null check: a CONFIG_SLOT_NODE node
+ * existing implies the store module loaded and registered the hook). */ let slotUnobservedHook;
+
+/** Install the shared slot-node unobserved handler (store module, once). */ function setSlotUnobserved(e) {
+    slotUnobservedHook = e;
+}
+
+/** Push a new node onto its firewall's child chain (the literal already
+ * points `_nextChild` at the old head). Doubly linked so a released leaf
+ * unlinks in O(1) — the chain is walked per mark of the projection and
+ * would otherwise grow by one node per leaf ever read (#3351). */ function linkFirewallChild(e, t) {
+    const n = t.Ee;
+    if (n !== null) n.Vt = t;
+    ext(e).i = t;
+    e.T |= CONFIG_FW_CHILDREN;
+}
+
+/** Release a firewall child the store no longer addresses (unobserved sweep
+ * dropped it from its target's cache): unlink it from the chain so the
+ * projection stops retaining it and its last value. The node keeps its own
+ * `_nextChild` so a walk that is mid-chain on it still terminates. Nodes in
+ * `_companionChildren` stay there — companions are permanent by contract
+ * and snap through that set, not the chain. */ function unlinkFirewallChild(e) {
+    const t = e;
+    const n = t.ce;
+    if (!n) return;
+    const i = t.Vt;
+    const l = t.Ee;
+    if (i !== null) i.Ee = l; else if (n.o.i === t) n.o.i = l;
+    if (l !== null) l.Vt = i;
+    t.Vt = null;
+}
+
+function slotSignal(e, t, n, i, l, u = null) {
+    // Prod and observe boilerplates — see computed(). The store relabels the
+    // observe slot (`store.<key>`) when the attribution engine is installed.
+    const o = {
+        ve: t,
+        T: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
+        me: e,
+        u: null,
+        dt: null,
+        _e: clock,
+        ce: u,
+        Ee: u?.o?.i || null,
+        Vt: null,
+        Ge: NOT_PENDING,
+        ge: null,
+        At: -1,
+        o: null,
+        // Slot backrefs: what the equals/unobserved closures used to capture.
+        Ut: n,
+        xt: i,
+        // Store read-path caches, pre-shaped (were post-construction expandos).
+        acc: l,
+        px: undefined,
+        pxv: undefined
+    };
+    if (u) linkFirewallChild(u, o);
+    if (snapshotCaptureActive && !((u?.S ?? 0) & STATUS_PENDING)) {
+        ext(o).ze = e === undefined ? NO_SNAPSHOT : e;
+        o.T |= CONFIG_HAS_SNAPSHOT;
+        snapshotSources.add(o);
+    }
+    return o;
+}
+
 function optimisticSignal(e, t) {
     const n = signal(e, t);
-    ext(n).Pe = NOT_PENDING;
+    ext(n).be = NOT_PENDING;
     n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
 
 function optimisticComputed(e, t) {
     const n = computed(e, t);
-    ext(n).Pe = NOT_PENDING;
+    ext(n).be = NOT_PENDING;
     n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
@@ -657,11 +823,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.ht === null && !tracking && true) return e();
+    if (GlobalQueue.Lt === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.ht !== null) return GlobalQueue.ht(e);
+        if (GlobalQueue.Lt !== null) return GlobalQueue.Lt(e);
         return e();
     } finally {
         tracking = n;
@@ -711,35 +877,62 @@ function isEqual(e, t) {
  * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
  * installed at first until() call — apps that never use until() shake it.
  */ function notifyAuthoritativeObservers(e) {
-    for (let t = e.u; t !== null; t = t.ae) {
-        const e = t.ce;
+    for (let t = e.u; t !== null; t = t.Te) {
+        const e = t.Ie;
         if (!(e.T & CONFIG_AUTHORITATIVE_READ)) continue;
         // Missed-wake latch (#3037), same contract as insertSubs: the reader may
         // itself have pulled this recompute (updateIfNecessary from its own
         // read), and the heap refuses RECOMPUTING nodes — latch so recompute's
         // tail reschedules it with the staged value visible.
-                if (e.ie & REACTIVE_RECOMPUTING_DEPS && t.Ft === e.Ke && t !== e.je) e.ie |= REACTIVE_MISSED_WAKE;
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && t.yt === e.tt && t !== e.et) e.ie |= REACTIVE_MISSED_WAKE;
         enqueueSub(e);
     }
     schedule();
 }
 
-/** Installs the until() machinery hook. Idempotent; called by until() before
- * any authoritative-view read happens (same late-binding contract as the
- * optimistic engine). */ function installAuthoritativeRead() {
-    if (GlobalQueue.he === null) GlobalQueue.he = notifyAuthoritativeObservers;
+/** Installs the authoritative-reader wakeup hook. Idempotent; called by every
+ * creator of a CONFIG_AUTHORITATIVE_READ computation — until() and refresh() —
+ * before its first read (same late-binding contract as the optimistic engine;
+ * the gating bit is only ever set by such a read, so the `!` call sites are
+ * safe once every setter installs, #3303). */ function installAuthoritativeRead() {
+    if (GlobalQueue.Qt === null) GlobalQueue.Qt = notifyAuthoritativeObservers;
+}
+
+/**
+ * Stale-reader term of the value selections below: a render effect reading a
+ * node some OTHER live transaction has staged sees the committed value. The
+ * commit is silent — the staging walk was the notification — so a reader
+ * that linked AFTER that walk (an effect created during the hold, a store
+ * key first read under it) would show the old value past the reveal: record
+ * it for the transaction's commit replay (the `_gatedSubs` contract lanes
+ * already use). An effect the transaction itself computed re-derives at its
+ * commit on its own (parked run, or the contested re-derive, #3322) and is
+ * not recorded — replaying it too would publish the frame twice.
+ */ function heldFromStale(e, t) {
+    const n = e.ge;
+    if (n === null || n === activeTransition) return false;
+    const i = currentTransition(n);
+    const l = t._t;
+    if (l == null || currentTransition(l) !== i) i.lt.add(t);
+    return true;
 }
 
 function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.oe || e.st || e.o?.Pe !== undefined || e.o?.We !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.oe || e.ce || e.o?.be !== undefined || e.o?.ze !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.Gt) t = t.Dt;
+    if (t?.gt) t = t.bt;
     if (t && tracking) link(e, t);
     // Children-forbidden readers (createTrackedEffect / onSettled callbacks) get
     // committed visibility: like the effect half of createEffect and event
     // handlers, effect-phase code never observes its own unsettled write — the
     // write lands in the same flush's continuation (#3006).
-        return !t || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Re;
+    // A stale reader (render effect) recomputing with no transaction active is
+    // mainline: a write staged by a live transaction (`_transition` stamped —
+    // ambient staging never is) stays masked until that transaction's reveal,
+    // the same rule the slow path applies (#3322). Without it a zombie
+    // recompute, or a commit-time re-derive of a contested effect, published
+    // another transaction's uncommitted value.
+        return !t || e.Ge === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) ? e.me : e.Ge;
 }
 
 function read(e) {
@@ -747,33 +940,34 @@ function read(e) {
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.gt(e);
+    if (latestReadActive) return GlobalQueue.wt(e);
     let t = context;
-    if (t?.Gt) t = t.Dt;
+    if (t?.gt) t = t.bt;
     const n = e;
-    const i = e.st;
-    const u = i || e;
+    const i = e.ce;
+    const l = i || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.Ht(e, t, u, i);
+        GlobalQueue.Wt(e, t, l, i);
     } else if (typeof n.oe === "function") {
         prepareComputed(e, false);
     }
-    if (!n.oe && u === e && e.o?.Pe === undefined && e.o?.We === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.oe && l === e && e.o?.be === undefined && e.o?.ze === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        // Committed visibility for children-forbidden readers — see readNodeFast.
-                return !t || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Re;
+        // Committed visibility for children-forbidden readers and for stale
+        // readers of a foreign transaction's staged write — see readNodeFast.
+                return !t || e.Ge === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) ? e.me : e.Ge;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (u.oe) {
+        if (l.oe) {
             const n = queueFor(e);
-            if (u.Me >= n.Qe) {
+            if (l.Be >= n.Ke) {
                 markNode(t);
                 markHeap(n);
-                updateIfNecessary(u);
+                updateIfNecessary(l);
             }
             // Fresh-pull readers (awaitable refresh's waiter) recompute a dirty
             // source inline even when the height gate defers to the flush: the
@@ -781,64 +975,69 @@ function read(e) {
             // never read the PRE-re-ask value as settled. Self-guarded: a clean
             // node no-ops and updateIfNecessary refuses disposed nodes (#2983) —
             // a dead target serves its last value, which is already quiescent.
-             else if (t.T & CONFIG_FRESH_READ) updateIfNecessary(u);
-            const i = u.Me;
+             else if (t.T & CONFIG_FRESH_READ) updateIfNecessary(l);
+            const i = l.Be;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.Me && e.ke !== t) {
-                t.Me = i + 1;
+                        if (i >= t.Be && e.qe !== t) {
+                t.Be = i + 1;
             }
         }
     }
-    if (u.S & STATUS_PENDING) {
-        if (t && !(stale && u.Ae && activeTransition !== u.Ae)) {
+    if (l.S & STATUS_PENDING) {
+        // A reader landing on a pending node throws — the reveal that discovered
+        // the flight holds on it (A15: observed async settles as one unit) — with
+        // one carve-out: a stale (render) reader of a node pending in some OTHER
+        // transaction keeps showing the node's committed value, no entanglement
+        // (parallel transactions; the reader is recorded for that transaction's
+        // commit replay, `heldFromStale`). The carve-out is sound only while the
+        // committed value is coherent with the visible frame, i.e. while the
+        // flight's inputs are themselves unpublished: the stamp alone does not
+        // say so (it is pending-node bookkeeping), so it is refused when the
+        // inputs are on screen — committed by a batch that left the flight in
+        // the air (CONFIG_INPUTS_PUBLISHED, #3305) or revealed through a lane
+        // (optimistic / latest, #3334) — and the reader holds instead. An
+        // UNINITIALIZED node has no committed value to show and holds too
+        // (firewall-backed store reads always did; plain memos since the #3043
+        // port): falling through served `undefined` as if settled and stranded
+        // the reader outside both transactions, so it never re-ran.
+        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.T & CONFIG_INPUTS_PUBLISHED) && !(l.T & CONFIG_HAS_LANE && GlobalQueue.Mt(l)) && heldFromStale(l, t))) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
-            // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.Vt(u)) {
+            // active override throws — plus uninitialized sources regardless of
+            // lane (#3276); that check rides laneSuspends so floor bundles don't
+            // pay for it.
+            if (currentOptimisticLane === null || GlobalQueue.qt(l)) {
                 if (!tracking && e !== t) link(e, t);
-                throw u.o?._;
+                throw l.o?._;
             }
-        } else if (t && u.S & STATUS_UNINITIALIZED) {
-            // A stale (render) reader of a node held pending in ANOTHER transition
-            // normally keeps showing the node's committed value instead of
-            // entangling the two transactions — but an uninitialized node has no
-            // committed value to show. Suspend on it (firewall-backed store reads
-            // always took this branch; plain memos now do too): the reader
-            // registers as a reporter of that source, and its pending-node stamp
-            // ties it to the active transaction, so the two transactions merge
-            // when the source settles. Falling through served `undefined` as if
-            // settled and stranded the reader outside both transactions, so it
-            // never re-ran when either landed (#3043 port).
-            if (!tracking && e !== t) link(e, t);
-            throw u.o?._;
-        } else if (!t && u.S & STATUS_UNINITIALIZED) {
-            throw u.o?._;
+        } else if (!t && l.S & STATUS_UNINITIALIZED) {
+            throw l.o?._;
         }
     }
     // `owner` is the computed itself, or the firewall behind a store node —
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (u.oe && u.S & STATUS_ERROR) {
+        if (l.oe && l.S & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && u.Te < clock) {
-            recompute(u);
+        if (tracking && !pendingCheckActive && l._e < clock) {
+            recompute(l);
             return read(e);
-        } else throw u.o?._;
+        } else throw l.o?._;
     }
     if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.o?.We;
+        const n = e.o?.ze;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e.Re !== NOT_PENDING ? e.Re : e.be;
-            if (u !== i) t.ie |= REACTIVE_SNAPSHOT_STALE;
+            const l = e.Ge !== NOT_PENDING ? e.Ge : e.me;
+            if (l !== i) t.ie |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
-    if (e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING) {
+    if (e.o?.be !== undefined && e.o?.be !== NOT_PENDING) {
         // A17: the override IS the value for every reader — except an authoritative
         // reader (until()'s predicate carries CONFIG_AUTHORITATIVE_READ): it must
         // observe independently-arriving truth, and serving it the caller's own
@@ -849,7 +1048,15 @@ function read(e) {
         // authoritative — optimism never lives there); the sticky mark makes the
         // A17-silent "landing equals override" paths notify this node's subs so
         // the reader re-runs when truth arrives.
-        if (!(t && t.T & CONFIG_AUTHORITATIVE_READ)) return unwrapOverride(e.o?.Pe);
+        if (!(t && t.T & CONFIG_AUTHORITATIVE_READ)) {
+            // A18 supersession (#3331): the node's own source answered with a
+            // DIFFERENT value. The optimism is over for the graph — a tracked
+            // reader sees the staged truth — while the override remains the
+            // DISPLAYED value for untracked reads (and for a stale reader of some
+            // other transaction). The selection lives with the engine.
+            if (t && e.T & CONFIG_OVERRIDE_SUPERSEDED) return GlobalQueue.Yt(e);
+            return unwrapOverride(e.o?.be);
+        }
         e.T |= CONFIG_AUTHORITATIVE_OBSERVED;
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
@@ -859,8 +1066,8 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.vt(e, u, t)) {
-        return e.be;
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Zt(e, l, t)) {
+        return e.me;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
     // and for regular signals in stale mode (render effects). Non-stale readers (user
@@ -868,7 +1075,7 @@ function read(e) {
     // (The lane-context clause lives with the engine.) Children-forbidden readers
     // (createTrackedEffect / onSettled callbacks) get committed visibility — see
     // readNodeFast (#3006).
-        const l = !t || currentOptimisticLane !== null && GlobalQueue.bt(e, u, t) || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e.Ae && activeTransition !== e.Ae || 
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.Kt(e, l, t) || e.Ge === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) || 
     // A17 for HELD truth (#3164, see CONFIG_HELD_TRUTH): staged confirming
     // truth — fold-staged onto an armed family, or entangle-stolen by an
     // awaited until() — is masked from ordinary readers until its
@@ -877,11 +1084,11 @@ function read(e) {
     // compose override + staged truth into a state no timeline contains).
     // Authoritative readers (until()'s predicate) and latest() see the
     // staged truth — the tunnel that keeps the hold deadlock-free.
-    e.T & CONFIG_HELD_TRUTH && !latestReadActive && !(t.T & CONFIG_AUTHORITATIVE_READ) ? e.be : e.Re;
+    e.T & CONFIG_HELD_TRUTH && !latestReadActive && !(t.T & CONFIG_AUTHORITATIVE_READ) ? e.me : e.Ge;
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
-        if (pendingCheckActive) GlobalQueue.kt(e, l);
-    if (!t && u === e && typeof n.oe === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.u) {
+        if (pendingCheckActive) GlobalQueue.jt(e, u);
+    if (!t && l === e && typeof n.oe === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.u) {
         // Deferred, not inline (#3078): an inline unobserved() here made untracked
         // reads destructive — dispose on this read, full revival recompute on the
         // next — so consecutive reads could answer differently with no write in
@@ -891,41 +1098,47 @@ function read(e) {
         dormantNodes.add(e);
         schedule();
     }
-    return l;
+    return u;
 }
 
 function setSignal(e, t) {
-    if (e.Ae && activeTransition !== e.Ae) globalQueue.initTransition(e.Ae);
+    if (e.ge && activeTransition !== e.ge) globalQueue.initTransition(e.ge);
     // The optimistic write path lives with the engine: only optimisticSignal /
     // optimisticComputed callers and optimistic store nodes carry an
     // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
     // always-present config instead of a missing-property probe), and every
     // module that installs one installs the engine first.
-        if (e.T & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.xt(e, t);
-    const n = e.Re === NOT_PENDING ? e.be : e.Re;
+        if (e.T & CONFIG_OPTIMISTIC) {
+        if (!projectionWriteActive) return GlobalQueue.Bt(e, t);
+        // An authoritative store landing on an override-covered node: the store
+        // twin of asyncWrite's override branch, decided by the engine (#3331).
+                const n = e.o?.be;
+        if (n !== undefined && n !== NOT_PENDING) return GlobalQueue.zt(e, t);
+    }
+    const n = e.Ge === NOT_PENDING ? e.me : e.Ge;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.pe || !e.pe(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.ve || !e.ve(n, t);
     if (!i) return t;
-    const u = e.Re !== NOT_PENDING;
-    if (!u) queuePendingNode(e);
-    e.Re = t;
+    const l = e.Ge !== NOT_PENDING;
+    if (!l) queuePendingNode(e);
+    e.Ge = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook and
     // sets CONFIG_HAS_COMPANIONS — one masked read replaces two optional-field
     // probes on every write).
-        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Ue !== null && GlobalQueue.Ue(e, t);
+        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.pe !== null && GlobalQueue.pe(e, t);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
-        if (e.oe !== undefined) e.Te = clock;
+        if (e.oe !== undefined) e._e = clock;
     // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
     // were already walked — and where nothing has recomputed or linked since
     // (epoch) — re-stages the value and stops. The walk is idempotent (subs
     // marked, heap entries flag-guarded, effects queued once); lane and reask
     // contexts change what a walk MEANS, so they always walk.
-        if (u && e.It === notifyEpoch && currentOptimisticLane === null && !reaskArmed) return t;
+        if (l && e.At === notifyEpoch && currentOptimisticLane === null && !reaskArmed) return t;
     insertSubs(e);
     schedule();
     return t;
@@ -939,12 +1152,12 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.ie & REACTIVE_MANUAL_WRITE) && e.Re === NOT_PENDING) {
+    if (!(e.ie & REACTIVE_MANUAL_WRITE) && e.Ge === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
     e.ie = e.ie & -4 | REACTIVE_MANUAL_WRITE;
-    e.Ut = clock;
+    e.Jt = clock;
 }
 
 /**
@@ -1014,10 +1227,16 @@ function staleValues(e, t = true) {
             // refresh is a later, explicit re-ask and lifts the mask — otherwise
             // any setStore early in an action silently swallows every refresh()
             // for the rest of the transaction (#3026).
-            if (e.Ut === clock) return;
+            if (e.Jt === clock) return;
             e.ie &= ~REACTIVE_MANUAL_WRITE;
-            // No REASK below: the batch carries a manual value change, so the
-            // recompute is not a quiet re-ask of an unchanged question.
+            // The lift falls through to the re-ask classification below. The held
+            // write's value change already rides the transaction; the refetch it
+            // asks for is the same question with unchanged inputs. Skipping the
+            // mark here classified that refetch as a NEW question, which pends
+            // every leaf (3.1) — an action doing setStore + yield + refresh(store)
+            // lit up every sibling row, and affects() could not narrow it (a mark
+            // only turns pending on). Same-question motion stays silent (3.4);
+            // the written slot and any declared mark carry the pending instead.
                 }
         // A refresh with no value-change dirt already queued is a re-ask of the
         // same question: mark it so the recompute classifies any resulting
@@ -1026,7 +1245,7 @@ function staleValues(e, t = true) {
         // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
         // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
         // change followed by refresh() must not be laundered into a quiet re-ask.
-         else if (!(e.ie & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+                if (!(e.ie & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
             e.ie |= REACTIVE_REASK;
             armReaskClear();
         }
@@ -1036,4 +1255,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, effectStatusNotify, ext, installAuthoritativeRead, isEqual, latestReadActive, markRefresh, markSnapshotScope, notifyAuthoritativeObservers, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, releaseSnapshotScope, runWithOwner, setContextInternal, setEffectStatusNotify, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, statusNotifierOf, suppressComputedRecompute, tracking, untrack };
+export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, effectStatusNotify, ext, installAuthoritativeRead, isEqual, latestReadActive, markRefresh, markSnapshotScope, notifyAuthoritativeObservers, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, releaseSnapshotScope, runWithOwner, setContextInternal, setEffectStatusNotify, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSlotUnobserved, setSnapshotCapture, signal, slotSignal, slotUnobservedHook, snapshotCaptureActive, snapshotSources, stale, staleValues, statusNotifierOf, suppressComputedRecompute, tracking, unlinkFirewallChild, untrack };