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

package/dist/prod/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_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 { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DIRTY, REACTIVE_CHECK, REACTIVE_IN_HEAP, STATUS_PENDING, CONFIG_SLOT_NODE, REACTIVE_STAGED_READ, 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, CONFIG_INPUTS_PUBLISHED, CONFIG_STAGED, REACTIVE_JOINED } from "./constants.js";
 
-import { ext, tracking, stagedRead } from "./core.js";
+import { ext, bornInto, tracking, creatorReads, stagedRead } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
+import { removePendingSource, releaseFlightTeardown, handleAsync, notifyStatus, isThenable } from "./async.js";
+
 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, setPassLane, sameLane, flushTransaction, commitPendingNode, releaseQueues, holdNode, joinFuture, reruns, merge } from "./scheduler.js";
+import { schedule, question, nextQuestion, armGuessing, installLaneHooks, GlobalQueue, newTransaction, list, staleReader, resolveTx, txOf, commitPendingNode, ownFlights, stagedReaders, blocked, clock, insertSubs, laneDirty, flushTransaction, queuePendingNode, passLane, setPassLane, sameLane, releaseQueues, holdNode, 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
@@ -49,9 +51,10 @@ 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) {
+ * has revealed, the committed truth before — NOT_PENDING when there is none
+ * (uninitialized, as `laneValueOf`): its read throws NotReady. */ function display(e) {
     const n = e.T.P;
-    return e.T.Re.ge && n !== NOT_PENDING ? n : e.le;
+    return e.T.Re.Ue && n !== NOT_PENDING ? n : e.m & STATUS_UNINITIALIZED ? NOT_PENDING : e.le;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -64,9 +67,8 @@ function newLane(e) {
 /** What the writer sees of a node: an unflushed guess to it, else the
  * lane's value or the committed one — what an optimistic updater composes
  * 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.le;
+    let n = pendingGuessOf(e);
+    return n !== NOT_PENDING || e.l & CONFIG_OVERRIDE && (n = laneValueOf(e)) !== NOT_PENDING ? n : e.le;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -74,6 +76,32 @@ function newLane(e) {
     return NOT_PENDING;
 }
 
+/** This module's copy of scheduler.ts `guessing`: its readers here stay
+ * foldable when a bundler splits lanes.ts from scheduler.ts into separate
+ * chunks (a cross-chunk binding is not folded; the compiled live page). */ let guessed = false;
+
+/** Guesses another action's lane took over (#4336): the node, its guess,
+ * the guess's lane, its question, the lane that took it. */ const kept = [];
+
+/** Lanes a revert dissolved: the guesses they took come back at their
+ * parent's landing (`endLanes`). */ const reverted = /* @__PURE__ */ new WeakSet;
+
+/** Lane `l` takes `n`'s guess (another action's), kept to come back if `l`
+ * reverts. Its readers saw the guess: they re-derive at the lane's reveal
+ * (and, a flight's, hold the lane while they would show it). `d`: a guess
+ * `l` takes without writing it (a store target's other slots) — the node
+ * shows its truth in `l`'s world until the guess comes back. */ function take(e, n, s) {
+    const t = e.T;
+    kept.push(e, t.P, t.Re, t.Ie, n);
+    rerun(e, n);
+    e.l &= s ? -10241 : ~CONFIG_GUESS;
+    if (s) t.Re = null, t.P = NOT_PENDING; else list(e, n);
+}
+
+/** `n`'s readers are stale readers of `t` (re-derived at its landing). */ function rerun(e, n) {
+    for (let s = e.o; s !== null; s = s.t) staleReader(s.u, n);
+}
+
 function optimisticWrite(e, n) {
     // What the user sees: an unflushed guess to the same node, else the lane's
     // value or the committed one. The updater composes on it; guessing it
@@ -82,8 +110,10 @@ 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.xe && e.xe(s, n) && !(e.l & CONFIG_GUESS)) return n;
+    if (e.ye && e.ye(s, n) && !(e.l & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
+    armGuessing();
+    guessed = true;
     schedule();
     return n;
 }
@@ -100,7 +130,7 @@ 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.m & STATUS_PENDING) !== 0 || (e.l & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.k?.(e) === true;
+    return e.m & STATUS_PENDING || e.l & CONFIG_SLOT_NODE && GlobalQueue.k?.(e);
 }
 
 function applyGuesses(e) {
@@ -117,9 +147,9 @@ function applyGuesses(e) {
             // 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.xe || !t.xe(laneValueOf(t), l);
+            u = !t.ye || !t.ye(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.ie = NOT_PENDING;
+                t.ue = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
             t.T.P = l;
@@ -146,7 +176,7 @@ function applyGuesses(e) {
             list(t, s);
         }
         if (e !== null && i !== null) merge(e, i);
-        ext(t).Te = pendingGuesses[s + 2];
+        ext(t).Ie = 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
@@ -166,24 +196,31 @@ function applyGuesses(e) {
  * action, not with the one it shares a reader with). A nested lane reading
  * through an ancestor's guess stays its own (the screen plus its own
  * guesses). */ function enterLane(e, n) {
-    n.R |= REACTIVE_LANE_READ;
-    const s = passLane;
-    if (s === null) {
+    const s = n.R |= REACTIVE_LANE_READ, t = passLane;
+    if (t === null) {
+        const t = e._parent.Pe === e;
+        // A verdict lane's value (a memo of `latest` / `isPending`, F-6) read by
+        // a derivation that already read the frame's staging or joined its
+        // hold, or by any pass a pass that did is creating: the verdict read
+        // does not break it out — it stays the frame's, as the same read inline
+        // does (verdict.ts `markVerdictReader`, `route`; D-25, D-26). An
+        // effect's own reads do not count (its `_type`, 1–3, carries neither bit).
+                if (!(t && creatorReads(n, n.i || s))) {
+            setPassLane(e);
+            // The pass read a held write before its first lane read (it joined the
+            // frame's future as mainline would): lane work sees the screen — the
+            // seam re-derives it on the committed world next round (`stagedReaders`,
+            // the park's repair), as it does a lane pass that read a staging. Not a
+            // pass whose held reads were all of nodes born held (no staged read,
+            // `stagedRead`): it has no committed world to re-derive on (#3969).
+            // (A pass not joined: a held write beside a guess, #4336; a leaf of a
+            // verdict lane — its plain reads are the screen's, D-26 `[s(), L()]`.)
+                        if (s & REACTIVE_STAGED_READ && (guessed || t || s & REACTIVE_JOINED)) stagedRead(n);
+        }
+    } else if (sameLane(t, e)) setPassLane(e); else if (!under(t, e)) {
+        if (!under(e, t)) linkLanes(t, e);
         setPassLane(e);
-        // The pass read a held write before its first lane read (it joined the
-        // frame's future as mainline would): lane work sees the screen — the
-        // seam re-derives it on the committed world next round (`stagedReaders`,
-        // the park's repair), as it does a lane pass that read a staging. Not a
-        // pass whose held reads were all of nodes born held (no staged read,
-        // `stagedRead`): it has no committed world to re-derive on (#3969).
-                if (n.R & REACTIVE_JOINED && n.R & REACTIVE_STAGED_READ) stagedRead(n);
-        return;
     }
-    if (sameLane(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) {
@@ -253,10 +290,19 @@ function unlink(e) {
         const n = e.T;
         if (n !== null) {
             const s = n.Re;
-            // Cleared before equality, so a return to the committed value notifies
-            // nobody. The seam wakes it unless the frame is still held (#3892).
-                        if (s?.ge && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
-            if (s?.P) n.Re = null;
+            if (s?.P) {
+                // Cleared before equality, so a return to the committed value
+                // notifies nobody. The seam wakes it (#3892) — always for a pass
+                // outside any transaction's flush: its value is the screen's now
+                // (#4367). While a transaction's flush runs the pass and the lane's
+                // frame is still held, what the screen shows stays the screen until
+                // the landing, and `_value` takes it (as `dissolveLane` keeps a shown
+                // lane's), so this pass's answer — the frame's — is a change against
+                // what is seen and reaches the screen with the frame's commit. (Only
+                // a lane is ever `_shown`.)
+                if (s.Ue) if (!flushTransaction || !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN; else e.le = display(e);
+                n.Re = null;
+            }
             n.P = NOT_PENDING;
         }
         e.l &= -1050881;
@@ -264,7 +310,7 @@ function unlink(e) {
     }
     if (!e.i) {
         if (!(e.l & CONFIG_OVERRIDE)) {
-            e.ie = NOT_PENDING;
+            e.ue = NOT_PENDING;
             e.l = e.l & -1048833 | CONFIG_OVERRIDE;
             ext(e);
         }
@@ -274,7 +320,12 @@ 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 (!t) e.l &= ~CONFIG_GUESS;
+        // Nor a pass of another action's guess: the re-ask is this lane's new
+        // question, which the guess (over the old one) does not answer — the
+        // lane waits for its own answer (F-1, F-6, #4336). (A guess of the
+        // lane's own action, D-33's entangled slot, still stands in.)
+        // (Read behind `guessed`: a bundle without optimism drops the reads.)
+                if (guessed && e.l & CONFIG_GUESS && e.T.Re?.P && resolveTx(e.T.Re._parent) !== resolveTx(n._parent)) take(e, n); else 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
@@ -297,6 +348,21 @@ function unlink(e) {
     return true;
 }
 
+/** The truth arrived for a written guess (A18): a correction dissolves the
+ * lane — the guess and everything derived from it is void, the truth is
+ * the parent's held write and the graph re-derives from it there, one frame
+ * at the parent's landing — while the display keeps what it shows until
+ * then. A confirmation is silent (A17): the truth stays staged beneath the
+ * guess for the parent's commit, the guess stays the value; only a reader
+ * of the truth (CONFIG_AUTHORITATIVE) is told its view changed. Either way
+ * the parent takes this node, not the tick that carried the truth (D-33):
+ * one landing answering two actions' guesses (a store re-ask over two
+ * rows) must not tie them together; a pass that derives from the held
+ * truth joins the parent on its own (`joinPass`). */
+/** The correction round is replacing a guess with the value it covered (no
+ * landing beneath it): observe's "reverted"; the lane gives back the
+ * guesses it took (#4336, `endLanes`). */ let reverting = false;
+
 function supersede(e, n, s) {
     const t = txOf(e);
     // Resolved: the parent may have merged into another transaction since the
@@ -309,9 +375,10 @@ function supersede(e, n, s) {
         if (s && e.l & CONFIG_SLOT_NODE && GlobalQueue.nn?.(e.T.P, n)) s = false;
     if (s) {
         dissolveLane(t, l, e);
+        if (guessed && reverting) reverted.add(t);
         // 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.ge) e.le = e.T.P;
+                if (t.Ue) e.le = e.T.P;
         e.l &= -10241;
         e.T.P = NOT_PENDING;
         holdNode(e, l);
@@ -321,8 +388,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.sn?.(t);
     }
-    e.ie = n;
-    joinFuture(l);
+    e.ue = n;
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -345,18 +411,20 @@ function supersede(e, n, s) {
         e.Pe = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
+    // First loads this dissolution leaves loading (below).
+        const u = [];
     for (let t = 0; t < e.tn.length; t++) {
         const l = e.tn[t];
-        const u = l.T;
-        if (l === s || u.Re !== e) continue;
-        const i = l.i;
-        const r = l.l & CONFIG_GUESS;
-        const o = u.P;
+        const i = l.T;
+        if (l === s || i.Re !== e) continue;
+        const r = l.i;
+        const o = l.l & CONFIG_GUESS;
+        const E = i.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.ge && !i ? o : l.le;
+                const a = e.Ue && !r ? E : l.le;
         const f = laneValueOf(l);
-        u.P = NOT_PENDING;
+        i.P = NOT_PENDING;
         l.l &= -10241;
         if (n === null) {
             // A derivation the revert re-derives (dirtied by the guess's
@@ -364,20 +432,33 @@ function supersede(e, n, s) {
             // lane's answer beside inputs that are the truth now: a fresh reader
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
-            u.Re = null;
-            if (!i && !r) l.ie = f;
+            // Not a first load the lane produced nothing for whose own flight is
+            // up, nor one pending on such a load kept here (an identity memo of
+            // it, a derived store's derive): committing its empty `_value` would
+            // initialize it as `undefined`, which `latest()` would serve and
+            // `isPending()` call pending. It stays loading until its flight
+            // answers (D-22, A19 exc. 1; async-gen 3289 #929, 91501 #504, #156).
+            i.Re = null;
+            if (!r && !o) E === NOT_PENDING && (l.m & (STATUS_UNINITIALIZED | STATUS_PENDING)) === (STATUS_UNINITIALIZED | STATUS_PENDING) && (i.Ee || u.some(e => i.se?.has(e))) ? u.push(l) : l.ue = f;
             commitPendingNode(l);
-            if (!i) {
+            if (!r) {
                 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.le))) insertSubs(l);
+                if (a !== NOT_PENDING && (!l.ye || !l.ye(a, l.le))) insertSubs(l);
             }
-        } else if (r) {
+            // A stale reader's own error — its pass (a memo's or a render
+            // effect's) threw over the committed value of what the parent held
+            // (A10), served as the screen — is no answer of the world landing now:
+            // it re-derives on it (A15; D-39, the landing is the new answer). The
+            // landing's `reruns` skips an errored reader: its error is an errored
+            // source's (#3945).
+                        if (l.R & REACTIVE_FRAME_READ && l.m & STATUS_ERROR && i.U.source === l) enqueueSub(l);
+        } else if (o) {
             // 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.ie === NOT_PENDING) l.ie = covered(l);
-            if (e.ge) l.le = o;
+            if (l.ue === NOT_PENDING) l.ue = covered(l);
+            if (e.Ue) l.le = E;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -388,19 +469,19 @@ function supersede(e, n, s) {
             // flight is asking the void world's question: its landing is nobody's
             // answer — it re-asks from the truth (whose notification may not reach
             // it: an input's truth equal to its committed value is silent).
-            u.Re = null;
-            if (!i) {
-                if (E !== NOT_PENDING && e.ge) l.ie = E;
+            i.Re = null;
+            if (!r) {
+                if (a !== NOT_PENDING && e.Ue) l.ue = a;
                 if (l.m & STATUS_PENDING) {
-                    u.Ee = null;
+                    i.Ee = null;
                     enqueueSub(l);
                 }
             }
-            if (e.ge) {
+            if (e.Ue) {
                 commitPendingNode(l);
-                if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
+                if (!r) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (u.Ue !== null || u.me !== null) GlobalQueue.Ce(l, false, true);
+                if (i.me !== null || i.Le !== null) GlobalQueue.Ce(l, false, true);
                 l.l &= -1048961;
             }
         }
@@ -416,7 +497,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.ge && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
+        if (n === null || e.Ue && !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
@@ -478,17 +559,22 @@ function supersede(e, n, s) {
                 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 (l && t.Ue) return NOT_PENDING;
+            if (!s && n.ue !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ue;
             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)) {
+                // Before the throw below: a leaf that waits on a lane that has never
+                // shown has no flight to settle it — only the reveal re-derives it,
+                // and its pending holds its frame until then (#4338).
+                if (!(e.R & REACTIVE_SCREEN_READ)) {
                     e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
                     t.En.push(e);
                 }
-                return display(n);
+                // Nothing on screen yet (uninitialized: `display` is NOT_PENDING).
+                                const s = display(n);
+                if (s === NOT_PENDING) throw new NotReadyError(null);
+                return s;
             }
             // A verdict reader reads ahead of the seam's verdict: re-derived on the
             // screen if the lane holds (#4284).
@@ -501,7 +587,7 @@ function supersede(e, n, s) {
 
 /** 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.le;
+    return e.l & CONFIG_SLOT_NODE && GlobalQueue.an !== undefined ? GlobalQueue.an(e) : e.le;
 }
 
 /** A guess in `l` whose own truth is in flight (its refetch — authoritative:
@@ -540,8 +626,10 @@ 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.ie !== NOT_PENDING ? n.ie : covered(n);
-                supersede(n, e, !n.xe || !n.xe(n.T.P, e));
+                const e = n.ue !== NOT_PENDING ? n.ue : covered(n);
+                if (guessed) reverting = n.ue === NOT_PENDING;
+                supersede(n, e, !n.ye || !n.ye(n.T.P, e));
+                if (guessed) reverting = false;
             }
         }
     }
@@ -556,8 +644,8 @@ function laneSeam(e, n) {
         return;
     }
     e.ln = false;
-    e.ge = true;
-    reruns(e);
+    e.Ue = true;
+    if (reruns(e)) revealing.push(resolveTx(e._parent));
     for (let n = 0; n < e.tn.length; n++) {
         const s = e.tn[n];
         if (s.R & LEFT_SHOWN) {
@@ -566,13 +654,13 @@ function laneSeam(e, n) {
         }
         const t = s.T;
         if (t.Re !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.ie !== NOT_PENDING) {
-            t.P = s.ie;
-            s.ie = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
+            t.P = 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 (t.Ue !== null || t.me !== null) GlobalQueue.Ce(s, false, true);
+                if (t.me !== null || t.Le !== null) GlobalQueue.Ce(s, false, true);
         s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
@@ -580,6 +668,25 @@ function laneSeam(e, n) {
 
 /** The parent landed: its lanes end, nested first. (None is blocked: a
  * blocked lane blocks its parent.) */ function endLanes(e) {
+    // A revert landing (#4336): the guesses its lane took from another action
+    // that is still out come back in this frame, over the truth it lands —
+    // its readers re-derive with the landing (one frame, no bare truth
+    // between). Taken by a later lane since, a node stays that lane's.
+    if (guessed) for (let n = kept.length - 5; n >= 0; n -= 5) if (resolveTx(kept[n + 4]._parent) === e) {
+        let [s, t, l, u, i] = kept.splice(n, 5);
+        // (A store slot's node now: the one taken, or a read's since.)
+                if (reverted.has(i) && lanes.includes(l) && (!(s.l & CONFIG_SLOT_NODE) || (s = GlobalQueue.fn(s, true)))) {
+            const n = ext(s);
+            if (n.Re === null || txOf(s) === e) {
+                commitPendingNode(s);
+                n.P = t;
+                n.Ie = u;
+                s.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+                list(s, l);
+                rerun(s, e);
+            }
+        }
+    }
     for (let n = lanes.length - 1; n >= 0; n--) {
         const s = lanes[n];
         if (resolveTx(s._parent) !== e) continue;
@@ -596,7 +703,13 @@ function laneSeam(e, n) {
     return e.P && linkBlocked(e) || nestedBlocked(e);
 }
 
+/** Parents whose lane revealed this seam with readers to re-derive there
+ * (`laneSeam`): the lane shows ahead of its parent (F-6), so the parent lands
+ * a round later — after those readers have shown the lane's answer — even
+ * when nothing else holds it (#4393). */ const revealing = [];
+
 /** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
+    if (revealing.indexOf(e) !== -1) return true;
     for (let n = 0; n < lanes.length; n++) {
         const s = lanes[n];
         if (resolveTx(s._parent) !== e) continue;
@@ -610,7 +723,9 @@ 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.l & CONFIG_GUESS) {
+    // (A store slot's guess its derive's re-ask in another action's lane
+    // writes is that lane's derivation from here — store `_slotTake`, #4336.)
+    if (e.l & CONFIG_GUESS && !(guessed && GlobalQueue.fn?.(e))) {
         // 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
@@ -621,18 +736,18 @@ function laneSeam(e, n) {
         // A store re-bases a keyed arrangement guess over an older truth, and
         // folds a current one beneath it (D-34): true.
         const s = stale(e, question);
-        if (GlobalQueue.an?.(e, n, s) || s) {
-            e.ie = n;
+        if (GlobalQueue.Nn?.(e, n, s) || s) {
+            e.ue = n;
             e.l |= CONFIG_HELD;
             schedule();
             return n;
         }
-        supersede(e, n, !e.xe || !e.xe(e.T.P, n));
+        supersede(e, n, !e.ye || !e.ye(e.T.P, n));
     } else {
         const s = txOf(e);
-        if (e.xe && e.xe(laneValueOf(e), n)) return n;
-        if (s.ge) e.ie = n; else e.T.P = n;
-        if (e.X !== undefined) e.Se = clock;
+        if (e.ye && e.ye(laneValueOf(e), n)) return n;
+        if (s.Ue) e.ue = n; else e.T.P = n;
+        if (e.X !== undefined) e.ie = clock;
         insertSubs(e);
         laneDirty(e, s);
     }
@@ -654,18 +769,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.ie = n;
+        e.ue = n;
         e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.xe || !e.xe(e.T.P, n));
+    supersede(e, n, !e.ye || !e.ye(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.Te;
+    return n !== 0 && n < e.T.Ie;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
@@ -674,7 +789,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.Te > n && e.Se === clock) n = e.T.Te;
+        if (e.T !== null && e.T.Ie > n && e.ie === clock) n = e.T.Ie;
     }
     return n;
 }
@@ -689,33 +804,100 @@ const applyGuessesAt = e => {
     if (pendingGuesses.length !== 0) applyGuesses(e);
 };
 
+/** `t` is parked by `r`'s pass alone: each node keeping it — `t`'s own, or
+ * a lane's under it — is `r` itself (its flight, in the verdict lane) or a
+ * render effect pending on `r` only: the frame observing the lane work that
+ * read its staging. Anything else (an open action, a guess's flight,
+ * another flight) holds it on its own. */ function heldBy(e, n) {
+    if (e.tt !== 0 || e.P && linkBlocked(e)) return false;
+    for (let s = -1, t = e; t; t = lanes[++s]) if (t === e || resolveTx(t._parent) === e) {
+        if (t !== e && guessFlights(t)) return false;
+        for (let e = 0; e < t.tn.length; e++) {
+            const s = t.tn[e];
+            if (s === n || !(s.m & STATUS_PENDING) || s.T.Re !== null && txOf(s) !== t) continue;
+            const l = s.T.se;
+            if (s.i !== EFFECT_RENDER || l?.size !== 1 || !l.has(n)) return false;
+        }
+    }
+    return true;
+}
+
 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.
+    if (revealing.length) revealing.length = 0;
     const n = [];
-    if (e !== null) for (let s = 0; s < e.length; s++) {
-        const t = e[s];
-        const l = t.T?.Re;
+    if (e !== null) for (let s = 0; s < stagedReaders.length; s++) {
+        const t = stagedReaders[s], 
+        // A pass no transaction holds that read the frame's staging (an
+        // effect, a `[s(), latest(s)]` reader watched before the frame had
+        // a transaction): judged by the frame's — it re-derives only if the
+        // frame stays parked; landing here, what it read is the screen (one
+        // run, D-22).
+        l = t.T?.Re || (t.R & REACTIVE_STAGED_READ ? e : null);
         // 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 (t.R & REACTIVE_DISPOSED || l != null && l._parent?.Pe === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+        // what it read the screen (one run). The frame is the transaction that
+        // holds what it read (`t`, this flush's — not always the lane's parent:
+        // a landing that reached a frame held elsewhere joined that one). Nor
+        // when only this pass keeps it parked (`heldBy`): the frame lands with
+        // the pass's answer, so what the pass read is the screen when anything
+        // shows it — re-derived on the committed world, it would ask a question
+        // already asked, over inputs the landing replaces. A reader a
+        // transaction holds that read none of its stagings (a verdict reader
+        // that probed only a flight, held as the frame's pending observer or
+        // its staged derivation) has nothing to re-derive: its re-run
+        // re-enters that transaction and parks it again, every round — it
+        // runs at the landing (#4349). One that read a staging re-derives only
+        // if its frame stays parked: landing at this seam, what it read is the
+        // screen (one run, D-22). Not one born into that frame (a held pass's
+        // child, ruling A): it has no screen, its reads are the transaction's
+        // either way — it runs again at the landing, not now.
+                if (t.R & REACTIVE_DISPOSED || (l?.P ? l._parent?.Pe === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(e) || heldBy(e, t)) : l && !(t.R & REACTIVE_PROBE_UNANSWERED || t.R & REACTIVE_STAGED_READ && blocked(l) && !bornInto(t, l)))) 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.P && t.i) t.R |= REACTIVE_LANE_DIRTY;
+                if (l?.P && t.i) t.R |= REACTIVE_LANE_DIRTY;
+        // R5 for an async reader: its frame pass asked the frame's question
+        // (F-6's lane gets its own pass now). That flight is the frame's
+        // answer: the landing adopts it rather than asking it again (F-9: a
+        // re-ask of the same question is no new question; `reruns`). A frame
+        // landing at this seam has nothing to re-derive: the pass was the
+        // landing's, its flight the screen's answer. Sync or async, the
+        // reader's lane pass is still to come: the verdict lane it joins does
+        // not reveal this seam (F-6: the lane's readers show its answer
+        // together, D-23: atomic with the value) — revealed now, it showed a
+        // verdict beside the frame pass's value, before the pass that answers
+        // for the lane, and a reader of the re-derived memo read it outside
+        // the shown lane and waited for the frame (#4393).
+         else if (!l?.P && t.R & REACTIVE_PROBE_UNANSWERED) {
+            if (isThenable(t.T?.Ee)) {
+                if (!blocked(e)) continue;
+                t.T.He = t.T.Ee;
+            } else if (blocked(e)) 
+            // A sync reader's lane pass re-derives the async memos over it (a
+            // memo over a verdict memo is a verdict reader, D-25 #4050; D-22:
+            // `latest()` extracted into a memo reads as inline). The flight
+            // each asked over its frame staging, up and held by `t`, is the
+            // frame's answer too: the landing adopts it (F-9).
+            for (let n = t.o, s; n; n = n.t) if (isThenable((s = n.u).T?.Ee) && s.T.se?.has(s) && s.l & CONFIG_HELD && txOf(s) === e) s.T.He = s.T.Ee;
+            if (e?.Pe && n.indexOf(e.Pe) === -1) n.push(e.Pe);
+        }
         enqueueSub(t);
-        if (l != null && l.P && n.indexOf(l) === -1) n.push(l);
+        if (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 lane born at this seam is judged with it: it exists only once
+    // a pass routed into it — the park seam's zombie verdict readers re-run
+    // as its work so that this seam reveals them (#3444).
+        for (let e = lanes.length - 1; e >= 0; e--) if (e < judged || lanes[e]._parent?.Pe === lanes[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).
@@ -725,10 +907,40 @@ const laneSeams = e => {
     }
 };
 
+/** The landing's re-derive of a reader whose frame flight the seam parked
+ * (R5): the flight asked the question the landing would — adopted, it is
+ * asked once (F-9). Not over a pass already queued: that one asks anew.
+ * Registered as if this pass had returned it — the node pending on it, its
+ * landing the answer — through a promise of its own: the frame pass's
+ * registration still listens to the flight, and must not land it a second
+ * time. */ const adoptParked = e => {
+    const n = e.T?.He;
+    if (!n || e.R & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP)) return false;
+    e.T.He = undefined;
+    releaseFlightTeardown(e);
+    try {
+        handleAsync(e, n.then());
+    } catch {}
+    e.T.fe = true;
+    notifyStatus(e, STATUS_PENDING, new NotReadyError(e));
+    return true;
+};
+
+/** A15: lane work or a verdict reader was served `el`'s committed value
+ * (core.ts `frameRead`), so its pass does not wait on `el`'s flight: what
+ * `el`'s pending propagated onto it before the pass (its origins, `el`
+ * included) is not this pass's — the landing re-derives it (`reruns`).
+ * Kept, a pass that went pending on another source never woke when that
+ * source settled (#4397). Only a reader something made pending has anything
+ * to drop. */ const laneServed = (e, n) => {
+    const s = n.T?.se;
+    if (s && e.T?.se) for (const n of s) removePendingSource(e, n);
+};
+
 /** 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);
+installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked, adoptParked, laneServed);
 
 GlobalQueue.J = verdictLane;
 
-export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, take, verdictLane };