@solidjs/signals 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/prod/core/effect.js

@@ -22,12 +22,12 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
     // staged); the flush's commit replays this effect. Its first run is not this
     // creation's (A29). A lane's node likewise: its run is the lane's, queued
     // by the pass and released at the reveal (lanes.ts).
-        !u?.defer && f.ue === NOT_PENDING && !f.T?.Re?.v && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : runEffect(f, f.i));
+        !u?.defer && f.ie === NOT_PENDING && !f.T?.Re?.P && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : runEffect(f, f.i));
 }
 
 function notifyEffectStatus() {
     const t = this.m;
-    const e = this.T?.F;
+    const e = this.T?.U;
     if (t & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
@@ -81,8 +81,8 @@ function runEffect(t, e) {
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
         if (t.m & STATUS_ERROR && t.i === EFFECT_USER) {
-        const e = unwrapStatusError(t.T?.F);
-        t.ge = t.Ie;
+        const e = unwrapStatusError(t.T?.U);
+        t.ke = t.le;
         t.Ae = false;
         try {
             t.qe ? t.qe(e, () => {
@@ -97,21 +97,21 @@ function runEffect(t, e) {
     }
     // Captured before the callback: its own throw errors the node below, but
     // the compute pass that produced `_value` was clean, so its tail still goes.
-        const E = t.T?.F == null;
+        const E = t.T?.U == null;
     const u = t.Je;
     t.Je = undefined;
     try {
         u?.();
-        const e = t.Ke(t.Ie, t.ge);
+        const e = t.Ke(t.le, t.ke);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.Je = e;
     } catch (e) {
-        ext(t).F = new StatusError(t, e);
+        ext(t).U = new StatusError(t, e);
         t.m |= STATUS_ERROR;
         escalate(t, e);
     } finally {
-        t.ge = t.Ie;
+        t.ke = t.le;
         t.Ae = false;
         // The run applied: this is the frame now, so the dependency tail the
         // compute pass left linked goes (A30, #3438 — `recompute` defers an
@@ -157,7 +157,7 @@ GlobalQueue.K = runEffect;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.
-        E.M = run;
+        E.Z = run;
     // The first run rides the heap like every wake (GlobalQueue._update), so a
     // tracked effect created inside a render-effect callback runs after that
     // pass's staged writes commit, not before.

package/dist/prod/core/graph.js

@@ -133,7 +133,7 @@ function link(e, n) {
     if (s) {
         o = l !== null ? l.G : n.C;
         if (o !== null && o.S === e) {
-            o.Te = n.Ne;
+            o.de = n.Ne;
             n._ = o;
             return;
         }
@@ -144,14 +144,14 @@ function link(e, n) {
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
         const r = e.ve;
-    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    if (r !== null && r.u === n && (!s || r.de === n.Ne)) return;
     const t = n._ = e.ve = {
         S: e,
         u: n,
         G: o,
         Xe: r,
         t: null,
-        Te: n.Ne
+        de: n.Ne
     };
     if (l !== null) l.G = t; else n.C = t;
     if (r !== null) r.t = t; else e.o = t;

package/dist/prod/core/heap.js

@@ -11,14 +11,14 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.Ge > e.Fe) dirtyQueue.Ge = e.Fe;
+    if (dirtyQueue.Fe > e.he) dirtyQueue.Fe = e.he;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Qe ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
-    if (E >= e.Fe) e.Fe = E + 1;
-    const n = e.Fe;
+    const E = (e._parent?.Qe ? e._parent.Ye?.he : e._parent?.he) ?? -1;
+    if (E >= e.he) e.he = E + 1;
+    const n = e.he;
     const I = t.$e[n];
     if (I === undefined) t.$e[n] = e; else {
         const t = I.We;
@@ -65,7 +65,7 @@ function deleteFromHeap(e, t) {
     const E = e.R;
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
-    const n = e.Fe;
+    const n = e.he;
     if (e.We === e) t.$e[n] = undefined; else {
         const E = e.be;
         const I = t.$e[n];
@@ -98,11 +98,11 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.p = false;
-    for (e.Ge = 0; e.Ge <= e.et; e.Ge++) {
-        let E = e.$e[e.Ge];
+    for (e.Fe = 0; e.Fe <= e.et; e.Fe++) {
+        let E = e.$e[e.Fe];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.$e[e.Ge];
+            E = e.$e[e.Fe];
         }
     }
     e.et = 0;
@@ -110,13 +110,13 @@ function runHeap(e, t) {
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.Fe;
+    let E = e.he;
     for (let t = e.C; t; t = t.G) {
         const e = t.S;
-        if (e.X && e.Fe >= E) E = e.Fe + 1;
+        if (e.X && e.he >= E) E = e.he + 1;
     }
-    if (e.Fe !== E) {
-        e.Fe = E;
+    if (e.he !== E) {
+        e.he = E;
         for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }

package/dist/prod/core/lanes.js

@@ -1,4 +1,4 @@
-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 { 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, EFFECT_RENDER, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, STATUS_PENDING, CONFIG_INPUTS_PUBLISHED, CONFIG_SLOT_NODE, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ } from "./constants.js";
 
 import { ext, tracking, stagedRead } from "./core.js";
 
@@ -8,7 +8,7 @@ import { laneValueOf } from "./truth.js";
 
 import { enqueueSub } from "./heap.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";
+import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, newTransaction, resolveTx, ownFlights, blocked, txOf, clock, insertSubs, laneDirty, queuePendingNode, list, passLane, setPassLane, sameLane, flushTransaction, commitPendingNode, releaseQueues, holdNode, joinFuture, reruns, merge } 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
@@ -50,8 +50,8 @@ function newLane(e) {
 
 /** 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.T.v;
-    return e.T.Re.ke && n !== NOT_PENDING ? n : e.Ie;
+    const n = e.T.P;
+    return e.T.Re.ge && n !== NOT_PENDING ? n : e.le;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -66,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.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ie;
+    return e.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.le;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -119,10 +119,10 @@ function applyGuesses(e) {
             // value re-asked renews the question; nothing to notify.
             u = !t.xe || !t.xe(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.ue = NOT_PENDING;
+                t.ie = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
-            t.T.v = l;
+            t.T.P = l;
             i = txOf(t)._parent;
         } else {
             let s;
@@ -141,12 +141,12 @@ 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(t).v = l;
+                        ext(t).P = l;
             t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
             list(t, s);
         }
         if (e !== null && i !== null) merge(e, i);
-        ext(t).Ee = pendingGuesses[s + 2];
+        ext(t).Te = 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
@@ -187,7 +187,7 @@ function applyGuesses(e) {
 }
 
 /** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
-    for (let s = e._parent; s !== null && s.v; s = s._parent) if (s === n) return true;
+    for (let s = e._parent; s !== null && s.P; s = s._parent) if (s === n) return true;
     return false;
 }
 
@@ -231,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.he ??= newLane(e);
+    return e.Pe ??= newLane(e);
 }
 
 /** A lane pass's node (core.ts `recompute`, before its staging; a pending
@@ -255,16 +255,16 @@ function unlink(e) {
             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;
+                        if (s?.ge && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
+            if (s?.P) n.Re = null;
+            n.P = NOT_PENDING;
         }
         e.l &= -1050881;
         return false;
     }
     if (!e.i) {
         if (!(e.l & CONFIG_OVERRIDE)) {
-            e.ue = NOT_PENDING;
+            e.ie = NOT_PENDING;
             e.l = e.l & -1048833 | CONFIG_OVERRIDE;
             ext(e);
         }
@@ -287,7 +287,7 @@ function unlink(e) {
     // 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 (t) {
-        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Re?.v) {
+        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Re?.P) {
             queuePendingNode(e);
             return false;
         }
@@ -306,14 +306,14 @@ function supersede(e, n, s) {
     // 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 && e.l & CONFIG_SLOT_NODE && GlobalQueue.nn?.(e.T.P, 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 (t.ke) e.Ie = e.T.v;
+                if (t.ge) e.le = e.T.P;
         e.l &= -10241;
-        e.T.v = NOT_PENDING;
+        e.T.P = NOT_PENDING;
         holdNode(e, l);
         if (e.o !== null) insertSubs(e);
     } else {
@@ -321,7 +321,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.sn?.(t);
     }
-    e.ue = n;
+    e.ie = n;
     joinFuture(l);
 }
 
@@ -340,9 +340,9 @@ function supersede(e, n, s) {
     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.he;
+        const l = e.Pe;
     if (l !== null) {
-        e.he = null;
+        e.Pe = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
     for (let t = 0; t < e.tn.length; t++) {
@@ -351,12 +351,12 @@ function supersede(e, n, s) {
         if (l === s || u.Re !== e) continue;
         const i = l.i;
         const r = l.l & CONFIG_GUESS;
-        const o = u.v;
+        const o = u.P;
         // 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.ke && !i ? o : l.Ie;
+                const E = e.ge && !i ? o : l.le;
         const f = laneValueOf(l);
-        u.v = NOT_PENDING;
+        u.P = NOT_PENDING;
         l.l &= -10241;
         if (n === null) {
             // A derivation the revert re-derives (dirtied by the guess's
@@ -365,19 +365,19 @@ function supersede(e, n, s) {
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
             u.Re = null;
-            if (!i && !r) l.ue = f;
+            if (!i && !r) l.ie = f;
             commitPendingNode(l);
             if (!i) {
                 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);
+                if (E !== NOT_PENDING && (!l.xe || !l.xe(E, l.le))) 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 (l.ue === NOT_PENDING) l.ue = covered(l);
-            if (e.ke) l.Ie = o;
+            if (l.ie === NOT_PENDING) l.ie = covered(l);
+            if (e.ge) l.le = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -390,13 +390,13 @@ function supersede(e, n, s) {
             // it: an input's truth equal to its committed value is silent).
             u.Re = null;
             if (!i) {
-                if (E !== NOT_PENDING && e.ke) l.ue = E;
+                if (E !== NOT_PENDING && e.ge) l.ie = E;
                 if (l.m & STATUS_PENDING) {
-                    u.Se = null;
+                    u.Ee = null;
                     enqueueSub(l);
                 }
             }
-            if (e.ke) {
+            if (e.ge) {
                 commitPendingNode(l);
                 if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
@@ -416,7 +416,7 @@ function supersede(e, n, s) {
     // 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.ke && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
+        if (n === null || e.ge && !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
@@ -433,7 +433,11 @@ function supersede(e, n, s) {
  * has shown, or one the seam has not judged yet (its run waits on the
  * 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) {
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */ function laneRead(e, n) {
     const s = n.l & CONFIG_GUESS;
     const t = txOf(n);
     // A lane a correction folded under (D-34): store/optimistic.ts reads it.
@@ -450,6 +454,7 @@ function supersede(e, n, s) {
     // An errored member's lane value predates its error; the error is the answer (#4106).
         if (!s && u & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
+    const i = !s && u & STATUS_PENDING;
     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
@@ -458,39 +463,45 @@ function supersede(e, n, s) {
         // lanes read by one pass link, as for tracked reads). Outside lane
         // work, the screen.
         if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(t, e);
-        if (!s && u & STATUS_PENDING) return NOT_PENDING;
-        return laneValueOf(n);
-    }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, t))) {
-        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 (u & 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 (t.ln || !s && u & STATUS_PENDING) {
-            if (!s && !t.ke && u & 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;
-                t.En.push(e);
+    } else if (e.i === EFFECT_RENDER) {
+        // 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.
+        const l = i && n.T.P === NOT_PENDING;
+        // D-28: a leaf a verdict read moved into the lane still throws on such
+        // a flight — the pass leaves the lane, and its frame holds as if the
+        // read had come first (S-39, #4275). Nor does a verdict lane's seat carry
+        // the leaf into another lane (no link): it reads that lane as from the
+        // frame's seat (#4284).
+                if ((l || passLane !== t) && passLane?._parent.Pe === passLane) setPassLane(null);
+        if (passLane === null || !sameLane(passLane, t)) {
+            // (A lane that has never shown: the screen is the committed value.)
+            if (l && t.ge) return NOT_PENDING;
+            if (!s && n.ie !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ie;
+            if (t.ln || i) {
+                if (!s && !t.ge && u & 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;
+                    t.En.push(e);
+                }
+                return display(n);
             }
-            return display(n);
+            // A verdict reader reads ahead of the seam's verdict: re-derived on the
+            // screen if the lane holds (#4284).
+                        if (e.l & CONFIG_VERDICT && t._parent.Pe !== t) entered.push(e);
         }
     }
     enterLane(t, e);
-    if (!s && u & STATUS_PENDING) return NOT_PENDING;
-    return laneValueOf(n);
+    return i ? NOT_PENDING : 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.l & CONFIG_SLOT_NODE && GlobalQueue.fn !== undefined ? GlobalQueue.fn(e) : e.Ie;
+    return e.l & CONFIG_SLOT_NODE && GlobalQueue.fn !== undefined ? GlobalQueue.fn(e) : e.le;
 }
 
 /** A guess in `l` whose own truth is in flight (its refetch — authoritative:
@@ -521,7 +532,7 @@ function supersede(e, n, 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;
+        if (!l.nt || l.tt !== 0 || l.P || 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
@@ -529,8 +540,8 @@ function supersede(e, n, s) {
                 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.ue !== NOT_PENDING ? n.ue : covered(n);
-                supersede(n, e, !n.xe || !n.xe(n.T.v, e));
+                const e = n.ie !== NOT_PENDING ? n.ie : covered(n);
+                supersede(n, e, !n.xe || !n.xe(n.T.P, e));
             }
         }
     }
@@ -545,7 +556,7 @@ function laneSeam(e, n) {
         return;
     }
     e.ln = false;
-    e.ke = true;
+    e.ge = true;
     reruns(e);
     for (let n = 0; n < e.tn.length; n++) {
         const s = e.tn[n];
@@ -555,9 +566,9 @@ function laneSeam(e, n) {
         }
         const t = s.T;
         if (t.Re !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
-            t.v = s.ue;
-            s.ue = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ie !== NOT_PENDING) {
+            t.P = s.ie;
+            s.ie = NOT_PENDING;
         }
         // The frame this pass built is the screen's now; the one it replaced
         // goes (as `commitPendingNode` retires a committed pass's).
@@ -582,7 +593,7 @@ function laneSeam(e, n) {
  * frame is not complete without it (A15) — landing it would commit the write
  * beside a derivation still showing the old one. A guess whose own flight is
  * up likewise: the question was asked in this frame. */ function lanesBlocked(e) {
-    return e.v && linkBlocked(e) || nestedBlocked(e);
+    return e.P && linkBlocked(e) || nestedBlocked(e);
 }
 
 /** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
@@ -611,17 +622,17 @@ function laneSeam(e, n) {
         // folds a current one beneath it (D-34): true.
         const s = stale(e, question);
         if (GlobalQueue.an?.(e, n, s) || s) {
-            e.ue = n;
+            e.ie = n;
             e.l |= CONFIG_HELD;
             schedule();
             return n;
         }
-        supersede(e, n, !e.xe || !e.xe(e.T.v, n));
+        supersede(e, n, !e.xe || !e.xe(e.T.P, n));
     } else {
         const s = txOf(e);
         if (e.xe && e.xe(laneValueOf(e), n)) return n;
-        if (s.ke) e.ue = n; else e.T.v = n;
-        if (e.X !== undefined) e.ie = clock;
+        if (s.ge) e.ie = n; else e.T.P = n;
+        if (e.X !== undefined) e.Se = clock;
         insertSubs(e);
         laneDirty(e, s);
     }
@@ -643,18 +654,18 @@ function laneSeam(e, n) {
  * 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.ue = n;
+        e.ie = n;
         e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.xe || !e.xe(e.T.v, n));
+    supersede(e, n, !e.xe || !e.xe(e.T.P, 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.T.Ee;
+    return n !== 0 && n < e.T.Te;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
@@ -663,7 +674,7 @@ function laneSeam(e, n) {
     let n = 0;
     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;
+        if (e.T !== null && e.T.Te > n && e.Se === clock) n = e.T.Te;
     }
     return n;
 }
@@ -693,20 +704,29 @@ const laneSeams = e => {
         // 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 (t.R & REACTIVE_DISPOSED || l != null && l._parent?.he === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+                if (t.R & REACTIVE_DISPOSED || l != null && l._parent?.Pe === 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;
+                if (l != null && l.P && t.i) t.R |= REACTIVE_LANE_DIRTY;
         enqueueSub(t);
-        if (l != null && l.v && n.indexOf(l) === -1) n.push(l);
+        if (l != null && l.P && 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);
+    // A verdict reader that entered a lane this seam held: its run waits with
+    // the lane, and the verdict beside it would freeze — it re-derives next
+    // round from the frame's seat, a stale reader of the lane (#4284).
+        for (let e; e = entered.pop(); ) if (e.T.Re?.ln) {
+        e.R &= ~REACTIVE_LANE_DIRTY;
+        enqueueSub(e);
+    }
 };
 
+/** Render effects that read a verdict and entered a lane before its seam (#4284). */ const entered = [];
+
 installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked);
 
 GlobalQueue.J = verdictLane;