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

package/dist/prod/core/lanes.js

@@ -1,12 +1,14 @@
-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 { 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, txOf, passLane, sameLane, flushTransaction, resolveTx, queuePendingNode, list, clock, insertSubs, laneDirty, merge, newTransaction, reruns, releaseQueues, ownFlights, setPassLane, holdNode, joinFuture, commitPendingNode } from "./scheduler.js";
+import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, newTransaction, resolveTx, 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
@@ -38,24 +40,18 @@ 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);
     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.ke.ve && n !== NOT_PENDING ? n : e.pe;
+    const n = e.T.v;
+    return e.T.Re.ke && n !== NOT_PENDING ? n : e.Ie;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -70,7 +66,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) {
@@ -84,9 +80,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 s = guessedValueOf(e);
+    if (typeof n === "function") n = n(s);
+    if (e.xe && e.xe(s, n) && !(e.l & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
     schedule();
     return n;
@@ -104,35 +100,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 u = 0; u < pendingGuesses.length; u += 3) {
-        const l = pendingGuesses[u];
-        const t = pendingGuesses[u + 1];
-        let s = true;
-        if (l.u & CONFIG_OVERRIDE) {
+    for (let s = 0; s < pendingGuesses.length; s += 3) {
+        const t = pendingGuesses[s];
+        const l = pendingGuesses[s + 1];
+        let u = true;
+        // 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 i = 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.
-            s = !l.We || !l.We(laneValueOf(l), t);
-            if (!(l.u & CONFIG_GUESS)) {
-                l.Ae = NOT_PENDING;
-                l.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.xe || !t.xe(laneValueOf(t), l);
+            if (!(t.l & CONFIG_GUESS)) {
+                t.se = NOT_PENDING;
+                t.l |= CONFIG_GUESS;
             }
-            l.m.Z = t;
-            const n = txOf(l)._parent;
-            if (e !== null && n !== null) merge(e, n);
+            t.T.v = l;
+            i = txOf(t)._parent;
         } else {
-            let u;
-            if (l.u & CONFIG_HELD) u = newLane(txOf(l)); else {
-                if (e === null && inFlight(l)) 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(i = txOf(t)); else {
+                if (e === null && inFlight(t)) e = newTransaction(false);
                 if (e === null) continue;
-                u = 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
@@ -140,17 +141,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(l).Z = t;
-            l.u |= CONFIG_OVERRIDE | CONFIG_GUESS;
-            list(l, u);
+                        ext(t).v = l;
+            t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(t, s);
         }
-        ext(l).Oe = pendingGuesses[u + 2];
-        if (s) {
+        if (e !== null && i !== null) merge(e, i);
+        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(l);
-            laneDirty(l, txOf(l));
+            insertSubs(t);
+            laneDirty(t, txOf(t));
         }
     }
     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 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(u, e)) return setPassLane(e);
-    if (under(u, e)) return;
-    if (under(e, u)) return setPassLane(e);
-    linkLanes(u, 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 u = e._parent; u !== null && u.Z; u = u._parent) if (u === 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 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 s = e.en ?? (e.en = [ e ]);
+    const t = n.en;
+    if (t === s) return;
+    if (t === null) {
+        s.push(n);
+        n.en = s;
+    } else for (let e = 0; e < t.length; e++) {
+        s.push(t[e]);
+        t[e].en = s;
     }
 }
 
@@ -204,20 +208,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.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;
+    const n = e.en;
+    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.nn;
+    const n = e.en;
     if (n === null) return;
-    const u = n.indexOf(e);
-    if (u !== -1) n.splice(u, 1);
-    e.nn = null;
+    const s = n.indexOf(e);
+    if (s !== -1) n.splice(s, 1);
+    e.en = null;
 }
 
 /** Verdicts (maintainer, 2026-10-01): `isPending` and `latest` are
@@ -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.he ??= 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, s, t) {
+    if (!(s || t || e.R & REACTIVE_LANE_READ || e.l & CONFIG_GUESS)) {
+        const n = e.T;
+        if (n !== null) {
+            const s = n.Re;
+            // 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?.ke && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
+            if (s?.v) n.Re = 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.se = 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
@@ -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 (!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
@@ -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 (t) {
+        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Re?.v) {
             queuePendingNode(e);
             return false;
         }
@@ -288,29 +297,32 @@ function unlink(e) {
     return true;
 }
 
-function supersede(e, n, u) {
-    const l = 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 t = resolveTx(l._parent ?? l);
-    if (u) {
-        dissolveLane(l, t, e);
+        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.nn?.(e.T.v, n)) s = false;
+    if (s) {
+        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 (l.ve) e.pe = e.m.Z;
-        e.u &= -10241;
-        e.m.Z = NOT_PENDING;
-        e.Ae = n;
-        holdNode(e, t);
-        joinFuture(t);
-        if (e.t !== null) insertSubs(e);
+                if (t.ke) e.Ie = e.T.v;
+        e.l &= -10241;
+        e.T.v = NOT_PENDING;
+        holdNode(e, l);
+        if (e.o !== 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.l |= CONFIG_HELD;
+        // A confirmation is silent (A17); only truth readers are told.
+                GlobalQueue.sn?.(t);
     }
+    e.se = n;
+    joinFuture(l);
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -322,52 +334,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, 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 t = e.ye;
-    if (t !== null) {
-        e.ye = null;
-        if (lanes.indexOf(t) !== -1) dissolveLane(t, null);
+        const l = e.he;
+    if (l !== null) {
+        e.he = 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 t = 0; t < e.tn.length; t++) {
+        const l = e.tn[t];
+        const u = l.T;
+        if (l === s || u.Re !== e) continue;
+        const i = l.i;
+        const r = 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 E = e.ve && !i ? o : t.pe;
-        const f = laneValueOf(t);
-        s.Z = NOT_PENDING;
-        t.u &= -10241;
+                const E = e.ke && !i ? o : l.Ie;
+        const f = laneValueOf(l);
+        u.v = NOT_PENDING;
+        l.l &= -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);
+            u.Re = null;
+            if (!i && !r) l.se = f;
+            commitPendingNode(l);
             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);
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.m & STATUS_PENDING) l.l |= CONFIG_INPUTS_PUBLISHED;
+                if (E !== NOT_PENDING && (!l.xe || !l.xe(E, l.Ie))) insertSubs(l);
             }
         } else if (r) {
             // 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.se === NOT_PENDING) l.se = covered(l);
+            if (e.ke) l.Ie = 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 +388,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;
+            u.Re = null;
             if (!i) {
-                if (E !== NOT_PENDING && e.ve) t.Ae = E;
-                if (t.G & STATUS_PENDING) {
-                    s.De = null;
-                    enqueueSub(t);
+                if (E !== NOT_PENDING && e.ke) l.se = E;
+                if (l.m & STATUS_PENDING) {
+                    u.Se = null;
+                    enqueueSub(l);
                 }
             }
-            if (e.ve) {
-                commitPendingNode(t);
-                if (!i) t.u |= CONFIG_INPUTS_PUBLISHED;
+            if (e.ke) {
+                commitPendingNode(l);
+                if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (s.Me !== null || s.Be !== null) GlobalQueue.he(t, false, true);
-                t.u &= -385;
+                if (u.Ue !== null || u.me !== null) GlobalQueue.Ce(l, false, true);
+                l.l &= -1048961;
             }
         }
     }
@@ -404,7 +416,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.ke && !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
@@ -422,59 +434,61 @@ 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 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 l = txOf(n);
-    const t = n.G;
-    if (!tracking || e.u & CONFIG_CHILDREN_FORBIDDEN) {
+    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);
+        if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
         enterLane(l, e);
-        if (!u && t & STATUS_PENDING) return NOT_PENDING;
+        if (!s && t & STATUS_PENDING) return NOT_PENDING;
         return laneValueOf(n);
     }
     if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, l))) {
-        if (!u) {
+        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 (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 (t & STATUS_PENDING && n.T.v === NOT_PENDING) return NOT_PENDING;
+            if (n.se !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.se;
         }
-        if (l.ln || !u && t & STATUS_PENDING) {
-            if (!u && !l.ve && t & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (l.ln || !s && t & STATUS_PENDING) {
+            if (!s && !l.ke && 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;
-                l.sn.push(e);
+                l.En.push(e);
             }
             return display(n);
         }
     }
     enterLane(l, e);
-    if (!u && t & STATUS_PENDING) return NOT_PENDING;
+    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.rn !== undefined ? GlobalQueue.rn(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.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.tn.length; n++) {
+        const s = e.tn[n];
+        if (s.l & CONFIG_GUESS && s.T.Re === e && inFlight(s)) return true;
     }
     return false;
 }
@@ -494,20 +508,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 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 < 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 < t.tn.length && lanes.indexOf(t) !== -1; e++) {
+            const n = t.tn[e];
+            if (n.l & CONFIG_GUESS && n.T.Re === t) {
+                const e = n.se !== NOT_PENDING ? n.se : covered(n);
+                supersede(n, e, !n.xe || !n.xe(n.T.v, e));
             }
         }
     }
@@ -522,20 +536,24 @@ function laneSeam(e, n) {
         return;
     }
     e.ln = false;
-    e.ve = true;
+    e.ke = 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.tn.length; n++) {
+        const s = e.tn[n];
+        if (s.R & LEFT_SHOWN) {
+            s.R ^= LEFT_SHOWN;
+            insertSubs(s);
+        }
+        const t = s.T;
+        if (t.Re !== e) continue;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.se !== NOT_PENDING) {
+            t.v = s.se;
+            s.se = 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 (t.Ue !== null || t.me !== null) GlobalQueue.Ce(s, false, true);
+        s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
 }
@@ -543,10 +561,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 s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        endLanes(s);
+        dissolveLane(s, null);
     }
 }
 
@@ -555,14 +573,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 u = lanes[n];
-        if (resolveTx(u._parent) !== e) continue;
-        if (blocked(u) || guessFlights(u)) return true;
+        const s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        if (blocked(s) || guessFlights(s)) return true;
     }
     return false;
 }
@@ -572,7 +590,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
@@ -581,20 +599,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.se = n;
+            e.l |= CONFIG_HELD;
+            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }
-        supersede(e, n, !e.We || !e.We(e.m.Z, n));
+        supersede(e, n, !e.xe || !e.xe(e.T.v, 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 s = txOf(e);
+        if (e.xe && e.xe(laneValueOf(e), n)) return n;
+        if (s.ke) e.se = n; else e.T.v = n;
+        if (e.X !== undefined) e.ie = clock;
         insertSubs(e);
-        laneDirty(e, u);
+        laneDirty(e, s);
     }
     schedule();
     return n;
@@ -611,80 +629,75 @@ 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, s) {
+    if (s) return true;
     if (stale(e, answered(e))) {
-        e.Ae = n;
-        e.u |= CONFIG_HELD;
+        e.se = n;
+        e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.We || !e.We(e.m.Z, n));
+    supersede(e, n, !e.xe || !e.xe(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 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 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.Nt = laneRead;
-
-GlobalQueue.M = laneStage;
-
-GlobalQueue.Qe = laneOutcome;
-
-GlobalQueue.Tt = 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 => {
+const applyGuessesAt = e => {
     judged = lanes.length;
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
-GlobalQueue.Nn = 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 u = 0; u < e.length; u++) {
-        const l = e[u];
-        const t = l.m?.ke;
+    if (e !== null) for (let s = 0; s < e.length; s++) {
+        const t = e[s];
+        const l = t.T?.Re;
         // 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 (t.R & REACTIVE_DISPOSED || l != null && l._parent?.he === 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.an = () => lanes.length !== 0 && laneCorrections();
-
-GlobalQueue.In = endLanes;
-
-GlobalQueue.cn = lanesBlocked;
+installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked);
 
-GlobalQueue.ne = verdictLane;
+GlobalQueue.J = verdictLane;
 
 export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };