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

package/dist/observe/core/lanes.js

@@ -1,16 +1,18 @@
-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 { attrHooks } from "./attribution-hooks.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, resolveTx, newTransaction, 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, resolveTx, newTransaction, list, staleReader, 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
@@ -51,9 +53,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.V;
-    return e.T.Je.It && n !== NOT_PENDING ? n : e.le;
+    return e.T.Je.Nt && n !== NOT_PENDING ? n : e.m & STATUS_UNINITIALIZED ? NOT_PENDING : e.le;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -66,9 +69,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) {
@@ -76,6 +78,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.V, t.Je, t.Ie, n);
+    rerun(e, n);
+    e.l &= s ? -10241 : ~CONFIG_GUESS;
+    if (s) t.Je = null, t.V = 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
@@ -86,6 +114,8 @@ function optimisticWrite(e, n) {
     if (typeof n === "function") n = n(s);
     if (e.je && e.je(s, n) && !(e.l & CONFIG_GUESS)) return n;
     pendingGuesses.push(e, n, question || nextQuestion());
+    armGuessing();
+    guessed = true;
     schedule();
     return n;
 }
@@ -102,7 +132,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) {
@@ -110,29 +140,29 @@ function applyGuesses(e) {
     for (let s = 0; s < pendingGuesses.length; s += 3) {
         const t = pendingGuesses[s];
         const l = pendingGuesses[s + 1];
-        let u = true;
+        let r = true;
         // The frame already holding the slot: a guess over it is a second
         // suggestion for the slot, and two cannot finish apart (A34 (1)) — the
         // frames entangle.
-                let i = null;
+                let u = 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.je || !t.je(laneValueOf(t), l);
+            r = !t.je || !t.je(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.ie = NOT_PENDING;
+                t.ue = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
             t.T.V = l;
-            i = txOf(t)._parent;
+            u = 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(i = txOf(t)); else {
+                        if (t.l & CONFIG_HELD) s = newLane(u = txOf(t)); else {
                 if (e === null && inFlight(t)) e = newTransaction(false);
                 if (e === null) continue;
                 s = n ??= newLane(e);
@@ -147,9 +177,9 @@ function applyGuesses(e) {
             t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
             list(t, s);
         }
-        if (e !== null && i !== null) merge(e, i);
-        ext(t).de = pendingGuesses[s + 2];
-        if (u) {
+        if (e !== null && u !== null) merge(e, u);
+        ext(t).Ie = pendingGuesses[s + 2];
+        if (r) {
             // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
             // blocked lane's re-guess does not re-run its render effects as stale
             // readers republishing the committed view (#3460).
@@ -168,24 +198,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.it === 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) {
@@ -255,10 +292,19 @@ function unlink(e) {
         const n = e.T;
         if (n !== null) {
             const s = n.Je;
-            // Cleared before equality, so a return to the committed value notifies
-            // nobody. The seam wakes it unless the frame is still held (#3892).
-                        if (s?.It && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
-            if (s?.V) n.Je = null;
+            if (s?.V) {
+                // 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.Nt) if (!flushTransaction || !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN; else e.le = display(e);
+                n.Je = null;
+            }
             n.V = NOT_PENDING;
         }
         e.l &= -1050881;
@@ -266,7 +312,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);
         }
@@ -276,7 +322,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.Je?.V && resolveTx(e.T.Je._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
@@ -305,9 +356,14 @@ function unlink(e) {
  * 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. */
-/** Observe: the correction round is replacing a guess with the value it
- * covered (no landing beneath it) — `optimisticReverted`'s "reverted". */ let reverting = false;
+ * 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);
@@ -323,11 +379,12 @@ function supersede(e, n, s) {
         // Observe: a displayed guess is being replaced by a differing truth — a
         // landing's (superseded), or the value it covered (reverted: the body
         // ended with nothing coming true).
-        if (t.It && attrHooks !== null) attrHooks.optimisticReverted(e, e.T.V, n, reverting ? "reverted" : "superseded");
+        if (t.Nt && attrHooks !== null) attrHooks.optimisticReverted(e, e.T.V, n, reverting ? "reverted" : "superseded");
         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.It) e.le = e.T.V;
+                if (t.Nt) e.le = e.T.V;
         e.l &= -10241;
         e.T.V = NOT_PENDING;
         holdNode(e, l);
@@ -337,8 +394,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.tn?.(t);
     }
-    e.ie = n;
-    joinFuture(l);
+    e.ue = n;
 }
 
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
@@ -361,16 +417,18 @@ function supersede(e, n, s) {
         e.it = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
+    // First loads this dissolution leaves loading (below).
+        const r = [];
     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 i = l.i;
-        const r = l.l & CONFIG_GUESS;
-        const o = u.V;
+        const o = l.l & CONFIG_GUESS;
+        const E = 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 && !i ? o : l.le;
+                const a = e.Nt && !i ? E : l.le;
         const f = laneValueOf(l);
         u.V = NOT_PENDING;
         l.l &= -10241;
@@ -381,29 +439,42 @@ 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 (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");
+            if (o && e.Nt && attrHooks !== null) {
+                const e = l.ue !== NOT_PENDING ? l.ue : l.le;
+                if (e !== E) attrHooks.optimisticReverted(l, E, e, l.ue !== NOT_PENDING ? "superseded" : "reverted");
             }
             // A derivation the revert re-derives (dirtied by the guess's
             // notification — listed before it), or one still in flight, shows the
             // lane's answer beside inputs that are the truth now: a fresh reader
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
+            // 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).
                         u.Je = null;
-            if (!i && !r) l.ie = f;
+            if (!i && !o) E === NOT_PENDING && (l.m & (STATUS_UNINITIALIZED | STATUS_PENDING)) === (STATUS_UNINITIALIZED | STATUS_PENDING) && (u.Ee || r.some(e => u.se?.has(e))) ? r.push(l) : l.ue = 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.je || !l.je(E, l.le))) insertSubs(l);
+                if (a !== NOT_PENDING && (!l.je || !l.je(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 && u.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.It) l.le = o;
+            if (l.ue === NOT_PENDING) l.ue = covered(l);
+            if (e.Nt) l.le = E;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -416,17 +487,17 @@ function supersede(e, n, s) {
             // it: an input's truth equal to its committed value is silent).
             u.Je = null;
             if (!i) {
-                if (E !== NOT_PENDING && e.It) l.ie = E;
+                if (a !== NOT_PENDING && e.Nt) l.ue = a;
                 if (l.m & STATUS_PENDING) {
                     u.Ee = null;
                     enqueueSub(l);
                 }
             }
-            if (e.It) {
+            if (e.Nt) {
                 commitPendingNode(l);
                 if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
-                if (u.ft !== null || u.Nt !== null) GlobalQueue.et(l, false, true);
+                if (u.ft !== null || u.Tt !== null) GlobalQueue.et(l, false, true);
                 l.l &= -1048961;
             }
         }
@@ -442,7 +513,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.It && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
+        if (n === null || e.Nt && !e.ln) releaseQueues(e); else e.rn[0].length = e.rn[1].length = 0;
 }
 
 /** Lanes. A lane's node is read by its reader's kind: an authoritative
@@ -475,12 +546,12 @@ function supersede(e, n, s) {
         const s = l(e, n);
         if (s !== NOT_PENDING) return s;
     }
-    if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.rn(n);
-    const u = n.m;
+    if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.un(n);
+    const r = n.m;
     // An errored member's lane value predates its error; the error is the answer (#4106).
-        if (!s && u & STATUS_ERROR) return NOT_PENDING;
+        if (!s && r & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
-    const i = !s && u & STATUS_PENDING;
+    const u = !s && r & 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
@@ -495,7 +566,7 @@ function supersede(e, n, 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;
+        const l = u && 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
@@ -504,17 +575,22 @@ function supersede(e, n, s) {
                 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);
+            if (l && t.Nt) 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 || u) {
                 // 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).
@@ -522,12 +598,12 @@ function supersede(e, n, s) {
         }
     }
     enterLane(t, e);
-    return i ? NOT_PENDING : laneValueOf(n);
+    return u ? 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.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:
@@ -566,8 +642,8 @@ function supersede(e, n, s) {
                 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.ie !== NOT_PENDING ? n.ie : covered(n);
-                reverting = n.ie === NOT_PENDING;
+                const e = n.ue !== NOT_PENDING ? n.ue : covered(n);
+                reverting = n.ue === NOT_PENDING;
                 supersede(n, e, !n.je || !n.je(n.T.V, e));
                 reverting = false;
             }
@@ -584,8 +660,8 @@ function laneSeam(e, n) {
         return;
     }
     e.ln = false;
-    e.It = true;
-    reruns(e);
+    e.Nt = true;
+    if (reruns(e)) revealing.push(resolveTx(e._parent));
     for (let n = 0; n < e.Ye.length; n++) {
         const s = e.Ye[n];
         if (s.R & LEFT_SHOWN) {
@@ -594,13 +670,13 @@ function laneSeam(e, n) {
         }
         const t = s.T;
         if (t.Je !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.ie !== NOT_PENDING) {
-            t.V = s.ie;
-            s.ie = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
+            t.V = s.ue;
+            s.ue = NOT_PENDING;
         }
         // The frame this pass built is the screen's now; the one it replaced
         // goes (as `commitPendingNode` retires a committed pass's).
-                if (t.ft !== null || t.Nt !== null) GlobalQueue.et(s, false, true);
+                if (t.ft !== null || t.Tt !== null) GlobalQueue.et(s, false, true);
         s.l &= ~CONFIG_STAGED;
     }
     releaseQueues(e);
@@ -608,6 +684,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, r, u] = kept.splice(n, 5);
+        // (A store slot's node now: the one taken, or a read's since.)
+                if (reverted.has(u) && lanes.includes(l) && (!(s.l & CONFIG_SLOT_NODE) || (s = GlobalQueue.fn(s, true)))) {
+            const n = ext(s);
+            if (n.Je === null || txOf(s) === e) {
+                commitPendingNode(s);
+                n.V = t;
+                n.Ie = r;
+                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;
@@ -624,7 +719,13 @@ function laneSeam(e, n) {
     return e.V && 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;
@@ -638,7 +739,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
@@ -649,8 +752,8 @@ 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;
@@ -659,8 +762,8 @@ function laneSeam(e, n) {
     } else {
         const s = txOf(e);
         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;
+        if (s.Nt) e.ue = n; else e.T.V = n;
+        if (e.X !== undefined) e.ie = clock;
         insertSubs(e);
         laneDirty(e, s);
     }
@@ -682,7 +785,7 @@ 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;
     }
@@ -693,7 +796,7 @@ function laneSeam(e, n) {
 /** 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.de;
+    return n !== 0 && n < e.T.Ie;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
@@ -702,7 +805,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.de > n && e.ae === clock) n = e.T.de;
+        if (e.T !== null && e.T.Ie > n && e.ie === clock) n = e.T.Ie;
     }
     return n;
 }
@@ -717,33 +820,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.V && 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.Ye.length; e++) {
+            const s = t.Ye[e];
+            if (s === n || !(s.m & STATUS_PENDING) || s.T.Je !== 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?.Je;
+    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?.Je || (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?.it === 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?.V ? l._parent?.it === 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.V && t.i) t.R |= REACTIVE_LANE_DIRTY;
+                if (l?.V && 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?.V && t.R & REACTIVE_PROBE_UNANSWERED) {
+            if (isThenable(t.T?.Ee)) {
+                if (!blocked(e)) continue;
+                t.T.rt = 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.rt = s.T.Ee;
+            if (e?.it && n.indexOf(e.it) === -1) n.push(e.it);
+        }
         enqueueSub(t);
-        if (l != null && l.V && n.indexOf(l) === -1) n.push(l);
+        if (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 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?.it === 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).
@@ -753,9 +923,39 @@ 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?.rt;
+    if (!n || e.R & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP)) return false;
+    e.T.rt = 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.xe = e => {
     const n = [];
@@ -769,4 +969,4 @@ GlobalQueue.xe = e => {
 
 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 };