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

package/dist/observe/core/effect.js

@@ -18,45 +18,48 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, e, o, u) {
-    const E = !!u?.user;
-    const r = createEffectNode(t, e, o, E ? EFFECT_USER : EFFECT_RENDER, u);
-    recompute(r, true);
+ */ function effect(t, e, o, r) {
+    const u = !!r?.user;
+    const E = createEffectNode(t, e, o, u ? EFFECT_USER : EFFECT_RENDER, r);
+    recompute(E, true);
     // A first pass that read a staged value was staged itself (recompute: born
     // 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 && r.ue === NOT_PENDING && !r.T?.Je?.V && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !r?.defer && E.ie === NOT_PENDING && !E.T?.Je?.V && (E.i === EFFECT_USER || r?.schedule ? globalQueue.enqueue(E.i, runEffect.bind(null, E)) : runEffect(E, E.i));
 }
 
-function notifyEffectStatus(t, e) {
-    // Use passed values if provided, otherwise read from node
-    const o = t !== undefined ? t : this.m;
-    const u = e !== undefined ? e : this.T?.F;
-    if (o & STATUS_ERROR) {
+function notifyEffectStatus() {
+    const t = this.m;
+    const e = this.T?.F;
+    if (t & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
             // and the runner dispatches on them, so a recovery before the effect
-            // phase takes the success arm instead. Blocked forwards (explicit
-            // `status` arg without node-state writes) don't queue: the status
-            // re-propagates unblocked at commit.
+            // phase takes the success arm instead. (Re-read: the boundary
+            // notify above can run a redraw.)
             if (this.m & STATUS_ERROR) {
                 this.Qe = true;
                 globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            // Dev locates the halt at the node that threw: the StatusError's
-            // source, upstream of this effect when a computed failed.
-            haltReactivity(unwrapStatusError(u));
-            throw u;
-        }
+        // Dev locates the halt at the node that threw: the StatusError's
+        // source, upstream of this effect when a computed failed.
+                escalate(this, unwrapStatusError(e), e, this);
     } else if (this.i === EFFECT_RENDER) {
-        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, o, u);
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, t, e);
+    }
+}
+
+/** An effect's error no boundary takes halts the system (boundary-or-halt):
+ * halted with `cause`, `thrown` rethrown; dev locates it at `subject`. */ function escalate(t, e, o = e, r = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw o;
     }
 }
 
@@ -83,19 +86,16 @@ function runEffect(t, e) {
     // 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._t = t.Ie;
+        t._t = t.le;
         t.Qe = false;
         try {
-            t.ht ? t.ht(e, () => {
+            t.Ht ? t.Ht(e, () => {
                 const e = t.kt;
                 t.kt = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(e);
-                throw e;
-            }
+            escalate(t, e);
         }
         return;
     }
@@ -107,23 +107,20 @@ function runEffect(t, e) {
     // cascade an observer reports) and what times the callback (the `effect`
     // record) — facts a production observer needs, not only a dev console.
         if (attrHooks !== null) attrHooks.effectRunStart(t);
-    const u = t.kt;
+    const r = t.kt;
     t.kt = undefined;
     try {
-        u?.();
-        const e = t.Ge(t.Ie, t._t);
+        r?.();
+        const e = t.Ge(t.le, t._t);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.kt = e;
     } catch (e) {
         ext(t).F = new StatusError(t, e);
         t.m |= STATUS_ERROR;
-        if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(e);
-            throw e;
-        }
+        escalate(t, e);
     } finally {
-        t._t = t.Ie;
+        t._t = t.le;
         t.Qe = false;
         // The run applied: this is the frame now, so the dependency tail the
         // compute pass left linked goes (A30, #3438 — `recompute` defers an
@@ -159,8 +156,8 @@ GlobalQueue.K = runEffect;
         const e = o.kt;
         o.kt = undefined;
         e?.();
-        const u = staleValues(t);
-        o.kt = u;
+        const r = staleValues(t);
+        o.kt = r;
     }, {
         ...e,
         lazy: true
@@ -175,7 +172,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.
-        o.M = run;
+        o.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/observe/core/graph.js

@@ -1,4 +1,4 @@
-import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
+import { NewSet, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
 
 import { deleteFromHeap } from "./heap.js";
 
@@ -21,7 +21,7 @@ function unlinkSubs(e) {
     const l = e.G;
     const o = e.t;
     const s = e.en;
-    if (o !== null) o.en = s; else n.dt = s;
+    if (o !== null) o.en = s; else n.Ct = s;
     if (s !== null) s.t = o; else {
         n.o = o;
         if (o === null) {
@@ -107,7 +107,7 @@ function unobserved(e) {
  * stays alive and serves its cache, uniform with observed memos) while
  * reclamation still happens within one microtask — the enqueue site arms
  * schedule(), so a flush is guaranteed even when no other work is queued.
- */ const dormantNodes = new Set;
+ */ const dormantNodes = new NewSet;
 
 function sweepDormant() {
     if (dormantNodes.size === 0) return;
@@ -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.Ie = n.Ne;
             n._ = o;
             return;
         }
@@ -143,15 +143,15 @@ function link(e, n) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (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.dt;
-    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
-    const t = n._ = e.dt = {
+        const r = e.Ct;
+    if (r !== null && r.u === n && (!s || r.Ie === n.Ne)) return;
+    const t = n._ = e.Ct = {
         S: e,
         u: n,
         G: o,
         en: r,
         t: null,
-        Te: n.Ne
+        Ie: n.Ne
     };
     if (l !== null) l.G = t; else n.C = t;
     if (r !== null) r.t = t; else e.o = t;

package/dist/observe/core/heap.js

@@ -11,12 +11,12 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.st > e.Et) dirtyQueue.st = e.Et;
+    if (dirtyQueue.lt > e.Et) dirtyQueue.lt = e.Et;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Pt ? e._parent.Ht?.Et : e._parent?.Et) ?? -1;
+    const E = (e._parent?.Pt ? e._parent.ht?.Et : e._parent?.Et) ?? -1;
     if (E >= e.Et) e.Et = E + 1;
     const n = e.Et;
     const I = t.gt[n];
@@ -98,11 +98,11 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.p = false;
-    for (e.st = 0; e.st <= e.jt; e.st++) {
-        let E = e.gt[e.st];
+    for (e.lt = 0; e.lt <= e.jt; e.lt++) {
+        let E = e.gt[e.lt];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.gt[e.st];
+            E = e.gt[e.lt];
         }
     }
     e.jt = 0;

package/dist/observe/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 { attrHooks } from "./attribution-hooks.js";
 
@@ -10,7 +10,7 @@ import { laneValueOf } from "./truth.js";
 
 import { enqueueSub } from "./heap.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";
+import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, resolveTx, newTransaction, 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
@@ -53,7 +53,7 @@ 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.Je.It && n !== NOT_PENDING ? n : e.Ie;
+    return e.T.Je.It && n !== NOT_PENDING ? n : e.le;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -68,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.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) {
@@ -84,7 +84,7 @@ function optimisticWrite(e, n) {
     // the guess's question and entangles its frame (#3347) without notifying.
     const s = guessedValueOf(e);
     if (typeof n === "function") n = n(s);
-    if (e.Ye && e.Ye(s, n) && !(e.l & CONFIG_GUESS)) return n;
+    if (e.je && e.je(s, n) && !(e.l & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
     schedule();
     return n;
@@ -114,25 +114,25 @@ function applyGuesses(e) {
         // 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;
+                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). The same
             // value re-asked renews the question; nothing to notify.
-            u = !t.Ye || !t.Ye(laneValueOf(t), l);
+            u = !t.je || !t.je(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.ue = NOT_PENDING;
+                t.ie = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
             t.T.V = l;
-            r = txOf(t)._parent;
+            i = txOf(t)._parent;
         } else {
             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 (t.l & CONFIG_HELD) s = newLane(i = txOf(t)); else {
                 if (e === null && inFlight(t)) e = newTransaction(false);
                 if (e === null) continue;
                 s = n ??= newLane(e);
@@ -147,8 +147,8 @@ function applyGuesses(e) {
             t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
             list(t, s);
         }
-        if (e !== null && r !== null) merge(e, r);
-        ext(t).Ee = pendingGuesses[s + 2];
+        if (e !== null && i !== null) merge(e, i);
+        ext(t).de = 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
@@ -266,7 +266,7 @@ function unlink(e) {
     }
     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);
         }
@@ -327,7 +327,7 @@ function supersede(e, n, 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.It) e.Ie = e.T.V;
+                if (t.It) e.le = e.T.V;
         e.l &= -10241;
         e.T.V = NOT_PENDING;
         holdNode(e, l);
@@ -337,7 +337,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.tn?.(t);
     }
-    e.ue = n;
+    e.ie = n;
     joinFuture(l);
 }
 
@@ -361,16 +361,16 @@ function supersede(e, n, s) {
         e.it = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
-    for (let t = 0; t < e.je.length; t++) {
-        const l = e.je[t];
+    for (let t = 0; t < e.Ye.length; t++) {
+        const l = e.Ye[t];
         const u = l.T;
         if (l === s || u.Je !== e) continue;
-        const r = l.i;
-        const i = l.l & CONFIG_GUESS;
+        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.It && !r ? o : l.Ie;
+                const E = e.It && !i ? o : l.le;
         const f = laneValueOf(l);
         u.V = NOT_PENDING;
         l.l &= -10241;
@@ -381,9 +381,9 @@ function supersede(e, n, s) {
             // 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.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");
+            if (r && e.It && attrHooks !== null) {
+                const e = l.ie !== NOT_PENDING ? l.ie : l.le;
+                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.ie !== 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
@@ -391,19 +391,19 @@ function supersede(e, n, s) {
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
                         u.Je = null;
-            if (!r && !i) l.ue = f;
+            if (!i && !r) l.ie = f;
             commitPendingNode(l);
-            if (!r) {
+            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.Ye || !l.Ye(E, l.Ie))) insertSubs(l);
+                if (E !== NOT_PENDING && (!l.je || !l.je(E, l.le))) insertSubs(l);
             }
-        } else if (i) {
+        } 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.It) l.Ie = o;
+            if (l.ie === NOT_PENDING) l.ie = covered(l);
+            if (e.It) l.le = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -415,18 +415,18 @@ function supersede(e, n, s) {
             // answer — it re-asks from the truth (whose notification may not reach
             // it: an input's truth equal to its committed value is silent).
             u.Je = null;
-            if (!r) {
-                if (E !== NOT_PENDING && e.It) l.ue = E;
+            if (!i) {
+                if (E !== NOT_PENDING && e.It) l.ie = E;
                 if (l.m & STATUS_PENDING) {
-                    u.Se = null;
+                    u.Ee = null;
                     enqueueSub(l);
                 }
             }
             if (e.It) {
                 commitPendingNode(l);
-                if (!r) l.l |= CONFIG_INPUTS_PUBLISHED;
+                if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (u.Nt !== null || u.ft !== null) GlobalQueue.et(l, false, true);
+                if (u.ft !== null || u.Nt !== null) GlobalQueue.et(l, false, true);
                 l.l &= -1048961;
             }
         }
@@ -459,7 +459,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.
@@ -476,6 +480,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
@@ -484,45 +489,51 @@ 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.It && 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.V === 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.it === passLane) setPassLane(null);
+        if (passLane === null || !sameLane(passLane, t)) {
+            // (A lane that has never shown: the screen is the committed value.)
+            if (l && t.It) 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.It && 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.it !== 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:
  * the landing supersedes, not the body's end). */ function guessFlights(e) {
-    for (let n = 0; n < e.je.length; n++) {
-        const s = e.je[n];
+    for (let n = 0; n < e.Ye.length; n++) {
+        const s = e.Ye[n];
         if (s.l & CONFIG_GUESS && s.T.Je === e && inFlight(s)) return true;
     }
     return false;
@@ -552,12 +563,12 @@ function supersede(e, n, s) {
         // 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 < t.je.length && lanes.indexOf(t) !== -1; e++) {
-            const n = t.je[e];
+                for (let e = 0; e < t.Ye.length && lanes.indexOf(t) !== -1; e++) {
+            const n = t.Ye[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));
+                const e = n.ie !== NOT_PENDING ? n.ie : covered(n);
+                reverting = n.ie === NOT_PENDING;
+                supersede(n, e, !n.je || !n.je(n.T.V, e));
                 reverting = false;
             }
         }
@@ -575,21 +586,21 @@ function laneSeam(e, n) {
     e.ln = false;
     e.It = true;
     reruns(e);
-    for (let n = 0; n < e.je.length; n++) {
-        const s = e.je[n];
+    for (let n = 0; n < e.Ye.length; n++) {
+        const s = e.Ye[n];
         if (s.R & LEFT_SHOWN) {
             s.R ^= LEFT_SHOWN;
             insertSubs(s);
         }
         const t = s.T;
         if (t.Je !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
-            t.V = s.ue;
-            s.ue = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ie !== NOT_PENDING) {
+            t.V = 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).
-                if (t.Nt !== null || t.ft !== null) GlobalQueue.et(s, false, true);
+                if (t.ft !== null || t.Nt !== null) GlobalQueue.et(s, false, true);
         s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
@@ -639,17 +650,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.Ye || !e.Ye(e.T.V, n));
+        supersede(e, n, !e.je || !e.je(e.T.V, n));
     } else {
         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;
+        if (e.je && e.je(laneValueOf(e), n)) return n;
+        if (s.It) e.ie = n; else e.T.V = n;
+        if (e.X !== undefined) e.ae = clock;
         insertSubs(e);
         laneDirty(e, s);
     }
@@ -671,18 +682,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.Ye || !e.Ye(e.T.V, n));
+    supersede(e, n, !e.je || !e.je(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.T.Ee;
+    return n !== 0 && n < e.T.de;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
@@ -691,7 +702,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.de > n && e.ae === clock) n = e.T.de;
     }
     return n;
 }
@@ -733,16 +744,25 @@ const laneSeams = e => {
         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);
+    // 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.Je?.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.Ke = e => {
+GlobalQueue.xe = e => {
     const n = [];
     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]);
+        for (let e = 0; e < t.Ye.length; e++) if (t.Ye[e].l & CONFIG_GUESS && t.Ye[e].T.Je === t) n.push(t.Ye[e]);
     }
     return n;
 };