@solidjs/signals 2.0.0-rc.15 → 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, 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 { 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
@@ -48,18 +50,10 @@ function newLane(e) {
     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.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.B;
-    return e.m._t.Tt && n !== NOT_PENDING ? n : e.Ae;
+    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, …]`).
@@ -74,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.i & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ae;
+    return e.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ie;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -88,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.en && e.en(t, n) && !(e.i & 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;
@@ -108,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.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(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 u = pendingGuesses[t];
-        const l = pendingGuesses[t + 1];
-        let s = true;
-        if (u.i & 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 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.
-            s = !u.en || !u.en(laneValueOf(u), l);
-            if (!(u.i & CONFIG_GUESS)) {
-                u.Oe = NOT_PENDING;
-                u.i |= 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;
             }
-            u.m.B = l;
-            const n = txOf(u)._parent;
-            if (e !== null && n !== null) merge(e, n);
+            t.T.V = l;
+            r = txOf(t)._parent;
         } else {
-            let t;
-            if (u.i & CONFIG_HELD) t = newLane(txOf(u)); else {
-                if (e === null && inFlight(u)) 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
@@ -144,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(u).B = l;
-            u.i |= CONFIG_OVERRIDE | CONFIG_GUESS;
-            list(u, t);
+                        ext(t).V = l;
+            t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(t, s);
         }
-        ext(u)._e = pendingGuesses[t + 2];
-        if (s) {
+        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(u);
-            laneDirty(u, txOf(u));
+            insertSubs(t);
+            laneDirty(t, txOf(t));
         }
     }
     pendingGuesses.length = 0;
@@ -169,8 +169,8 @@ 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
@@ -181,28 +181,28 @@ function applyGuesses(e) {
                 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.B; 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 u = n.un;
-    if (u === t) return;
-    if (u === null) {
-        t.push(n);
-        n.un = t;
-    } else for (let e = 0; e < u.length; e++) {
-        t.push(u[e]);
-        u[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;
     }
 }
 
@@ -210,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 u = n[t];
-        if (u !== e && (u.tt !== 0 || ownFlights(u) || nestedBlocked(u))) 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
@@ -233,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
@@ -250,24 +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, u) {
-    if (!(t || u || e.R & REACTIVE_LANE_READ || e.i & CONFIG_GUESS)) {
-        const n = e.m;
+ * 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 t = n._t;
+            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 (t?.Tt && !blocked(resolveTx(t._parent))) e.R |= LEFT_SHOWN;
-            if (t?.B) n._t = null;
-            n.B = NOT_PENDING;
+                        if (s?.It && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
+            if (s?.V) n.Je = null;
+            n.V = NOT_PENDING;
         }
-        e.i &= -1050881;
+        e.l &= -1050881;
         return false;
     }
-    if (!e.u) {
-        if (!(e.i & CONFIG_OVERRIDE)) {
-            e.Oe = NOT_PENDING;
-            e.i = e.i & -1048833 | CONFIG_OVERRIDE;
+    if (!e.i) {
+        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
@@ -276,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 (!u) e.i &= ~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
@@ -288,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 (u) {
-        if (u !== true && !(u.S & STATUS_UNINITIALIZED) && (e.i & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?._t?.B) {
+     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;
         }
@@ -309,61 +309,38 @@ 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 u = 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(u._parent ?? u);
+        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 (t && e.i & CONFIG_SLOT_NODE && GlobalQueue.sn?.(e.m.B, n)) t = false;
-    if (t) {
+        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 (u.Tt && attrHooks !== null) attrHooks.optimisticReverted(e, e.m.B, n, reverting ? "reverted" : "superseded");
-        dissolveLane(u, 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 (u.Tt) e.Ae = e.m.B;
-        e.i &= -10241;
-        e.m.B = NOT_PENDING;
+                if (t.It) e.Ie = e.T.V;
+        e.l &= -10241;
+        e.T.V = NOT_PENDING;
         holdNode(e, l);
-        if (e.t !== null) insertSubs(e);
+        if (e.o !== null) insertSubs(e);
     } else {
-        e.i |= CONFIG_HELD;
+        e.l |= CONFIG_HELD;
         // A confirmation is silent (A17); only truth readers are told.
-                GlobalQueue.rn?.(u);
+                GlobalQueue.tn?.(t);
     }
-    e.Oe = n;
+    e.ue = n;
     joinFuture(l);
 }
 
-/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
- * the first one installs these on GlobalQueue (signals.ts `watch`).
- *
- * A truth reader's read of a lane node: the lane's value when it is the
- * truth (#3943), else the truth staged beneath a guess, else the committed
- * value. */ function truthRead(e) {
-    return truth(e) ? laneValueOf(e) : e.i & CONFIG_GUESS && e.Oe !== NOT_PENDING ? e.Oe : e.Ae;
-}
-
-/** A guess confirmed: its lane's truth readers re-read — of the lane's
- * derivations too, which may be the truth now (#3943). */ function truthConfirmed(e) {
-    for (let n = 0; n < e.Je.length; n++) for (let t = e.Je[n].t; t !== null; t = t.o) if (t.l.i & CONFIG_AUTHORITATIVE) enqueueSub(t.l);
-}
-
-/** A lane node's value is the truth when every guess beneath it is
- * confirmed — its source staged a value equal to the guess — and nothing
- * beneath it is held in the parent: same inputs, same value. */ function truth(e) {
-    if (e.i & CONFIG_GUESS) return e.Oe !== NOT_PENDING && e.en && e.en(e.m.B, e.Oe);
-    if (e.Oe !== NOT_PENDING) return;
-    if (e.i & CONFIG_OVERRIDE) for (let n = e.G; n; n = n._) if (!truth(n.I)) return;
-    return 1;
-}
-
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
  * values are the truth now: a guess lands the truth staged beneath it or
  * reverts to the one it covered (`_value`, untouched by the guess); a
@@ -373,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 u = lanes.indexOf(e);
-    if (u !== -1) lanes.splice(u, 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 u = 0; u < e.Je.length; u++) {
-        const l = e.Je[u];
-        const s = l.m;
-        if (l === t || s._t !== e) continue;
-        const r = l.u;
-        const i = l.i & CONFIG_GUESS;
-        const o = s.B;
+    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.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.Ae;
-        const E = laneValueOf(l);
-        s.B = NOT_PENDING;
-        l.i &= -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
@@ -404,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.Oe !== NOT_PENDING ? l.Oe : l.Ae;
-                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.Oe !== 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).
-                        s._t = null;
-            if (!r && !i) l.Oe = 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.S & STATUS_PENDING) l.i |= CONFIG_INPUTS_PUBLISHED;
-                if (f !== NOT_PENDING && (!l.en || !l.en(f, l.Ae))) 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.Oe === NOT_PENDING) l.Oe = covered(l);
-            if (e.Tt) l.Ae = o;
+            if (l.ue === NOT_PENDING) l.ue = covered(l);
+            if (e.It) l.Ie = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -437,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).
-            s._t = null;
+            u.Je = null;
             if (!r) {
-                if (f !== NOT_PENDING && e.Tt) l.Oe = f;
-                if (l.S & STATUS_PENDING) {
-                    s.Te = 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.i |= CONFIG_INPUTS_PUBLISHED;
+                if (!r) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (s.St !== null || s.ct !== null) GlobalQueue.Et(l, false, true);
-                l.i &= -1048961;
+                if (u.Nt !== null || u.ft !== null) GlobalQueue.et(l, false, true);
+                l.l &= -1048961;
             }
         }
     }
@@ -465,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
@@ -483,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.i & CONFIG_GUESS;
-    if (e !== null && e.i & CONFIG_AUTHORITATIVE) return GlobalQueue.Nn(n);
+    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 u = txOf(n);
-    const l = n.S;
-    if (!tracking || e.i & 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.i & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(u, 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.u === EFFECT_RENDER && (passLane === null || !sameLane(passLane, u))) {
-        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.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 (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 (u.fn || !t && l & STATUS_PENDING) {
-            if (!t && !u.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;
-                u.an.push(e);
+                l.En.push(e);
             }
             return display(n);
         }
     }
-    enterLane(u, 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.i & CONFIG_SLOT_NODE && GlobalQueue.In !== undefined ? GlobalQueue.In(e) : e.Ae;
+    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.Je.length; n++) {
-        const t = e.Je[n];
-        if (t.i & 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;
 }
@@ -555,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 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;
+    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 < u.Je.length && lanes.indexOf(u) !== -1; e++) {
-            const n = u.Je[e];
-            if (n.i & CONFIG_GUESS && n.m._t === u) {
-                const e = n.Oe !== NOT_PENDING ? n.Oe : covered(n);
-                reverting = n.Oe === NOT_PENDING;
-                supersede(n, e, !n.en || !n.en(n.m.B, e));
+                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;
             }
         }
@@ -581,28 +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.Je.length; n++) {
-        const t = e.Je[n];
-        if (t.R & LEFT_SHOWN) {
-            t.R ^= LEFT_SHOWN;
-            insertSubs(t);
+    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 u = t.m;
-        if (u._t !== e) continue;
-        if (!(t.i & CONFIG_GUESS) && !t.u && t.Oe !== NOT_PENDING) {
-            u.B = t.Oe;
-            t.Oe = NOT_PENDING;
+        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 (u.St !== null || u.ct !== null) GlobalQueue.Et(t, false, true);
-        t.i &= ~CONFIG_STAGED;
+                if (t.Nt !== null || t.ft !== null) GlobalQueue.et(s, false, true);
+        s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
 }
@@ -610,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);
     }
 }
 
@@ -622,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.B && 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;
 }
@@ -639,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.i & 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
@@ -648,20 +627,20 @@ function laneSeam(e, n) {
         // continuation's — the flight's); unstamped writes and mainline are
         // current.
         if (stale(e, question)) {
-            e.Oe = n;
-            e.i |= CONFIG_HELD;
-            GlobalQueue._n?.(e, n);
+            e.ue = n;
+            e.l |= CONFIG_HELD;
+            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }
-        supersede(e, n, !e.en || !e.en(e.m.B, n));
+        supersede(e, n, !e.Ye || !e.Ye(e.T.V, n));
     } else {
-        const t = txOf(e);
-        if (e.en && e.en(laneValueOf(e), n)) return n;
-        if (t.Tt) e.Oe = n; else e.m.B = n;
-        if (e.ee !== undefined) e.Ie = clock;
+        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;
@@ -678,97 +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.Oe = n;
-        e.i |= CONFIG_HELD;
+        e.ue = n;
+        e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.en || !e.en(e.m.B, 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._e;
+    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.G; t !== null; t = t._) {
-        const e = t.I;
-        if (e.m !== null && e.m._e > n && e.Ie === clock) n = e.m._e;
+    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.W = 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.Gn = e => {
+const applyGuessesAt = e => {
     judged = lanes.length;
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
-GlobalQueue.cn = 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 u = e[t];
-        const l = u.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 (u.R & REACTIVE_DISPOSED || l != null && l._parent?.rt === l && (u.i & CONFIG_VERDICT ? !(u.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+                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.B && u.u) u.R |= REACTIVE_LANE_DIRTY;
-        enqueueSub(u);
-        if (l != null && l.B && n.indexOf(l) === -1) n.push(l);
+                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.On = () => lanes.length !== 0 && laneCorrections();
-
-GlobalQueue.Tn = endLanes;
+installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked);
 
-GlobalQueue.Qe = e => {
+GlobalQueue.Ke = e => {
     const n = [];
-    for (let t = 0; t < lanes.length; t++) {
-        const u = lanes[t];
-        if (resolveTx(u._parent) !== e) continue;
-        for (let e = 0; e < u.Je.length; e++) if (u.Je[e].i & CONFIG_GUESS && u.Je[e].m._t === u) n.push(u.Je[e]);
+    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.dn = lanesBlocked;
-
-GlobalQueue.$ = verdictLane;
+GlobalQueue.J = verdictLane;
 
-export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, truthConfirmed, truthRead, verdictLane };
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };