@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/observe/core/lanes.js

@@ -1,4 +1,4 @@
-import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, CONFIG_AUTHORITATIVE, CONFIG_CHILDREN_FORBIDDEN, STATUS_PENDING, EFFECT_RENDER, CONFIG_HELD, STATUS_UNINITIALIZED, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_RECOMPUTING_DEPS, REACTIVE_LANE_DIRTY, CONFIG_STAGED, REACTIVE_JOINED, CONFIG_SLOT_NODE, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_INPUTS_PUBLISHED } from "./constants.js";
+import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, REACTIVE_LANE_DIRTY, CONFIG_AUTHORITATIVE, CONFIG_CHILDREN_FORBIDDEN, STATUS_PENDING, EFFECT_RENDER, CONFIG_HELD, STATUS_UNINITIALIZED, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_RECOMPUTING_DEPS, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ, CONFIG_SLOT_NODE, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_INPUTS_PUBLISHED } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
@@ -40,6 +40,8 @@ import { schedule, question, nextQuestion, GlobalQueue, blocked, resolveTx, txOf
 /** Live lanes (parented). Scanned at every seam while non-empty. */
 const lanes = [];
 
+/** A pass left a shown slot the equality gate can no longer see (#3892). */ const LEFT_SHOWN = 1 << 20;
+
 function newLane(e) {
     const n = newTransaction(true, e);
     lanes.push(n);
@@ -49,15 +51,15 @@ function newLane(e) {
 /** A lane node's current value: its guess, or the latest it derived — the
  * staging a shown lane holds for its next reveal, else its slot; the
  * committed value while it has none (its first lane pass in flight). */ function laneValueOf(e) {
-    if (!(e.u & CONFIG_GUESS) && e.Ae !== NOT_PENDING) return e.Ae;
-    const n = e.m.Z;
-    return n !== NOT_PENDING ? n : e.pe;
+    if (!(e.i & CONFIG_GUESS) && e.Oe !== NOT_PENDING) return e.Oe;
+    const n = e.m.B;
+    return n !== NOT_PENDING ? n : e.Ae;
 }
 
 /** What the screen shows for a lane's node: the lane's value once the lane
  * has revealed, the committed truth before. */ function display(e) {
-    const n = e.m.Z;
-    return e.m._t.Tt && n !== NOT_PENDING ? n : e.pe;
+    const n = e.m.B;
+    return e.m._t.Tt && n !== NOT_PENDING ? n : e.Ae;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -72,7 +74,7 @@ function newLane(e) {
  * on (a store setter's draft too, store/optimistic.ts). */ function guessedValueOf(e) {
     const n = pendingGuessOf(e);
     if (n !== NOT_PENDING) return n;
-    return e.u & CONFIG_OVERRIDE ? laneValueOf(e) : e.pe;
+    return e.i & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ae;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -88,7 +90,7 @@ function optimisticWrite(e, n) {
     // the guess's question and entangles its frame (#3347) without notifying.
     const t = guessedValueOf(e);
     if (typeof n === "function") n = n(t);
-    if (e.tn && e.tn(t, n) && !(e.u & CONFIG_GUESS)) return n;
+    if (e.en && e.en(t, n) && !(e.i & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
     schedule();
     return n;
@@ -106,33 +108,33 @@ function optimisticWrite(e, n) {
 /** A guess's own truth is in flight: the node's own refetch — or, a store
  * leaf's, its family's derive (the slot's flight; store/optimistic.ts
  * installs the resolver). A17: the guess stands in for the flight. */ function inFlight(e) {
-    return (e.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
+    return (e.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(e) === true;
 }
 
 function applyGuesses(e) {
     let n = null;
     for (let t = 0; t < pendingGuesses.length; t += 3) {
-        const s = pendingGuesses[t];
+        const u = pendingGuesses[t];
         const l = pendingGuesses[t + 1];
-        let u = true;
-        if (s.u & CONFIG_OVERRIDE) {
+        let s = true;
+        if (u.i & CONFIG_OVERRIDE) {
             // A lane's node already: a guess re-asked, or a derivation guessed
             // over (its staging is void — the guess is the value now). Two
             // suggestions for one slot cannot finish apart (A34 (1)): the frames
             // entangle. The same value re-asked renews the question; nothing to
             // notify.
-            u = !s.tn || !s.tn(laneValueOf(s), l);
-            if (!(s.u & CONFIG_GUESS)) {
-                s.Ae = NOT_PENDING;
-                s.u |= CONFIG_GUESS;
+            s = !u.en || !u.en(laneValueOf(u), l);
+            if (!(u.i & CONFIG_GUESS)) {
+                u.Oe = NOT_PENDING;
+                u.i |= CONFIG_GUESS;
             }
-            s.m.Z = l;
-            const n = txOf(s)._parent;
+            u.m.B = l;
+            const n = txOf(u)._parent;
             if (e !== null && n !== null) merge(e, n);
         } else {
             let t;
-            if (s.u & CONFIG_HELD) t = newLane(txOf(s)); else {
-                if (e === null && inFlight(s)) e = newTransaction(false);
+            if (u.i & CONFIG_HELD) t = newLane(txOf(u)); else {
+                if (e === null && inFlight(u)) e = newTransaction(false);
                 if (e === null) continue;
                 t = n ??= newLane(e);
             }
@@ -142,17 +144,17 @@ function applyGuesses(e) {
             // screen's plus the guess (plan sec. 19) — a derivation reading a held write
             // beside the guess must not show it. Two flights for one input, when
             // the worlds coincide, is the price.)
-                        ext(s).Z = l;
-            s.u |= CONFIG_OVERRIDE | CONFIG_GUESS;
-            list(s, t);
+                        ext(u).B = l;
+            u.i |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(u, t);
         }
-        ext(s).Oe = pendingGuesses[t + 2];
-        if (u) {
+        ext(u)._e = pendingGuesses[t + 2];
+        if (s) {
             // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
             // blocked lane's re-guess does not re-run its render effects as stale
             // readers republishing the committed view (#3460).
-            insertSubs(s);
-            laneDirty(s, txOf(s));
+            insertSubs(u);
+            laneDirty(u, txOf(u));
         }
     }
     pendingGuesses.length = 0;
@@ -173,8 +175,10 @@ function applyGuesses(e) {
         // The pass read a held write before its first lane read (it joined the
         // frame's future as mainline would): lane work sees the screen — the
         // seam re-derives it on the committed world next round (`stagedReaders`,
-        // the park's repair), as it does a lane pass that read a staging.
-                if (n.R & REACTIVE_JOINED) stagedRead(n);
+        // the park's repair), as it does a lane pass that read a staging. Not a
+        // pass whose held reads were all of nodes born held (no staged read,
+        // `stagedRead`): it has no committed world to re-derive on (#3969).
+                if (n.R & REACTIVE_JOINED && n.R & REACTIVE_STAGED_READ) stagedRead(n);
         return;
     }
     if (sameLane(t, e)) return setPassLane(e);
@@ -185,20 +189,20 @@ function applyGuesses(e) {
 }
 
 /** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
-    for (let t = e._parent; t !== null && t.Z; t = t._parent) if (t === n) return true;
+    for (let t = e._parent; t !== null && t.B; t = t._parent) if (t === n) return true;
     return false;
 }
 
 /** One link group (a shared array) for both lanes' groups. */ function linkLanes(e, n) {
     const t = e.un ?? (e.un = [ e ]);
-    const s = n.un;
-    if (s === t) return;
-    if (s === null) {
+    const u = n.un;
+    if (u === t) return;
+    if (u === null) {
         t.push(n);
         n.un = t;
-    } else for (let e = 0; e < s.length; e++) {
-        t.push(s[e]);
-        s[e].un = t;
+    } else for (let e = 0; e < u.length; e++) {
+        t.push(u[e]);
+        u[e].un = t;
     }
 }
 
@@ -208,8 +212,8 @@ function applyGuesses(e) {
  * shows, A17.) */ function linkBlocked(e) {
     const n = e.un;
     if (n !== null) for (let t = 0; t < n.length; t++) {
-        const s = n[t];
-        if (s !== e && (s.tt !== 0 || ownFlights(s) || nestedBlocked(s))) return true;
+        const u = n[t];
+        if (u !== e && (u.tt !== 0 || ownFlights(u) || nestedBlocked(u))) return true;
     }
     return false;
 }
@@ -246,19 +250,24 @@ function unlink(e) {
  * not leave (A30: it never got there). A first pass under a lane is the
  * lane's (ruling A); a guess is written, not derived — it never leaves this
  * way. `errored`: the pass has no answer — or, a lane pass's pending
- * propagation (async.ts `propagateStatus`), the node gone pending. */ function laneStage(e, n, t, s) {
-    if (!(t || s || e.R & REACTIVE_LANE_READ || e.u & CONFIG_GUESS)) {
-        if (e.m !== null) {
-            if (e.m._t?.Z) e.m._t = null;
-            e.m.Z = NOT_PENDING;
+ * propagation (async.ts `propagateStatus`), the node gone pending. */ function laneStage(e, n, t, u) {
+    if (!(t || u || e.R & REACTIVE_LANE_READ || e.i & CONFIG_GUESS)) {
+        const n = e.m;
+        if (n !== null) {
+            const t = n._t;
+            // Cleared before equality, so a return to the committed value notifies
+            // nobody. The seam wakes it unless the frame is still held (#3892).
+                        if (t?.Tt && !blocked(resolveTx(t._parent))) e.R |= LEFT_SHOWN;
+            if (t?.B) n._t = null;
+            n.B = NOT_PENDING;
         }
-        e.u &= -2305;
+        e.i &= -1050881;
         return false;
     }
-    if (!e.i) {
-        if (!(e.u & CONFIG_OVERRIDE)) {
-            e.Ae = NOT_PENDING;
-            e.u = e.u & ~CONFIG_HELD | CONFIG_OVERRIDE;
+    if (!e.u) {
+        if (!(e.i & CONFIG_OVERRIDE)) {
+            e.Oe = NOT_PENDING;
+            e.i = e.i & -1048833 | CONFIG_OVERRIDE;
             ext(e);
         }
         // A written guess whose own pass is the lane's work — its source is a
@@ -267,7 +276,7 @@ function unlink(e) {
         // of the lane from here (its value the lane's, its fate the lane's), no
         // longer a written guess. A pass with no answer (pending, errored)
         // leaves the guess.
-                if (!s) e.u &= ~CONFIG_GUESS;
+                if (!u) e.i &= ~CONFIG_GUESS;
     }
     // A leaf has no lane value to seat it (`recompute`): one left waiting on
     // the lane's flight runs its next pass as the lane's — the landing that
@@ -279,8 +288,8 @@ function unlink(e) {
     // `laneRead` decides — its frame holds). Its pending is the frame's: queued
     // for the commit sweep as mainline's (async.ts). A node born in the lane
     // has nothing on screen: its leaf waits as the lane's.
-     else if (s) {
-        if (s !== true && !(s.G & STATUS_UNINITIALIZED) && (e.u & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?._t?.Z) {
+     else if (u) {
+        if (u !== true && !(u.S & STATUS_UNINITIALIZED) && (e.i & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?._t?.B) {
             queuePendingNode(e);
             return false;
         }
@@ -301,32 +310,58 @@ function unlink(e) {
  * covered (no landing beneath it) — `optimisticReverted`'s "reverted". */ let reverting = false;
 
 function supersede(e, n, t) {
-    const s = txOf(e);
+    const u = txOf(e);
     // Resolved: the parent may have merged into another transaction since the
     // lane opened (two actions guessing one slot entangle, A34 (1)) — the
     // truth is held by the transaction that lands, not the merged-away one.
-        const l = resolveTx(s._parent ?? s);
+        const l = resolveTx(u._parent ?? u);
+    // A store row answered by a new object the store would reconcile into
+    // the guessed one unchanged is an echo, not a correction (#3898): the
+    // server's object never matches the guess by reference.
+        if (t && e.i & CONFIG_SLOT_NODE && GlobalQueue.sn?.(e.m.B, n)) t = false;
     if (t) {
         // Observe: a displayed guess is being replaced by a differing truth — a
         // landing's (superseded), or the value it covered (reverted: the body
         // ended with nothing coming true).
-        if (s.Tt && attrHooks !== null) attrHooks.optimisticReverted(e, e.m.Z, n, reverting ? "reverted" : "superseded");
-        dissolveLane(s, l, e);
+        if (u.Tt && attrHooks !== null) attrHooks.optimisticReverted(e, e.m.B, n, reverting ? "reverted" : "superseded");
+        dissolveLane(u, l, e);
         // What the screen showed stays the screen until the parent lands (A18
         // (c): display and untracked reads keep the override until the commit).
-                if (s.Tt) e.pe = e.m.Z;
-        e.u &= -10241;
-        e.m.Z = NOT_PENDING;
-        e.Ae = n;
+                if (u.Tt) e.Ae = e.m.B;
+        e.i &= -10241;
+        e.m.B = NOT_PENDING;
         holdNode(e, l);
-        joinFuture(l);
         if (e.t !== null) insertSubs(e);
     } else {
-        e.Ae = n;
-        e.u |= CONFIG_HELD;
-        joinFuture(l);
-        for (let n = e.t; n !== null; n = n.l) if (n.o.u & CONFIG_AUTHORITATIVE) enqueueSub(n.o);
+        e.i |= CONFIG_HELD;
+        // A confirmation is silent (A17); only truth readers are told.
+                GlobalQueue.rn?.(u);
     }
+    e.Oe = n;
+    joinFuture(l);
+}
+
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */ function truthRead(e) {
+    return truth(e) ? laneValueOf(e) : e.i & CONFIG_GUESS && e.Oe !== NOT_PENDING ? e.Oe : e.Ae;
+}
+
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */ function truthConfirmed(e) {
+    for (let n = 0; n < e.Je.length; n++) for (let t = e.Je[n].t; t !== null; t = t.o) if (t.l.i & CONFIG_AUTHORITATIVE) enqueueSub(t.l);
+}
+
+/** A lane node's value is the truth when every guess beneath it is
+ * confirmed — its source staged a value equal to the guess — and nothing
+ * beneath it is held in the parent: same inputs, same value. */ function truth(e) {
+    if (e.i & CONFIG_GUESS) return e.Oe !== NOT_PENDING && e.en && e.en(e.m.B, e.Oe);
+    if (e.Oe !== NOT_PENDING) return;
+    if (e.i & CONFIG_OVERRIDE) for (let n = e.G; n; n = n._) if (!truth(n.I)) return;
+    return 1;
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -339,8 +374,8 @@ function supersede(e, n, t) {
  * against what is seen), a truth staged beneath a guess is the parent's to
  * land, and the runs it held (showing the void guess) are dropped: the
  * parent's re-derivation makes the runs that show. */ function dissolveLane(e, n, t) {
-    const s = lanes.indexOf(e);
-    if (s !== -1) lanes.splice(s, 1);
+    const u = lanes.indexOf(e);
+    if (u !== -1) lanes.splice(u, 1);
     unlink(e);
     // Its verdicts end with it (a correction's dissolution reaches here before
     // `endLanes` would): the readers re-derive from the truth's notification.
@@ -349,19 +384,19 @@ function supersede(e, n, t) {
         e.rt = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
-    for (let s = 0; s < e.nn.length; s++) {
-        const l = e.nn[s];
-        const u = l.m;
-        if (l === t || u._t !== e) continue;
-        const r = l.i;
-        const i = l.u & CONFIG_GUESS;
-        const o = u.Z;
+    for (let u = 0; u < e.Je.length; u++) {
+        const l = e.Je[u];
+        const s = l.m;
+        if (l === t || s._t !== e) continue;
+        const r = l.u;
+        const i = l.i & CONFIG_GUESS;
+        const o = s.B;
         // What the screen shows of it (NOT_PENDING: nothing — a lane pass that
         // errored or pends staged no value), and the lane's latest.
-                const f = e.Tt && !r ? o : l.pe;
+                const f = e.Tt && !r ? o : l.Ae;
         const E = laneValueOf(l);
-        u.Z = NOT_PENDING;
-        l.u &= -10241;
+        s.B = NOT_PENDING;
+        l.i &= -10241;
         if (n === null) {
             // The parent landed: a guess lands the truth beneath it or reverts to
             // the one it covered; a derivation's latest commits (its frame with
@@ -370,28 +405,28 @@ function supersede(e, n, t) {
             // beneath it (superseded by a landing held there) or the value it
             // covered (reverted: nothing came true).
             if (i && e.Tt && attrHooks !== null) {
-                const e = l.Ae !== NOT_PENDING ? l.Ae : l.pe;
-                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.Ae !== NOT_PENDING ? "superseded" : "reverted");
+                const e = l.Oe !== NOT_PENDING ? l.Oe : l.Ae;
+                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.Oe !== NOT_PENDING ? "superseded" : "reverted");
             }
             // A derivation the revert re-derives (dirtied by the guess's
             // notification — listed before it), or one still in flight, shows the
             // lane's answer beside inputs that are the truth now: a fresh reader
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
-                        u._t = null;
-            if (!r && !i) l.Ae = E;
+                        s._t = null;
+            if (!r && !i) l.Oe = E;
             commitPendingNode(l);
             if (!r) {
-                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.G & STATUS_PENDING) l.u |= CONFIG_INPUTS_PUBLISHED;
-                if (f !== NOT_PENDING && (!l.tn || !l.tn(f, l.pe))) insertSubs(l);
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.S & STATUS_PENDING) l.i |= CONFIG_INPUTS_PUBLISHED;
+                if (f !== NOT_PENDING && (!l.en || !l.en(f, l.Ae))) insertSubs(l);
             }
         } else if (i) {
             // A guess of a dissolving lane: its truth — a landing held beneath it,
             // else the value it covered — is the parent's to land, and its readers
             // re-derive from it there. What the screen showed stays the screen
             // until then (A18 (c)).
-            if (l.Ae === NOT_PENDING) l.Ae = covered(l);
-            if (e.Tt) l.pe = o;
+            if (l.Oe === NOT_PENDING) l.Oe = covered(l);
+            if (e.Tt) l.Ae = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -402,20 +437,20 @@ function supersede(e, n, t) {
             // flight is asking the void world's question: its landing is nobody's
             // answer — it re-asks from the truth (whose notification may not reach
             // it: an input's truth equal to its committed value is silent).
-            u._t = null;
+            s._t = null;
             if (!r) {
-                if (f !== NOT_PENDING && e.Tt) l.Ae = f;
-                if (l.G & STATUS_PENDING) {
-                    u.De = null;
+                if (f !== NOT_PENDING && e.Tt) l.Oe = f;
+                if (l.S & STATUS_PENDING) {
+                    s.Te = null;
                     enqueueSub(l);
                 }
             }
             if (e.Tt) {
                 commitPendingNode(l);
-                if (!r) l.u |= CONFIG_INPUTS_PUBLISHED;
+                if (!r) l.i |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (u.St !== null || u.ct !== null) GlobalQueue.st(l, false, true);
-                l.u &= -385;
+                if (s.St !== null || s.ct !== null) GlobalQueue.Et(l, false, true);
+                l.i &= -1048961;
             }
         }
     }
@@ -448,59 +483,59 @@ function supersede(e, n, t) {
  * verdict: released if the lane shows, held if it blocks) — and sees the
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
  * member throws like any. */ function laneRead(e, n) {
-    const t = n.u & CONFIG_GUESS;
-    if (e !== null && e.u & CONFIG_AUTHORITATIVE) return t && n.Ae !== NOT_PENDING ? n.Ae : n.pe;
+    const t = n.i & CONFIG_GUESS;
+    if (e !== null && e.i & CONFIG_AUTHORITATIVE) return GlobalQueue.Nn(n);
     if (e === null) return laneValueOf(n);
-    const s = txOf(n);
-    const l = n.G;
-    if (!tracking || e.u & CONFIG_CHILDREN_FORBIDDEN) {
+    const u = txOf(n);
+    const l = n.S;
+    if (!tracking || e.i & CONFIG_CHILDREN_FORBIDDEN) {
         // An untracked read inside lane work derives from the lane like a
         // tracked one, minus the subscription — `untrack` is about
         // dependencies, not about which world a pass derives from (a mapper's
         // row reads under its root, store/map): the pass enters the lane (two
         // lanes read by one pass link, as for tracked reads). Outside lane
         // work, the screen.
-        if (passLane === null || e.u & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(s, e);
+        if (passLane === null || e.i & CONFIG_CHILDREN_FORBIDDEN) return display(n);
+        enterLane(u, e);
         if (!t && l & STATUS_PENDING) return NOT_PENDING;
         return laneValueOf(n);
     }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, s))) {
+    if (e.u === EFFECT_RENDER && (passLane === null || !sameLane(passLane, u))) {
         if (!t) {
             // A flight whose value has never shown: nothing to show — the leaf
             // waits on it, and its own frame holds (A15, #3334), not the lane's
             // parent. The landing lands the frame: its own pass (the flush
             // joined its transaction) reads the answer it waited on — the lane's
             // staging, revealed at this seam.
-            if (l & STATUS_PENDING && n.m.Z === NOT_PENDING) return NOT_PENDING;
-            if (n.Ae !== NOT_PENDING && e.u & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.Ae;
+            if (l & STATUS_PENDING && n.m.B === NOT_PENDING) return NOT_PENDING;
+            if (n.Oe !== NOT_PENDING && e.i & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.Oe;
         }
-        if (s.fn || !t && l & STATUS_PENDING) {
-            if (!t && !s.Tt && l & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (u.fn || !t && l & STATUS_PENDING) {
+            if (!t && !u.Tt && l & STATUS_UNINITIALIZED) throw new NotReadyError(null);
             // Re-derived at the reveal; once per pass (the pass may also be a stale
             // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
                         if (!(e.R & REACTIVE_SCREEN_READ)) {
                 e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
-                s.an.push(e);
+                u.an.push(e);
             }
             return display(n);
         }
     }
-    enterLane(s, e);
+    enterLane(u, e);
     if (!t && l & STATUS_PENDING) return NOT_PENDING;
     return laneValueOf(n);
 }
 
 /** The value a guess covered: the node's committed value — a store slot's
  * asked of the store (a chained link follows the inner store's commits). */ function covered(e) {
-    return e.u & CONFIG_SLOT_NODE && GlobalQueue.Nn !== undefined ? GlobalQueue.Nn(e) : e.pe;
+    return e.i & CONFIG_SLOT_NODE && GlobalQueue.In !== undefined ? GlobalQueue.In(e) : e.Ae;
 }
 
 /** A guess in `l` whose own truth is in flight (its refetch — authoritative:
  * the landing supersedes, not the body's end). */ function guessFlights(e) {
-    for (let n = 0; n < e.nn.length; n++) {
-        const t = e.nn[n];
-        if (t.u & CONFIG_GUESS && t.m._t === e && inFlight(t)) return true;
+    for (let n = 0; n < e.Je.length; n++) {
+        const t = e.Je[n];
+        if (t.i & CONFIG_GUESS && t.m._t === e && inFlight(t)) return true;
     }
     return false;
 }
@@ -521,20 +556,20 @@ function supersede(e, n, t) {
     let e = false;
     const n = lanes.slice();
     for (let t = 0; t < n.length; t++) {
-        const s = n[t];
-        if (lanes.indexOf(s) === -1) continue;
-        const l = resolveTx(s._parent);
-        if (!l.nt || l.tt !== 0 || l.Z || ownFlights(l) || guessFlights(s)) continue;
+        const u = n[t];
+        if (lanes.indexOf(u) === -1) continue;
+        const l = resolveTx(u._parent);
+        if (!l.nt || l.tt !== 0 || l.B || ownFlights(l) || guessFlights(u)) continue;
         e = true;
         // Each guess's truth: the one beneath it (a landing held there), else
         // the one it covered. (A correction dissolves the lane — the others are
         // re-homed with theirs, `dissolveLane`.)
-                for (let e = 0; e < s.nn.length && lanes.indexOf(s) !== -1; e++) {
-            const n = s.nn[e];
-            if (n.u & CONFIG_GUESS && n.m._t === s) {
-                const e = n.Ae !== NOT_PENDING ? n.Ae : covered(n);
-                reverting = n.Ae === NOT_PENDING;
-                supersede(n, e, !n.tn || !n.tn(n.m.Z, e));
+                for (let e = 0; e < u.Je.length && lanes.indexOf(u) !== -1; e++) {
+            const n = u.Je[e];
+            if (n.i & CONFIG_GUESS && n.m._t === u) {
+                const e = n.Oe !== NOT_PENDING ? n.Oe : covered(n);
+                reverting = n.Oe === NOT_PENDING;
+                supersede(n, e, !n.en || !n.en(n.m.B, e));
                 reverting = false;
             }
         }
@@ -552,18 +587,22 @@ function laneSeam(e, n) {
     e.fn = false;
     e.Tt = true;
     reruns(e);
-    for (let n = 0; n < e.nn.length; n++) {
-        const t = e.nn[n];
-        const s = t.m;
-        if (s._t !== e) continue;
-        if (!(t.u & CONFIG_GUESS) && !t.i && t.Ae !== NOT_PENDING) {
-            s.Z = t.Ae;
-            t.Ae = NOT_PENDING;
+    for (let n = 0; n < e.Je.length; n++) {
+        const t = e.Je[n];
+        if (t.R & LEFT_SHOWN) {
+            t.R ^= LEFT_SHOWN;
+            insertSubs(t);
+        }
+        const u = t.m;
+        if (u._t !== e) continue;
+        if (!(t.i & CONFIG_GUESS) && !t.u && t.Oe !== NOT_PENDING) {
+            u.B = t.Oe;
+            t.Oe = NOT_PENDING;
         }
         // The frame this pass built is the screen's now; the one it replaced
         // goes (as `commitPendingNode` retires a committed pass's).
-                if (s.St !== null || s.ct !== null) GlobalQueue.st(t, false, true);
-        t.u &= ~CONFIG_STAGED;
+                if (u.St !== null || u.ct !== null) GlobalQueue.Et(t, false, true);
+        t.i &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
 }
@@ -583,7 +622,7 @@ function laneSeam(e, n) {
  * frame is not complete without it (A15) — landing it would commit the write
  * beside a derivation still showing the old one. A guess whose own flight is
  * up likewise: the question was asked in this frame. */ function lanesBlocked(e) {
-    return e.Z && linkBlocked(e) || nestedBlocked(e);
+    return e.B && linkBlocked(e) || nestedBlocked(e);
 }
 
 /** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
@@ -600,7 +639,7 @@ function laneSeam(e, n) {
  * landing), judged against the guess. On a derivation it is the lane's
  * latest: its staging once the lane has shown (promoted at the next
  * reveal), its slot before; the lane's members re-derive as its work. */ function laneWrite(e, n) {
-    if (e.u & CONFIG_GUESS) {
+    if (e.i & CONFIG_GUESS) {
         // Provenance (A18, #3331; Q-D, plan sec. 39): a write asking an OLDER
         // question than the guess's — another action's landing beneath it —
         // is not its answer: held beneath (the truth for the commit; the
@@ -609,18 +648,18 @@ function laneSeam(e, n) {
         // continuation's — the flight's); unstamped writes and mainline are
         // current.
         if (stale(e, question)) {
-            e.Ae = n;
-            e.u |= CONFIG_HELD;
-            GlobalQueue.In?.(e, n);
+            e.Oe = n;
+            e.i |= CONFIG_HELD;
+            GlobalQueue._n?.(e, n);
             schedule();
             return n;
         }
-        supersede(e, n, !e.tn || !e.tn(e.m.Z, n));
+        supersede(e, n, !e.en || !e.en(e.m.B, n));
     } else {
         const t = txOf(e);
-        if (e.tn && e.tn(laneValueOf(e), n)) return n;
-        if (t.Tt) e.Ae = n; else e.m.Z = n;
-        if (e.re !== undefined) e.Ne = clock;
+        if (e.en && e.en(laneValueOf(e), n)) return n;
+        if (t.Tt) e.Oe = n; else e.m.B = n;
+        if (e.ee !== undefined) e.Ie = clock;
         insertSubs(e);
         laneDirty(e, t);
     }
@@ -642,34 +681,34 @@ function laneSeam(e, n) {
  * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, t) {
     if (t) return true;
     if (stale(e, answered(e))) {
-        e.Ae = n;
-        e.u |= CONFIG_HELD;
+        e.Oe = n;
+        e.i |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.tn || !e.tn(e.m.Z, n));
+    supersede(e, n, !e.en || !e.en(e.m.B, n));
     return true;
 }
 
 /** THE provenance test, for a derivation's pass and a write alike: an
  * answer to question `q` landing on a guess is stale when `q` is older
  * than the guess's own; unstamped (0) and mainline are current. */ function stale(e, n) {
-    return n !== 0 && n < e.m.Oe;
+    return n !== 0 && n < e.m._e;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
  * sources that changed this round (a flight's landing carries the question
  * that started it); 0 when none is stamped. */ function answered(e) {
     let n = 0;
-    for (let t = e._; t !== null; t = t.p) {
+    for (let t = e.G; t !== null; t = t._) {
         const e = t.I;
-        if (e.m !== null && e.m.Oe > n && e.Ne === clock) n = e.m.Oe;
+        if (e.m !== null && e.m._e > n && e.Ie === clock) n = e.m._e;
     }
     return n;
 }
 
 GlobalQueue.Zt = laneRead;
 
-GlobalQueue.M = laneStage;
+GlobalQueue.W = laneStage;
 
 GlobalQueue.ft = laneOutcome;
 
@@ -680,12 +719,12 @@ GlobalQueue.Qt = laneWrite;
  * born at the seam has no work to judge yet (its passes run next round) —
  * it is neither shown nor blocked until it has. */ let judged = 0;
 
-GlobalQueue.cn = e => {
+GlobalQueue.Gn = e => {
     judged = lanes.length;
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
-GlobalQueue._n = e => {
+GlobalQueue.cn = e => {
     // Passes that read a write the parked frame holds as the screen
     // (`stagedReaders`: lane work, a verdict reader before the verdict): they
     // re-derive on the committed world next round (and register as stale
@@ -693,36 +732,43 @@ GlobalQueue._n = e => {
     // lane sees the screen plus its own guesses.
     const n = [];
     if (e !== null) for (let t = 0; t < e.length; t++) {
-        const s = e[t];
-        const l = s.m?._t;
+        const u = e[t];
+        const l = u.m?._t;
         // A verdict reader a later read of the same pass routed into a verdict
         // lane answered for itself: it re-derives at the holder's landing, not
         // now (one run — #3322, #3540). Other verdict-lane work re-derives only
         // if the frame stays parked: a transaction landing at this seam makes
         // what it read the screen (one run).
-                if (s.R & REACTIVE_DISPOSED || l != null && l._parent?.rt === l && (s.u & CONFIG_VERDICT ? !(s.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
-        enqueueSub(s);
-        if (l != null && l.Z && n.indexOf(l) === -1) n.push(l);
+                if (u.R & REACTIVE_DISPOSED || l != null && l._parent?.rt === l && (u.i & CONFIG_VERDICT ? !(u.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+        // A leaked effect re-derives seated in its lane from its first read: it
+        // carries no lane value (`laneStage`), so without this its pass starts
+        // as mainline, joins the parked frame on its first held read and reads
+        // the staging, then re-enters the lane at its guess read and leaks
+        // again — every round (#4014). A computed is already seated by its
+        // override, and a written guess's own pass stays the frame's.
+                if (l != null && l.B && u.u) u.R |= REACTIVE_LANE_DIRTY;
+        enqueueSub(u);
+        if (l != null && l.B && n.indexOf(l) === -1) n.push(l);
     }
     for (let e = Math.min(judged, lanes.length) - 1; e >= 0; e--) laneSeam(lanes[e], n.indexOf(lanes[e]) !== -1);
 };
 
-GlobalQueue.Gn = () => lanes.length !== 0 && laneCorrections();
+GlobalQueue.On = () => lanes.length !== 0 && laneCorrections();
 
-GlobalQueue.On = endLanes;
+GlobalQueue.Tn = endLanes;
 
-GlobalQueue.Je = e => {
+GlobalQueue.Qe = e => {
     const n = [];
     for (let t = 0; t < lanes.length; t++) {
-        const s = lanes[t];
-        if (resolveTx(s._parent) !== e) continue;
-        for (let e = 0; e < s.nn.length; e++) if (s.nn[e].u & CONFIG_GUESS && s.nn[e].m._t === s) n.push(s.nn[e]);
+        const u = lanes[t];
+        if (resolveTx(u._parent) !== e) continue;
+        for (let e = 0; e < u.Je.length; e++) if (u.Je[e].i & CONFIG_GUESS && u.Je[e].m._t === u) n.push(u.Je[e]);
     }
     return n;
 };
 
-GlobalQueue.Tn = lanesBlocked;
+GlobalQueue.dn = lanesBlocked;
 
-GlobalQueue.ne = verdictLane;
+GlobalQueue.$ = verdictLane;
 
-export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, truthConfirmed, truthRead, verdictLane };