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

package/dist/observe/core/lanes.js

@@ -1,14 +1,16 @@
-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_HELD, REACTIVE_LANE_READ, STATUS_UNINITIALIZED, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTHORITATIVE, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, STATUS_PENDING, EFFECT_RENDER, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_INPUTS_PUBLISHED, CONFIG_SLOT_NODE, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
-import { tracking, ext, stagedRead } from "./core.js";
+import { ext, tracking, stagedRead } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
+import { laneValueOf } from "./truth.js";
+
 import { enqueueSub } from "./heap.js";
 
-import { schedule, question, nextQuestion, GlobalQueue, blocked, resolveTx, txOf, passLane, sameLane, flushTransaction, queuePendingNode, list, clock, insertSubs, laneDirty, merge, newTransaction, reruns, releaseQueues, ownFlights, setPassLane, holdNode, joinFuture, commitPendingNode } from "./scheduler.js";
+import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, resolveTx, newTransaction, ownFlights, blocked, txOf, clock, insertSubs, laneDirty, queuePendingNode, list, passLane, sameLane, flushTransaction, commitPendingNode, releaseQueues, holdNode, joinFuture, reruns, merge, setPassLane } from "./scheduler.js";
 
 // Lanes (plan sec. 28 replay, 2026-10-02; maintainer rulings 2026-10-01/02). A lane
 // is "a new base of a transition": the sub-frame an optimistic write opens
@@ -40,24 +42,18 @@ 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);
     return n;
 }
 
-/** 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;
-}
-
 /** 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.T.V;
+    return e.T.Je.It && n !== NOT_PENDING ? n : e.Ie;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -72,7 +68,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.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ie;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -86,9 +82,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 t = guessedValueOf(e);
-    if (typeof n === "function") n = n(t);
-    if (e.tn && e.tn(t, n) && !(e.u & CONFIG_GUESS)) return n;
+    const s = guessedValueOf(e);
+    if (typeof n === "function") n = n(s);
+    if (e.Ye && e.Ye(s, n) && !(e.l & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
     schedule();
     return n;
@@ -106,35 +102,40 @@ 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.m & STATUS_PENDING) !== 0 || (e.l & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.k?.(e) === true;
 }
 
 function applyGuesses(e) {
     let n = null;
-    for (let t = 0; t < pendingGuesses.length; t += 3) {
-        const s = pendingGuesses[t];
-        const l = pendingGuesses[t + 1];
+    for (let s = 0; s < pendingGuesses.length; s += 3) {
+        const t = pendingGuesses[s];
+        const l = pendingGuesses[s + 1];
         let u = true;
-        if (s.u & CONFIG_OVERRIDE) {
+        // The frame already holding the slot: a guess over it is a second
+        // suggestion for the slot, and two cannot finish apart (A34 (1)) — the
+        // frames entangle.
+                let r = null;
+        if (t.l & 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;
+            // over (its staging is void — the guess is the value now). The same
+            // value re-asked renews the question; nothing to notify.
+            u = !t.Ye || !t.Ye(laneValueOf(t), l);
+            if (!(t.l & CONFIG_GUESS)) {
+                t.ue = NOT_PENDING;
+                t.l |= CONFIG_GUESS;
             }
-            s.m.Z = l;
-            const n = txOf(s)._parent;
-            if (e !== null && n !== null) merge(e, n);
+            t.T.V = l;
+            r = txOf(t)._parent;
         } else {
-            let t;
-            if (s.u & CONFIG_HELD) t = newLane(txOf(s)); else {
-                if (e === null && inFlight(s)) e = newTransaction(false);
+            let s;
+            // A held node: a truth staged there, or what a corrected guess showed.
+            // The guess composes on it, so it ends with that hold — and with its
+            // own frame's (F-11): it lands only when both have (the board's rapid
+            // adds — a later add's row reverted with an earlier add's landing).
+                        if (t.l & CONFIG_HELD) s = newLane(r = txOf(t)); else {
+                if (e === null && inFlight(t)) e = newTransaction(false);
                 if (e === null) continue;
-                t = n ??= newLane(e);
+                s = 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
@@ -142,17 +143,18 @@ 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(t).V = l;
+            t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(t, s);
         }
-        ext(s).Oe = pendingGuesses[t + 2];
+        if (e !== null && r !== null) merge(e, r);
+        ext(t).Ee = pendingGuesses[s + 2];
         if (u) {
             // 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(t);
+            laneDirty(t, txOf(t));
         }
     }
     pendingGuesses.length = 0;
@@ -167,38 +169,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 t = passLane;
-    if (t === null) {
+    const s = passLane;
+    if (s === 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(t, e)) return setPassLane(e);
-    if (under(t, e)) return;
-    if (under(e, t)) return setPassLane(e);
-    linkLanes(t, e);
+    if (sameLane(s, e)) return setPassLane(e);
+    if (under(s, e)) return;
+    if (under(e, s)) return setPassLane(e);
+    linkLanes(s, e);
     setPassLane(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 s = e._parent; s !== null && s.V; s = s._parent) if (s === 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) {
-        t.push(n);
-        n.un = t;
-    } else for (let e = 0; e < s.length; e++) {
-        t.push(s[e]);
-        s[e].un = t;
+    const s = e.nn ?? (e.nn = [ e ]);
+    const t = n.nn;
+    if (t === s) return;
+    if (t === null) {
+        s.push(n);
+        n.nn = s;
+    } else for (let e = 0; e < t.length; e++) {
+        s.push(t[e]);
+        t[e].nn = s;
     }
 }
 
@@ -206,20 +210,20 @@ function applyGuesses(e) {
  * without the group recursion. (A guess in `k` whose own truth is in flight
  * blocks `k`'s parent, not `k` — nor, through the link, `l`: the guess
  * 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 n = e.nn;
+    if (n !== null) for (let s = 0; s < n.length; s++) {
+        const t = n[s];
+        if (t !== e && (t.tt !== 0 || ownFlights(t) || nestedBlocked(t))) return true;
     }
     return false;
 }
 
 function unlink(e) {
-    const n = e.un;
+    const n = e.nn;
     if (n === null) return;
-    const t = n.indexOf(e);
-    if (t !== -1) n.splice(t, 1);
-    e.un = null;
+    const s = n.indexOf(e);
+    if (s !== -1) n.splice(s, 1);
+    e.nn = null;
 }
 
 /** Verdicts (maintainer, 2026-10-01): `isPending` and `latest` are
@@ -229,7 +233,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.rt ??= newLane(e);
+    return e.it ??= newLane(e);
 }
 
 /** A lane pass's node (core.ts `recompute`, before its staging; a pending
@@ -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, s, t) {
+    if (!(s || t || e.R & REACTIVE_LANE_READ || e.l & CONFIG_GUESS)) {
+        const n = e.T;
+        if (n !== null) {
+            const s = n.Je;
+            // Cleared before equality, so a return to the committed value notifies
+            // nobody. The seam wakes it unless the frame is still held (#3892).
+                        if (s?.It && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
+            if (s?.V) n.Je = null;
+            n.V = NOT_PENDING;
         }
-        e.u &= -2305;
+        e.l &= -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.l & CONFIG_OVERRIDE)) {
+            e.ue = NOT_PENDING;
+            e.l = e.l & -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 (!t) e.l &= ~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 (t) {
+        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Je?.V) {
             queuePendingNode(e);
             return false;
         }
@@ -300,33 +309,36 @@ function unlink(e) {
 /** Observe: the correction round is replacing a guess with the value it
  * covered (no landing beneath it) — `optimisticReverted`'s "reverted". */ let reverting = false;
 
-function supersede(e, n, t) {
-    const s = txOf(e);
+function supersede(e, n, s) {
+    const t = 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);
-    if (t) {
+        const l = resolveTx(t._parent ?? t);
+    // 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 (s && e.l & CONFIG_SLOT_NODE && GlobalQueue.sn?.(e.T.V, n)) s = false;
+    if (s) {
         // 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 (t.It && attrHooks !== null) attrHooks.optimisticReverted(e, e.T.V, n, reverting ? "reverted" : "superseded");
+        dissolveLane(t, 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 (t.It) e.Ie = e.T.V;
+        e.l &= -10241;
+        e.T.V = NOT_PENDING;
         holdNode(e, l);
-        joinFuture(l);
-        if (e.t !== null) insertSubs(e);
+        if (e.o !== 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.l |= CONFIG_HELD;
+        // A confirmation is silent (A17); only truth readers are told.
+                GlobalQueue.tn?.(t);
     }
+    e.ue = n;
+    joinFuture(l);
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -338,30 +350,30 @@ function supersede(e, n, t) {
  * 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, t) {
-    const s = lanes.indexOf(e);
-    if (s !== -1) lanes.splice(s, 1);
+ * parent's re-derivation makes the runs that show. */ function dissolveLane(e, n, s) {
+    const t = lanes.indexOf(e);
+    if (t !== -1) lanes.splice(t, 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 l = e.rt;
+        const l = e.it;
     if (l !== null) {
-        e.rt = null;
+        e.it = 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;
+    for (let t = 0; t < e.je.length; t++) {
+        const l = e.je[t];
+        const u = l.T;
+        if (l === s || u.Je !== e) continue;
         const r = l.i;
-        const i = l.u & CONFIG_GUESS;
-        const o = u.Z;
+        const i = l.l & CONFIG_GUESS;
+        const o = u.V;
         // 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 E = laneValueOf(l);
-        u.Z = NOT_PENDING;
-        l.u &= -10241;
+                const E = e.It && !r ? o : l.Ie;
+        const f = laneValueOf(l);
+        u.V = NOT_PENDING;
+        l.l &= -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
@@ -369,29 +381,29 @@ function supersede(e, n, t) {
             // displayed guess that lifts to something else — the truth staged
             // 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");
+            if (i && e.It && attrHooks !== null) {
+                const e = l.ue !== NOT_PENDING ? l.ue : l.Ie;
+                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.ue !== 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;
+                        u.Je = null;
+            if (!r && !i) l.ue = f;
             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.m & STATUS_PENDING) l.l |= CONFIG_INPUTS_PUBLISHED;
+                if (E !== NOT_PENDING && (!l.Ye || !l.Ye(E, l.Ie))) 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.ue === NOT_PENDING) l.ue = covered(l);
+            if (e.It) l.Ie = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -402,20 +414,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;
+            u.Je = null;
             if (!r) {
-                if (f !== NOT_PENDING && e.Tt) l.Ae = f;
-                if (l.G & STATUS_PENDING) {
-                    u.De = null;
+                if (E !== NOT_PENDING && e.It) l.ue = E;
+                if (l.m & STATUS_PENDING) {
+                    u.Se = null;
                     enqueueSub(l);
                 }
             }
-            if (e.Tt) {
+            if (e.It) {
                 commitPendingNode(l);
-                if (!r) l.u |= CONFIG_INPUTS_PUBLISHED;
+                if (!r) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (u.St !== null || u.ct !== null) GlobalQueue.st(l, false, true);
-                l.u &= -385;
+                if (u.Nt !== null || u.ft !== null) GlobalQueue.et(l, false, true);
+                l.l &= -1048961;
             }
         }
     }
@@ -430,7 +442,7 @@ function supersede(e, n, t) {
     // 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.Tt && !e.fn) releaseQueues(e); else e.En[0].length = e.En[1].length = 0;
+        if (n === null || e.It && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
 }
 
 /** Lanes. A lane's node is read by its reader's kind: an authoritative
@@ -448,59 +460,61 @@ 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 s = n.l & CONFIG_GUESS;
+    if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.rn(n);
+    const t = n.m;
+    // An errored member's lane value predates its error; the error is the answer (#4106).
+        if (!s && t & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
-    const s = txOf(n);
-    const l = n.G;
-    if (!tracking || e.u & CONFIG_CHILDREN_FORBIDDEN) {
+    const l = txOf(n);
+    if (!tracking || e.l & 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 (!t && l & STATUS_PENDING) return NOT_PENDING;
+        if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
+        enterLane(l, e);
+        if (!s && t & STATUS_PENDING) return NOT_PENDING;
         return laneValueOf(n);
     }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, s))) {
-        if (!t) {
+    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, l))) {
+        if (!s) {
             // 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 (t & STATUS_PENDING && n.T.V === NOT_PENDING) return NOT_PENDING;
+            if (n.ue !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ue;
         }
-        if (s.fn || !t && l & STATUS_PENDING) {
-            if (!t && !s.Tt && l & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (l.ln || !s && t & STATUS_PENDING) {
+            if (!s && !l.It && t & 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);
+                l.En.push(e);
             }
             return display(n);
         }
     }
-    enterLane(s, e);
-    if (!t && l & STATUS_PENDING) return NOT_PENDING;
+    enterLane(l, e);
+    if (!s && t & 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.l & CONFIG_SLOT_NODE && GlobalQueue.fn !== undefined ? GlobalQueue.fn(e) : e.Ie;
 }
 
 /** 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 s = e.je[n];
+        if (s.l & CONFIG_GUESS && s.T.Je === e && inFlight(s)) return true;
     }
     return false;
 }
@@ -520,21 +534,21 @@ function supersede(e, n, t) {
  * landing.) True when a lane was judged. */ function laneCorrections() {
     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;
+    for (let s = 0; s < n.length; s++) {
+        const t = n[s];
+        if (lanes.indexOf(t) === -1) continue;
+        const l = resolveTx(t._parent);
+        if (!l.nt || l.tt !== 0 || l.V || ownFlights(l) || guessFlights(t)) 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 < t.je.length && lanes.indexOf(t) !== -1; e++) {
+            const n = t.je[e];
+            if (n.l & CONFIG_GUESS && n.T.Je === t) {
+                const e = n.ue !== NOT_PENDING ? n.ue : covered(n);
+                reverting = n.ue === NOT_PENDING;
+                supersede(n, e, !n.Ye || !n.Ye(n.T.V, e));
                 reverting = false;
             }
         }
@@ -546,24 +560,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.fn = true;
+        e.ln = true;
         return;
     }
-    e.fn = false;
-    e.Tt = true;
+    e.ln = false;
+    e.It = 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 s = e.je[n];
+        if (s.R & LEFT_SHOWN) {
+            s.R ^= LEFT_SHOWN;
+            insertSubs(s);
+        }
+        const t = s.T;
+        if (t.Je !== e) continue;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
+            t.V = s.ue;
+            s.ue = 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 (t.Nt !== null || t.ft !== null) GlobalQueue.et(s, false, true);
+        s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
 }
@@ -571,10 +589,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 t = lanes[n];
-        if (resolveTx(t._parent) !== e) continue;
-        endLanes(t);
-        dissolveLane(t, null);
+        const s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        endLanes(s);
+        dissolveLane(s, null);
     }
 }
 
@@ -583,14 +601,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.V && 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 t = lanes[n];
-        if (resolveTx(t._parent) !== e) continue;
-        if (blocked(t) || guessFlights(t)) return true;
+        const s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        if (blocked(s) || guessFlights(s)) return true;
     }
     return false;
 }
@@ -600,7 +618,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.l & 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,20 +627,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.In?.(e, n);
+            e.ue = n;
+            e.l |= CONFIG_HELD;
+            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }
-        supersede(e, n, !e.tn || !e.tn(e.m.Z, n));
+        supersede(e, n, !e.Ye || !e.Ye(e.T.V, 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;
+        const s = txOf(e);
+        if (e.Ye && e.Ye(laneValueOf(e), n)) return n;
+        if (s.It) e.ue = n; else e.T.V = n;
+        if (e.X !== undefined) e.ie = clock;
         insertSubs(e);
-        laneDirty(e, t);
+        laneDirty(e, s);
     }
     schedule();
     return n;
@@ -639,90 +657,85 @@ 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, t) {
-    if (t) return true;
+ * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, s) {
+    if (s) return true;
     if (stale(e, answered(e))) {
-        e.Ae = n;
-        e.u |= CONFIG_HELD;
+        e.ue = n;
+        e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.tn || !e.tn(e.m.Z, n));
+    supersede(e, n, !e.Ye || !e.Ye(e.T.V, 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.T.Ee;
 }
 
 /** 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) {
-        const e = t.I;
-        if (e.m !== null && e.m.Oe > n && e.Ne === clock) n = e.m.Oe;
+    for (let s = e.C; s !== null; s = s.G) {
+        const e = s.S;
+        if (e.T !== null && e.T.Ee > n && e.ie === clock) n = e.T.Ee;
     }
     return n;
 }
 
-GlobalQueue.Zt = laneRead;
-
-GlobalQueue.M = laneStage;
-
-GlobalQueue.ft = laneOutcome;
-
-GlobalQueue.Qt = 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.cn = e => {
+const applyGuessesAt = e => {
     judged = lanes.length;
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
-GlobalQueue._n = e => {
+const laneSeams = 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 t = 0; t < e.length; t++) {
-        const s = e[t];
-        const l = s.m?._t;
+    if (e !== null) for (let s = 0; s < e.length; s++) {
+        const t = e[s];
+        const l = t.T?.Je;
         // 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 (t.R & REACTIVE_DISPOSED || l != null && l._parent?.it === l && (t.l & CONFIG_VERDICT ? !(t.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.V && t.i) t.R |= REACTIVE_LANE_DIRTY;
+        enqueueSub(t);
+        if (l != null && l.V && 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 = endLanes;
+installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked);
 
-GlobalQueue.Je = e => {
+GlobalQueue.Ke = 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]);
+    for (let s = 0; s < lanes.length; s++) {
+        const t = lanes[s];
+        if (resolveTx(t._parent) !== e) continue;
+        for (let e = 0; e < t.je.length; e++) if (t.je[e].l & CONFIG_GUESS && t.je[e].T.Je === t) n.push(t.je[e]);
     }
     return n;
 };
 
-GlobalQueue.Tn = lanesBlocked;
-
-GlobalQueue.ne = verdictLane;
+GlobalQueue.J = verdictLane;
 
 export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };