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

package/dist/prod/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 { tracking, ext, stagedRead } from "./core.js";
 
@@ -38,6 +38,8 @@ import { schedule, question, nextQuestion, GlobalQueue, blocked, txOf, passLane,
 /** 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);
@@ -47,15 +49,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.ke.ve && n !== NOT_PENDING ? n : e.pe;
+    const n = e.m.B;
+    return e.m.He.Ze && n !== NOT_PENDING ? n : e.Ae;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -70,7 +72,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) {
@@ -84,9 +86,9 @@ function optimisticWrite(e, n) {
     // again is no guess (the node's comparator, as for any write) — unless
     // the node already carries one: the user re-asked, and the re-ask renews
     // the guess's question and entangles its frame (#3347) without notifying.
-    const u = guessedValueOf(e);
-    if (typeof n === "function") n = n(u);
-    if (e.We && e.We(u, n) && !(e.u & CONFIG_GUESS)) return n;
+    const t = guessedValueOf(e);
+    if (typeof n === "function") n = n(t);
+    if (e.ye && e.ye(t, n) && !(e.i & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
     schedule();
     return n;
@@ -104,35 +106,35 @@ 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 u = 0; u < pendingGuesses.length; u += 3) {
-        const l = pendingGuesses[u];
-        const t = pendingGuesses[u + 1];
+    for (let t = 0; t < pendingGuesses.length; t += 3) {
+        const u = pendingGuesses[t];
+        const l = pendingGuesses[t + 1];
         let s = true;
-        if (l.u & CONFIG_OVERRIDE) {
+        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.
-            s = !l.We || !l.We(laneValueOf(l), t);
-            if (!(l.u & CONFIG_GUESS)) {
-                l.Ae = NOT_PENDING;
-                l.u |= CONFIG_GUESS;
+            s = !u.ye || !u.ye(laneValueOf(u), l);
+            if (!(u.i & CONFIG_GUESS)) {
+                u.Oe = NOT_PENDING;
+                u.i |= CONFIG_GUESS;
             }
-            l.m.Z = t;
-            const n = txOf(l)._parent;
+            u.m.B = l;
+            const n = txOf(u)._parent;
             if (e !== null && n !== null) merge(e, n);
         } else {
-            let u;
-            if (l.u & CONFIG_HELD) u = newLane(txOf(l)); else {
-                if (e === null && inFlight(l)) e = newTransaction(false);
+            let t;
+            if (u.i & CONFIG_HELD) t = newLane(txOf(u)); else {
+                if (e === null && inFlight(u)) e = newTransaction(false);
                 if (e === null) continue;
-                u = n ??= newLane(e);
+                t = n ??= newLane(e);
             }
             // (A guess equal to a truth staged beneath it is confirmed at birth —
             // A24 — and still re-derives its readers as the lane's: the truth's
@@ -140,17 +142,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(l).Z = t;
-            l.u |= CONFIG_OVERRIDE | CONFIG_GUESS;
-            list(l, u);
+                        ext(u).B = l;
+            u.i |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(u, t);
         }
-        ext(l).Oe = pendingGuesses[u + 2];
+        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(l);
-            laneDirty(l, txOf(l));
+            insertSubs(u);
+            laneDirty(u, txOf(u));
         }
     }
     pendingGuesses.length = 0;
@@ -165,38 +167,40 @@ function applyGuesses(e) {
  * through an ancestor's guess stays its own (the screen plus its own
  * guesses). */ function enterLane(e, n) {
     n.R |= REACTIVE_LANE_READ;
-    const u = passLane;
-    if (u === null) {
+    const t = passLane;
+    if (t === null) {
         setPassLane(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(u, e)) return setPassLane(e);
-    if (under(u, e)) return;
-    if (under(e, u)) return setPassLane(e);
-    linkLanes(u, e);
+    if (sameLane(t, e)) return setPassLane(e);
+    if (under(t, e)) return;
+    if (under(e, t)) return setPassLane(e);
+    linkLanes(t, e);
     setPassLane(e);
 }
 
 /** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
-    for (let u = e._parent; u !== null && u.Z; u = u._parent) if (u === 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 u = e.nn ?? (e.nn = [ e ]);
-    const l = n.nn;
-    if (l === u) return;
-    if (l === null) {
-        u.push(n);
-        n.nn = u;
-    } else for (let e = 0; e < l.length; e++) {
-        u.push(l[e]);
-        l[e].nn = u;
+    const t = e.nn ?? (e.nn = [ e ]);
+    const u = n.nn;
+    if (u === t) return;
+    if (u === null) {
+        t.push(n);
+        n.nn = t;
+    } else for (let e = 0; e < u.length; e++) {
+        t.push(u[e]);
+        u[e].nn = t;
     }
 }
 
@@ -205,9 +209,9 @@ function applyGuesses(e) {
  * blocks `k`'s parent, not `k` — nor, through the link, `l`: the guess
  * shows, A17.) */ function linkBlocked(e) {
     const n = e.nn;
-    if (n !== null) for (let u = 0; u < n.length; u++) {
-        const l = n[u];
-        if (l !== e && (l.tt !== 0 || ownFlights(l) || nestedBlocked(l))) return true;
+    if (n !== null) for (let t = 0; t < n.length; t++) {
+        const u = n[t];
+        if (u !== e && (u.tt !== 0 || ownFlights(u) || nestedBlocked(u))) return true;
     }
     return false;
 }
@@ -215,8 +219,8 @@ function applyGuesses(e) {
 function unlink(e) {
     const n = e.nn;
     if (n === null) return;
-    const u = n.indexOf(e);
-    if (u !== -1) n.splice(u, 1);
+    const t = n.indexOf(e);
+    if (t !== -1) n.splice(t, 1);
     e.nn = null;
 }
 
@@ -227,7 +231,7 @@ function unlink(e) {
  * lane under the holder, shown now, re-derived at the landing, ending with
  * it. Judged at the seam like any lane: blocked while a verdict reader's
  * own derivation is in flight (lane rule 3), shown otherwise. */ function verdictLane(e) {
-    return e.ye ??= newLane(e);
+    return e.xe ??= newLane(e);
 }
 
 /** A lane pass's node (core.ts `recompute`, before its staging; a pending
@@ -244,19 +248,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, u, l) {
-    if (!(u || l || e.R & REACTIVE_LANE_READ || e.u & CONFIG_GUESS)) {
-        if (e.m !== null) {
-            if (e.m.ke?.Z) e.m.ke = 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.He;
+            // 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?.Ze && !blocked(resolveTx(t._parent))) e.R |= LEFT_SHOWN;
+            if (t?.B) n.He = 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
@@ -265,7 +274,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 (!l) 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
@@ -277,8 +286,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 (l) {
-        if (l !== true && !(l.G & STATUS_UNINITIALIZED) && (e.u & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?.ke?.Z) {
+     else if (u) {
+        if (u !== true && !(u.S & STATUS_UNINITIALIZED) && (e.i & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?.He?.B) {
             queuePendingNode(e);
             return false;
         }
@@ -288,29 +297,55 @@ function unlink(e) {
     return true;
 }
 
-function supersede(e, n, u) {
-    const l = txOf(e);
+function supersede(e, n, t) {
+    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 t = resolveTx(l._parent ?? l);
-    if (u) {
-        dissolveLane(l, t, e);
+        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.tn?.(e.m.B, n)) t = false;
+    if (t) {
+        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 (l.ve) e.pe = e.m.Z;
-        e.u &= -10241;
-        e.m.Z = NOT_PENDING;
-        e.Ae = n;
-        holdNode(e, t);
-        joinFuture(t);
+                if (u.Ze) e.Ae = e.m.B;
+        e.i &= -10241;
+        e.m.B = NOT_PENDING;
+        holdNode(e, l);
         if (e.t !== null) insertSubs(e);
     } else {
-        e.Ae = n;
-        e.u |= CONFIG_HELD;
-        joinFuture(t);
-        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.un?.(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.ln.length; n++) for (let t = e.ln[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.ye && e.ye(e.m.B, e.Oe);
+    if (e.Oe !== NOT_PENDING) return;
+    if (e.i & CONFIG_OVERRIDE) for (let n = e.p; n; n = n._) if (!truth(n.I)) return;
+    return 1;
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -322,52 +357,52 @@ function supersede(e, n, u) {
  * the screen (`_value` takes it, so the parent's re-derivation compares
  * 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, u) {
-    const l = lanes.indexOf(e);
-    if (l !== -1) lanes.splice(l, 1);
+ * parent's re-derivation makes the runs that show. */ function dissolveLane(e, n, t) {
+    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.
-        const t = e.ye;
-    if (t !== null) {
-        e.ye = null;
-        if (lanes.indexOf(t) !== -1) dissolveLane(t, null);
+        const l = e.xe;
+    if (l !== null) {
+        e.xe = null;
+        if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
-    for (let l = 0; l < e.un.length; l++) {
-        const t = e.un[l];
-        const s = t.m;
-        if (t === u || s.ke !== e) continue;
-        const i = t.i;
-        const r = t.u & CONFIG_GUESS;
-        const o = s.Z;
+    for (let u = 0; u < e.ln.length; u++) {
+        const l = e.ln[u];
+        const s = l.m;
+        if (l === t || s.He !== 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 E = e.ve && !i ? o : t.pe;
-        const f = laneValueOf(t);
-        s.Z = NOT_PENDING;
-        t.u &= -10241;
+                const E = e.Ze && !r ? o : l.Ae;
+        const f = laneValueOf(l);
+        s.B = NOT_PENDING;
+        l.i &= -10241;
         if (n === null) {
             // 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).
-            s.ke = null;
-            if (!i && !r) t.Ae = f;
-            commitPendingNode(t);
-            if (!i) {
-                if (t.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || t.G & STATUS_PENDING) t.u |= CONFIG_INPUTS_PUBLISHED;
-                if (E !== NOT_PENDING && (!t.We || !t.We(E, t.pe))) insertSubs(t);
+            s.He = null;
+            if (!r && !i) l.Oe = f;
+            commitPendingNode(l);
+            if (!r) {
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.S & STATUS_PENDING) l.i |= CONFIG_INPUTS_PUBLISHED;
+                if (E !== NOT_PENDING && (!l.ye || !l.ye(E, l.Ae))) insertSubs(l);
             }
-        } else if (r) {
+        } 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 (t.Ae === NOT_PENDING) t.Ae = covered(t);
-            if (e.ve) t.pe = o;
-            holdNode(t, n);
-            insertSubs(t);
+            if (l.Oe === NOT_PENDING) l.Oe = covered(l);
+            if (e.Ze) l.Ae = o;
+            holdNode(l, n);
+            insertSubs(l);
         } else {
             // A correction: the lane's derivations are void. Shown, what the
             // screen showed stays the screen (committed, inputs published — every
@@ -376,20 +411,20 @@ function supersede(e, n, u) {
             // 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).
-            s.ke = null;
-            if (!i) {
-                if (E !== NOT_PENDING && e.ve) t.Ae = E;
-                if (t.G & STATUS_PENDING) {
-                    s.De = null;
-                    enqueueSub(t);
+            s.He = null;
+            if (!r) {
+                if (E !== NOT_PENDING && e.Ze) l.Oe = E;
+                if (l.S & STATUS_PENDING) {
+                    s.Te = null;
+                    enqueueSub(l);
                 }
             }
-            if (e.ve) {
-                commitPendingNode(t);
-                if (!i) t.u |= CONFIG_INPUTS_PUBLISHED;
+            if (e.Ze) {
+                commitPendingNode(l);
+                if (!r) l.i |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (s.Me !== null || s.Be !== null) GlobalQueue.he(t, false, true);
-                t.u &= -385;
+                if (s.Qe !== null || s.ve !== null) GlobalQueue.Fe(l, false, true);
+                l.i &= -1048961;
             }
         }
     }
@@ -404,7 +439,7 @@ function supersede(e, n, u) {
     // void: nothing of it reached the screen. So are the runs a blocked lane
     // parked: they show a re-guess the seam never revealed, beside derivations
     // that keep what the screen showed.
-        if (n === null || e.ve && !e.ln) releaseQueues(e); else e.tn[0].length = e.tn[1].length = 0;
+        if (n === null || e.Ze && !e.sn) releaseQueues(e); else e.rn[0].length = e.rn[1].length = 0;
 }
 
 /** Lanes. A lane's node is read by its reader's kind: an authoritative
@@ -422,59 +457,59 @@ function supersede(e, n, u) {
  * 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 u = n.u & CONFIG_GUESS;
-    if (e !== null && e.u & CONFIG_AUTHORITATIVE) return u && n.Ae !== NOT_PENDING ? n.Ae : n.pe;
+    const t = n.i & CONFIG_GUESS;
+    if (e !== null && e.i & CONFIG_AUTHORITATIVE) return GlobalQueue.En(n);
     if (e === null) return laneValueOf(n);
-    const l = txOf(n);
-    const t = 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(l, e);
-        if (!u && t & STATUS_PENDING) return NOT_PENDING;
+        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, l))) {
-        if (!u) {
+    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 (t & 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 (l.ln || !u && t & STATUS_PENDING) {
-            if (!u && !l.ve && t & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (u.sn || !t && l & STATUS_PENDING) {
+            if (!t && !u.Ze && 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;
-                l.sn.push(e);
+                u.fn.push(e);
             }
             return display(n);
         }
     }
-    enterLane(l, e);
-    if (!u && t & STATUS_PENDING) return NOT_PENDING;
+    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.rn !== undefined ? GlobalQueue.rn(e) : e.pe;
+    return e.i & CONFIG_SLOT_NODE && GlobalQueue.Nn !== undefined ? GlobalQueue.Nn(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.un.length; n++) {
-        const u = e.un[n];
-        if (u.u & CONFIG_GUESS && u.m.ke === e && inFlight(u)) return true;
+    for (let n = 0; n < e.ln.length; n++) {
+        const t = e.ln[n];
+        if (t.i & CONFIG_GUESS && t.m.He === e && inFlight(t)) return true;
     }
     return false;
 }
@@ -494,20 +529,20 @@ function supersede(e, n, u) {
  * landing.) True when a lane was judged. */ function laneCorrections() {
     let e = false;
     const n = lanes.slice();
-    for (let u = 0; u < n.length; u++) {
-        const l = n[u];
-        if (lanes.indexOf(l) === -1) continue;
-        const t = resolveTx(l._parent);
-        if (!t.nt || t.tt !== 0 || t.Z || ownFlights(t) || guessFlights(l)) continue;
+    for (let t = 0; t < n.length; t++) {
+        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 < l.un.length && lanes.indexOf(l) !== -1; e++) {
-            const n = l.un[e];
-            if (n.u & CONFIG_GUESS && n.m.ke === l) {
-                const e = n.Ae !== NOT_PENDING ? n.Ae : covered(n);
-                supersede(n, e, !n.We || !n.We(n.m.Z, e));
+                for (let e = 0; e < u.ln.length && lanes.indexOf(u) !== -1; e++) {
+            const n = u.ln[e];
+            if (n.i & CONFIG_GUESS && n.m.He === u) {
+                const e = n.Oe !== NOT_PENDING ? n.Oe : covered(n);
+                supersede(n, e, !n.ye || !n.ye(n.m.B, e));
             }
         }
     }
@@ -518,24 +553,28 @@ function laneSeam(e, n) {
     // Blocked — or one of its passes read a write the frame holds this seam:
     // its runs wait, the pass re-derives on the screen next round.
     if (n || blocked(e)) {
-        e.ln = true;
+        e.sn = true;
         return;
     }
-    e.ln = false;
-    e.ve = true;
+    e.sn = false;
+    e.Ze = true;
     reruns(e);
-    for (let n = 0; n < e.un.length; n++) {
-        const u = e.un[n];
-        const l = u.m;
-        if (l.ke !== e) continue;
-        if (!(u.u & CONFIG_GUESS) && !u.i && u.Ae !== NOT_PENDING) {
-            l.Z = u.Ae;
-            u.Ae = NOT_PENDING;
+    for (let n = 0; n < e.ln.length; n++) {
+        const t = e.ln[n];
+        if (t.R & LEFT_SHOWN) {
+            t.R ^= LEFT_SHOWN;
+            insertSubs(t);
+        }
+        const u = t.m;
+        if (u.He !== 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 (l.Me !== null || l.Be !== null) GlobalQueue.he(u, false, true);
-        u.u &= ~CONFIG_STAGED;
+                if (u.Qe !== null || u.ve !== null) GlobalQueue.Fe(t, false, true);
+        t.i &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
 }
@@ -543,10 +582,10 @@ function laneSeam(e, n) {
 /** The parent landed: its lanes end, nested first. (None is blocked: a
  * blocked lane blocks its parent.) */ function endLanes(e) {
     for (let n = lanes.length - 1; n >= 0; n--) {
-        const u = lanes[n];
-        if (resolveTx(u._parent) !== e) continue;
-        endLanes(u);
-        dissolveLane(u, null);
+        const t = lanes[n];
+        if (resolveTx(t._parent) !== e) continue;
+        endLanes(t);
+        dissolveLane(t, null);
     }
 }
 
@@ -555,14 +594,14 @@ 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) {
     for (let n = 0; n < lanes.length; n++) {
-        const u = lanes[n];
-        if (resolveTx(u._parent) !== e) continue;
-        if (blocked(u) || guessFlights(u)) return true;
+        const t = lanes[n];
+        if (resolveTx(t._parent) !== e) continue;
+        if (blocked(t) || guessFlights(t)) return true;
     }
     return false;
 }
@@ -572,7 +611,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
@@ -581,20 +620,20 @@ 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.En?.(e, n);
+            e.Oe = n;
+            e.i |= CONFIG_HELD;
+            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }
-        supersede(e, n, !e.We || !e.We(e.m.Z, n));
+        supersede(e, n, !e.ye || !e.ye(e.m.B, n));
     } else {
-        const u = txOf(e);
-        if (e.We && e.We(laneValueOf(e), n)) return n;
-        if (u.ve) e.Ae = n; else e.m.Z = n;
-        if (e.re !== undefined) e.Ne = clock;
+        const t = txOf(e);
+        if (e.ye && e.ye(laneValueOf(e), n)) return n;
+        if (t.Ze) e.Oe = n; else e.m.B = n;
+        if (e.ee !== undefined) e.Ie = clock;
         insertSubs(e);
-        laneDirty(e, u);
+        laneDirty(e, t);
     }
     schedule();
     return n;
@@ -611,80 +650,87 @@ function laneSeam(e, n) {
  * It is staged beneath the guess, for the commit like any landing, and
  * nothing moves: no downstream re-ask, no pending flip on the guess's
  * readers (`isPending` of the guess itself says the held truth differs,
- * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, u) {
-    if (u) return true;
+ * 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.We || !e.We(e.m.Z, n));
+    supersede(e, n, !e.ye || !e.ye(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 u = e._; u !== null; u = u.p) {
-        const e = u.I;
-        if (e.m !== null && e.m.Oe > n && e.Ne === clock) n = e.m.Oe;
+    for (let t = e.p; t !== null; t = t._) {
+        const e = t.I;
+        if (e.m !== null && e.m._e > n && e.Ie === clock) n = e.m._e;
     }
     return n;
 }
 
-GlobalQueue.Nt = laneRead;
+GlobalQueue.rt = laneRead;
 
-GlobalQueue.M = laneStage;
+GlobalQueue.W = laneStage;
 
-GlobalQueue.Qe = laneOutcome;
+GlobalQueue.We = laneOutcome;
 
-GlobalQueue.Tt = laneWrite;
+GlobalQueue.Nt = laneWrite;
 
 /** The lanes alive before this seam's guesses opened theirs (a prefix of
  * `lanes`; nothing dissolves one between here and the seam loop): a lane
  * 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.fn = e => {
+GlobalQueue.In = e => {
     judged = lanes.length;
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
-GlobalQueue.Nn = e => {
+GlobalQueue._n = 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
     // readers of the transaction there); a lane's runs wait that round — a
     // lane sees the screen plus its own guesses.
     const n = [];
-    if (e !== null) for (let u = 0; u < e.length; u++) {
-        const l = e[u];
-        const t = l.m?.ke;
+    if (e !== null) for (let t = 0; t < e.length; t++) {
+        const u = e[t];
+        const l = u.m?.He;
         // 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 (l.R & REACTIVE_DISPOSED || t != null && t._parent?.ye === t && (l.u & CONFIG_VERDICT ? !(l.R & REACTIVE_PROBE_UNANSWERED) : !blocked(t._parent))) continue;
-        enqueueSub(l);
-        if (t != null && t.Z && n.indexOf(t) === -1) n.push(t);
+                if (u.R & REACTIVE_DISPOSED || l != null && l._parent?.xe === 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.an = () => lanes.length !== 0 && laneCorrections();
+GlobalQueue.cn = () => lanes.length !== 0 && laneCorrections();
 
-GlobalQueue.In = endLanes;
+GlobalQueue.Gn = endLanes;
 
-GlobalQueue.cn = lanesBlocked;
+GlobalQueue.On = 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 };