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

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { notifyStatus, releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, stageError, settlePendingSource, releaseIfSettledUnobserved, settleErroredDependents } from "./async.js";
 
-import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, CONFIG_STAGED_ERROR, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, NewSet, STATUS_NONE } from "./constants.js";
+import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, CONFIG_STAGED_ERROR, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_ASYNC, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, NewSet, STATUS_NONE } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -10,7 +10,7 @@ import { insertIntoHeap, deleteFromHeap, insertIntoHeapHeight, enqueueSub, markN
 
 import { inheritId, linkChild, disposeChildren, markDisposal } from "./owner.js";
 
-import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneStageHook, passLane, laneReadHook, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, deferZombie } from "./scheduler.js";
+import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneStageHook, passLane, laneReadHook, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, guessing, holdWorkHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneServedHook, latestOpened, stagedReaders, laneSeamsHook, deferZombie } from "./scheduler.js";
 
 // The heap's per-node step. A tracked effect's heap visit is its compute
 // phase — empty, like a user effect whose compute reads nothing — and hands
@@ -161,20 +161,41 @@ function recompute(e, t = false) {
     // Restored at the end, after this pass's staging and runs have been
     // routed.
     // Lanes exist only with the lane engine installed (`laneStageHook`): a
-    // bundle without it seats every pass on mainline, and folds the seat away.
+    // bundle without it seats every pass on mainline (`passLane` is never set)
+    // and folds the seat, and its restores, away.
         const E = passLane;
     // The mount a first pass belongs to: its creator's lane, or the one its
     // creator's own mount came from — a render effect a verdict lane's mount's
     // content creates is that mount's too (#4166). Lanes only, like the seat.
         const s = laneRoot;
     const i = laneStageHook && (laneRoot = t && (E || s));
-    setPassLane(!laneStageHook ? null : (e.R & REACTIVE_LANE_DIRTY || (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.T?.Re?.P ? e.T.Re : // Loose `!=`: false with no creator lane (undefined == null).
+    if (laneStageHook) setPassLane((e.R & REACTIVE_LANE_DIRTY || (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.T?.Re?.P ? e.T.Re : // Loose `!=`: false with no creator lane (undefined == null).
     t && E?._parent.Pe != E && creatorPass(context)?.R & REACTIVE_RECOMPUTING_DEPS ? E : null);
     // CARVE 2: lane posture resolution (OPTIMISTIC_DIRTY, derived-override
     // re-derivation, lane adoption through deps) went with the optimistic engine.
-        if (!t) {
+    // An error a pass staged, which this pass replaces (`valueChanged`).
+        const l = e.l & CONFIG_STAGED_ERROR;
+    if (!t) {
         deleteFromHeap(e, dirtyQueue);
+        // A pending flight is the transition's own work (#3884), and so is a
+        // held async memo's re-run with no verdict window of its own (D-25,
+        // `holdWork`): a pass that takes no verdict role this time. A probe on
+        // an earlier pass left CONFIG_VERDICT, and a frame read here would serve
+        // the committed screen, settle the flight and drop the hold — a
+        // superseding write's verdict would depend on that probe. Cleared for
+        // this pass, before the flight it judges by is superseded; a probe in
+        // the body re-stamps it after the plain reads. Not an effect: it has no
+        // flight of its own (its pending is a source's), and a verdict memo's
+        // change may have just made it a verdict reader (`laneDirty`). Only a
+        // build with the lane engine (`laneStageHook`; verdict.ts imports it)
+        // ever sets CONFIG_VERDICT: without it the line folds away.
+                if (laneStageHook && !n && (e.m & STATUS_PENDING || (e.l & (CONFIG_ASYNC | CONFIG_HELD)) === (CONFIG_ASYNC | CONFIG_HELD))) e.l &= ~CONFIG_VERDICT;
         if (e.T !== null) {
+            // The seam's re-derive runs with the parked flight still current; any
+            // later pass asks its own question (`_parked`; only the lane engine
+            // parks one).
+            const t = laneStageHook && e.T.He;
+            if (t && t !== e.T.Ee) e.T.He = undefined;
             e.T.Ee = null;
             // Supersede is where an iterator flight dies (#3122): close it now.
             // Idempotent with the cleanup-channel close.
@@ -193,13 +214,7 @@ function recompute(e, t = false) {
         // A).
         // A boundary's structure (CONFIG_FRAME) is the frame like a render
         // effect: it publishes mainline outside its transaction's flush (#4283).
-        // A pending flight is the transition's own work (#3884). A probe on an
-        // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
-        // committed screen, settle the flight and drop the hold — a superseding
-        // write's verdict would depend on that probe. Cleared for this pass; a
-        // probe in the body re-stamps it after the plain reads.
-                if (e.m & STATUS_PENDING) e.l &= ~CONFIG_VERDICT;
-        if (e.l & CONFIG_HELD) {
+                if (e.l & CONFIG_HELD) {
             const t = txOf(e);
             // Held by a blocked lane: the frame joins nothing — a lane never holds
             // a sync write (#3460). The pass is the lane's if it reads the lane's
@@ -216,8 +231,12 @@ function recompute(e, t = false) {
                 // children die below (`disposeChildren`). The landing re-derives a
                 // fresh held frame for the reveal (`_reruns`).
                 // Not held any more, whichever frame reader it is: its readers read
-                // the value this pass publishes.
-                e.ie = NOT_PENDING;
+                // the value this pass publishes — those that read the staging it
+                // supersedes re-derive, even when it publishes the committed value
+                // back (no change to notify them by): their held runs carry the
+                // superseded frame, and the landing would apply them (#4378).
+                if (e.ue !== NOT_PENDING) insertSubs(e);
+                e.ue = NOT_PENDING;
                 e.l &= ~CONFIG_HELD;
             }
         }
@@ -235,57 +254,59 @@ function recompute(e, t = false) {
             deferReleases(o = []);
             disposeChildren(e);
             deferReleases(t);
-        } else if (e.pe !== null || e.He !== null) parkChildren(e);
+        } else if (e.pe !== null || e.ke !== null) parkChildren(e);
         // An error a pass staged (D-41) is replaced by this pass's answer: a
         // value, a flight, or an error of its own (#4109, #4145).
                 if (e.l & CONFIG_STAGED_ERROR) {
-            e.ie = NOT_PENDING;
+            e.ue = NOT_PENDING;
             e.l ^= CONFIG_STAGED_ERROR;
         }
     }
-    const l = !!(e.m & STATUS_UNINITIALIZED);
+    const r = !!(e.m & STATUS_UNINITIALIZED);
     // Capture both error and pending status before the compute clears them.
     // A conditional can drop its pending source and recover to an unchanged
     // value, leaving blocked dependents outside that source’s settle walk.
-        const r = e.m & STATUS_ERROR ? e.T?.U : undefined;
-    const u = (e.m & STATUS_PENDING) !== 0;
-    const a = u ? e.T?.fe : undefined;
+        const a = e.m & STATUS_ERROR && e.T?.U;
+    const _ = (e.m & STATUS_PENDING) !== 0;
+    const u = _ && e.T?.se;
     // Pending SOURCE-hood, captured before the compute clears status: a node
     // whose own flight parked dependents self-registers in _pendingSources
     // (notifyStatus, isSource). If this recompute supersedes that flight and
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const _ = e.T?.fe?.has(e);
+        const I = e.T?.se?.has(e);
     // D-41: this pass's error is staged, not published (`stageError`).
-        let I = false;
+        let N = false;
     // A19 exc. 2: a `refresh()` re-asks the question already answered — quiet
     // for the verdict — unless the question in flight is a new one, which the
     // re-ask does not launder (a poll during a quiet confirm stays quiet).
-        const N = (e.R & REACTIVE_REASK) !== 0 && !(e.m & STATUS_PENDING && e.T !== null && !e.T.Ve);
-    const f = context;
+    // Nor a guess's new question whose answer is still held (#4336: an
+    // action's refresh after an outside input change has not committed it).
+        const f = (e.R & REACTIVE_REASK) !== 0 && !((e.m & STATUS_PENDING || guessing && e.ue !== NOT_PENDING) && e.T !== null && !e.T.Ve);
+    const T = context;
     context = e;
     e._ = null;
-    e.Ne++;
+    e.de++;
     // REACTIVE_ZOMBIE is position: it says the node sits on its owner's parked
     // frame, and the splice/reawaken paths key off it. A zombie reruns for
     // live writes until the commit that disposes it, so every per-pass wipe
     // — here, the finally below, updateIfNecessary — carries it (#3543).
         e.R = REACTIVE_RECOMPUTING_DEPS | e.R & (REACTIVE_ZOMBIE | REACTIVE_REASK);
-    e.Se = clock;
+    e.ie = clock;
     // The pass's previous value: its staging, else a lane node's lane value
     // when it has one (lanes.ts), else the committed one.
-        let T = e.ie !== NOT_PENDING ? e.ie : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
-    let S = e.he;
-    let c = false;
+        let S = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
+    let c = e.he;
+    let A = false;
     // L2: did this pass read the future (REACTIVE_JOINED, set by read) — or,
     // a lane's mount, a staging of this flush (#3851, #4166)?
-        let A = false;
-    let R = tracking;
+        let R = false;
+    let C = tracking;
     tracking = true;
     try {
         if (!false && e.l & CONFIG_SYNC) {
-            T = e.X(T);
+            S = e.X(S);
             if (e.T !== null) e.T.Ee = null;
             e.ce = false;
         } else {
@@ -293,12 +314,15 @@ function recompute(e, t = false) {
             // (with the commit as setter): its undefined return is not a sync
             // answer, and the outer handleAsync must not clobber the registration.
             const t = e.T?.Ee;
-            const n = e.X(T);
+            const n = e.X(S);
             const o = typeof n === "object" && n !== null;
             const E = e.T?.Ee !== t;
-            T = E || !o ? n : handleAsync(e, n);
+            S = E || !o ? n : handleAsync(e, n);
             if (!E && !o) {
-                if (e.T !== null) e.T.Ee = null;
+                if (e.T !== null) {
+                    e.T.Ee = null;
+                    if (holdWorkHook) e.l &= ~CONFIG_ASYNC;
+                }
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight clears when its own handleAsync lands.
@@ -312,6 +336,10 @@ function recompute(e, t = false) {
                 if (e.m !== 0 || e.T !== null) clearStatus(e, t);
     } catch (t) {
         const n = t instanceof NotReadyError;
+        // An error answers, and so does a loading window's unready read (D-25,
+        // verdict.ts `holdWork`): no flight is its own. A pass left pending
+        // keeps the last answer's. (Kept by the verdict engine alone.)
+                if (holdWorkHook && (!n || e.ce)) e.l &= ~CONFIG_ASYNC;
         if (n && e.ce) {
             // Loading window with an unready sync dependency: register for the
             // source's settle (the settlePendingSource walk runs off
@@ -324,12 +352,12 @@ function recompute(e, t = false) {
         } else {
             // D-41: a pass of a held node, or one that read a staging of this
             // flush, stages its error (`stageError`).
-            if (n || !(I = stageError(e, t, true))) {
-                if (n) ext(e).se = true;
+            if (n || !(N = stageError(e, t, true))) {
+                if (n) ext(e).fe = true;
                 notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t);
                 // The replacement source is fully propagated now. If no new flight
                 // re-owned self, retire the superseded flight and its dependent copies.
-                                if (n && _ && !e.T?.Ee) settlePendingSource(e);
+                                if (n && I && !e.T?.Ee) settlePendingSource(e);
             }
             // A re-park drops what the earlier pass carried (#3456): a source this
             // pass no longer reaches — its branch switched, or a fresh flight
@@ -340,25 +368,29 @@ function recompute(e, t = false) {
             // re-park twin of the unchanged-value recovery sweep below; dependents
             // with another path keep the source (retryReaches). A staged error
             // answered what the pass carried: the same.
-                        if ((n || I) && a) for (const t of a) if (t !== e && !e.T?.fe?.has(t)) settlePendingSource(e, t);
+                        if ((n || N) && u) for (const t of u) if (t !== e && !e.T?.se?.has(t)) settlePendingSource(e, t);
         }
     } finally {
-        tracking = R;
+        tracking = C;
         if (laneStageHook) laneRoot = s;
         // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
         // landed beneath this pass on a link it had already validated. The wipe
         // below must not key off DIRTY/CHECK — the read-time pull protocol
         // (markNode(c) in read()) marks the running node as part of ordinary
         // bookkeeping, and those marks are correctly discarded here.
-                c = (e.R & REACTIVE_MISSED_WAKE) !== 0;
+                A = (e.R & REACTIVE_MISSED_WAKE) !== 0;
         // A mount's staged read joins it — except a nested derivation left
         // pending: no render effect reaches it yet, so it holds nothing and
-        // reaches no boundary (Reader, #4203). A reader that does is caught.
-                A = !!(e.R & (i && (E || n || !(e.m & STATUS_PENDING)) ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
+        // reaches no boundary (Reader, #4203), whatever it read — a memo the
+        // mount bore held over the staging included, at any depth (#4340). A
+        // reader that does is caught.
+                R = !!(e.R & (i ? E || n || !(e.m & STATUS_PENDING) ? REACTIVE_JOINED | REACTIVE_STAGED_READ : 0 : REACTIVE_JOINED));
         // A verdict reader is one for as long as it probes, or reads a memo
         // that does (`read`): a pass that did neither (REACTIVE_PROBED, the same
-        // bit) is an ordinary derivation again.
-                e.l = e.l & ~CONFIG_VERDICT | e.R & REACTIVE_PROBED;
+        // bit) is an ordinary derivation again. Its async posture is the
+        // verdict engine's to keep (CONFIG_ASYNC, verdict.ts `holdWork`, D-25).
+        // (Only the verdict engine probes: without it the line folds away.)
+                if (observeFlightHook) e.l = e.l & ~CONFIG_VERDICT | e.R & REACTIVE_PROBED;
         // REACTIVE_DISPOSED survives too (#3621): the pass may have disposed its
         // own owner (a memo calling its root's `dispose()`, a cleanup doing so
         // #3601/#3606), and `disposeChildren` set the flag on this node
@@ -367,12 +399,12 @@ function recompute(e, t = false) {
         // this pass's verdict for the landing; the next pass's wipe at the top
         // clears it.
                 e.R = e.R & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED | REACTIVE_FRAME_READ | REACTIVE_STAGED_READ | REACTIVE_LANE_READ | REACTIVE_SCREEN_READ | REACTIVE_PROBE_UNANSWERED) | (t ? e.R & REACTIVE_SNAPSHOT_STALE : 0);
-        context = f;
+        context = T;
         if (o) for (const e of o) releaseIfSettledUnobserved(e);
         // A19 exc. 2: a pass that went pending on a `refresh()` re-asks the
         // question already answered — quiet for the verdict; any other pending
         // pass is a new question. Settled, there is nothing to classify.
-                if (e.T !== null) e.T.Ve = N && (e.m & STATUS_PENDING) !== 0;
+                if (e.T !== null) e.T.Ve = f && (e.m & STATUS_PENDING) !== 0;
     }
     // A node that died during its own pass (#3621) is dead at the end of it,
     // and the pass is void. Its owner's teardown already unlinked its deps,
@@ -388,7 +420,7 @@ function recompute(e, t = false) {
         if (e.R & REACTIVE_DISPOSED) {
         clearDeps(e);
         if (e.T !== null) e.T.Ee = null;
-        setPassLane(E);
+        if (laneStageHook) setPassLane(E);
         return;
     }
     // The lane this pass is work of, if any: its seat (the node's, its
@@ -396,21 +428,25 @@ function recompute(e, t = false) {
     // seat that read none of the lane's world has left it: its result is the
     // frame's (a derivation whose branch no longer reaches the guess). A
     // guess is written, not derived — it never leaves this way.
-        let C = !laneStageHook ? null : passLane;
+        let O = !laneStageHook ? null : passLane;
     // Listed before its staging, a pending pass included (the lane's own
     // flight is the lane's); false: the pass left the lane (lanes.ts).
-        const d = !!e.T?.U || I;
-    if (laneStageHook && C !== null) {
-        if (laneStageHook(e, C, t, d)) setPassLane(C); else C = null;
+        const d = !!e.T?.U || N;
+    if (laneStageHook && O !== null) {
+        if (laneStageHook(e, O, t, d)) setPassLane(O); else O = null;
     }
     if (!d) {
         // INV-11 (#3330): the equality gate compares against the slot this run
         // publishes to — the staged `_pendingValue` when staged; a lane node's
         // lane value (a node entering the lane this pass has none yet — its
         // committed value, `laneStage` having voided a frame staging).
-        const o = e.ie !== NOT_PENDING ? e.ie : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
+        const o = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
         // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
-                const E = !n && l || !!e.T?.Ie || !isSame(e, o, T);
+        // A pass replacing an error this node staged is a new answer, even the
+        // committed value (D-41: a recovery equal to the last good value is a
+        // change): the slot it publishes to held the error, and the readers that
+        // derived from it — `latest()` throws it — re-derive (#4403).
+                const E = !n && r || !!e.T?.Te || !!l || !isSame(e, o, S);
         // Effects use `_equals: false` (no per-effect closure). The side effects that
         // the equals closure used to perform — flagging the effect dirty and enqueueing
         // its runner — happen here instead. `!create` matches the previous `initialized`
@@ -419,16 +455,16 @@ function recompute(e, t = false) {
                 if (n && E && 
         // A stale reader of a lane (REACTIVE_SCREEN_READ) that computed what it
         // last applied owes no run (lanes.ts).
-        !(e.R & REACTIVE_SCREEN_READ && !e.Ae && Object.is(e.ke, T)) && 
+        !(e.R & REACTIVE_SCREEN_READ && !e.Ae && Object.is(e.ge, S)) && 
         // A re-staging pass owes no run: the commit replays the effect (#3802).
-        e.ie === NOT_PENDING) {
+        e.ue === NOT_PENDING) {
             e.Ae = !e.T?.U;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
             // Lane work's run is the lane's (released at its reveal) — a first
             // pass under a lane too: `effect()` skips the synchronous first run of
             // a lane's node.
-                        if (!t || C !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.K.bind(null, e), C);
+                        if (!t || O !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.q.bind(null, e), O);
         }
         // Lanes. A written guess's own pass from the frame: its source
         // recomputed it — the truth (A18: "the source is whatever recomputes the
@@ -437,7 +473,7 @@ function recompute(e, t = false) {
         // only a correction: an equal truth re-runs nothing (lanes.ts). (As the
         // lane's own work the lane judged it — `laneStage`.)
         // (The hook first: a build without lanes folds the arm away.)
-                if (laneOutcomeHook && !t && C === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, T, d)) ; else if (d) ; else if (E) {
+                if (laneOutcomeHook && !t && O === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, S, d)) ; else if (d) ; else if (E) {
             // L2: a first pass is born held — staged, committed with the
             // transaction, its effect's first run the landing's (A29; `effect()`
             // skips the synchronous first run on a staged value) — when the flush
@@ -454,15 +490,15 @@ function recompute(e, t = false) {
             // pass that runs before anything joins: the pass's input, not a verdict
             // after it. An effect still carrying an uncommitted staged value
             // re-stages: the commit applies the latest pass, not the born-held one.
-            if (C !== null) {
+            if (O !== null) {
                 // Lane work: the lane's value — into the slot while the lane has not
                 // revealed (its reveal shows it), as its staging once it has (the
                 // next reveal promotes it; the screen keeps the revealed value). An
                 // effect's value slot is private: the run the lane holds is what
                 // shows it — unless the effect was born held, whose first run is the
                 // commit's (A29): it re-stages, as below.
-                if (n && e.ie === NOT_PENDING) e.le = T; else if (n || C.ge) e.ie = T; else e.T.P = T;
-            } else if (t ? !((flushTransaction !== null || passTx !== null) && (A || creatorPass(f)?.R & REACTIVE_JOINED)) : n && e.ie === NOT_PENDING) {
+                if (n && e.ue === NOT_PENDING) e.le = S; else if (n || O.Ue) e.ue = S; else e.T.P = S;
+            } else if (t ? !((flushTransaction !== null || passTx !== null) && (R || creatorPass(T)?.R & REACTIVE_JOINED)) : n && e.ue === NOT_PENDING) {
                 // A first pass publishes directly. So does an effect: its value slot
                 // is private (only its own run reads it), and the staging round-trip
                 // (queuePendingNode + commitPendingNodes) paid per effect on the
@@ -473,9 +509,13 @@ function recompute(e, t = false) {
                 // sources commit) must see the fresh value while PLAIN reads stay
                 // committed until flush (#3009 purity). The pending round-trip is
                 // that separation; it cannot be skipped on any path a pull can reach.
-                e.le = T;
+                e.le = S;
             } else {
-                e.ie = T;
+                e.ue = S;
+                // D-39: a staged recovery keeps the error it replaces the display
+                // until it commits (`commitPendingNode`), as a write over one does
+                // (`setMemo`).
+                                if (a) e.T.Te = a;
                 // Born held: in the transaction from birth, so a read of it this
                 // tick is a read of its world (the mount-during-a-hold case), not
                 // only after the seam parks it.
@@ -501,9 +541,9 @@ function recompute(e, t = false) {
                         if (e.o !== null) {
                 insertSubs(e);
                 // Lane work re-staged: the lane's members re-derive as its work.
-                                if (C !== null) laneDirty(e, C);
+                                if (O !== null) laneDirty(e, O);
             }
-        } else if (e.he != S) {
+        } else if (e.he != c) {
             for (let t = e.o; t !== null; t = t.t) insertIntoHeapHeight(t.u, dirtyQueue);
         }
         // Silent recovery: errored → unchanged value fires no notification, but
@@ -512,15 +552,15 @@ function recompute(e, t = false) {
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
                 if (!E && !e.T?.U) {
-            if (r !== undefined) settleErroredDependents(e, r);
+            if (a) settleErroredDependents(e, a);
             // Self-registration (this node's own superseded flight) is the #3181
             // sweep's business below — retiring it here too would walk twice.
-                        if (a) for (const t of a) if (t !== e) settlePendingSource(e, t);
+                        if (u) for (const t of u) if (t !== e) settlePendingSource(e, t);
         }
         // #3181: a synchronous settle supersedes the old landing callback, so
         // recompute owns its pending-source sweep. An uninitialized node without
         // a replacement source still has no truth to reveal and must stay parked.
-                if (_ && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
+                if (I && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
     }
     // A first pass that went pending where the born-held arm would have held
     // its value (it read a held node, or a verdict lane's mount read a staging,
@@ -530,7 +570,7 @@ function recompute(e, t = false) {
     // hold's commit (D-12) — but the hold does not wait for it: its only
     // readers are behind the fallback (`_hidden`; F-4, #3540). A boundary
     // re-armed by `on` owns what it collects outright (D-14): not held.
-        if (t && C === null && A && e.m & STATUS_PENDING) {
+        if (t && O === null && R && e.m & STATUS_PENDING) {
         const t = flushTransaction ?? passTx;
         if (t && !t.P && freshHook?.(e) !== CAUGHT_REARMED) holdNode(e, t);
     }
@@ -551,7 +591,7 @@ function recompute(e, t = false) {
     // kept at a park — one spurious recompute at most). A creation pass and a
     // tracked effect trim now: their frames are replaceable like a direct
     // commit, and a tracked effect's spurious run would be user-visible.
-        if (!e.T?.U && e.ie === NOT_PENDING && !(n && e.Ae)) {
+        if (!e.T?.U && e.ue === NOT_PENDING && !(n && e.Ae)) {
         if (t || n === EFFECT_TRACKED) trimStaleDeps(e); else heldTrim(e);
     }
     // A staged value, a parked frame (L2: the commit retires it), or status the
@@ -559,18 +599,18 @@ function recompute(e, t = false) {
     // node for this flush's commit. A first pass queues only when pending or
     // born held: otherwise its value published directly. A queued pass's
     // children are uncommitted (CONFIG_STAGED) until that commit.
-        if (e.ie !== NOT_PENDING || e.T !== null && (e.T.Ue !== null || e.T.me !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
+        if (e.ue !== NOT_PENDING || e.T !== null && (e.T.me !== null || e.T.Le !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
         e.l |= CONFIG_STAGED;
         // Lane work is the lane's to reveal (its seam), not this flush's commit.
-                if (C === null) queuePendingNode(e);
+                if (O === null) queuePendingNode(e);
     }
-    setPassLane(E);
+    if (laneStageHook) setPassLane(E);
     // Missed-wake reschedule (see the finally above): values this pass read
     // before the nested commit are stale, so run again now that the heap will
     // accept the node. Equality gates stop same-value landings from cascading,
     // and a re-run only latches again if another nested commit changes a dep
     // beneath it — convergent unless deps genuinely keep changing.
-        if (c) {
+        if (A) {
         enqueueSub(e);
         schedule();
     }
@@ -595,7 +635,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.R & REACTIVE_DIRTY || e.T?.U && e.Se < clock && !e.T?.Ee) {
+    if (e.R & REACTIVE_DIRTY || e.T?.U && e.ie < clock && !e.T?.Ee) {
         recompute(e);
     }
     // The guard above refused an already-disposed node; the recompute it just
@@ -625,30 +665,30 @@ function computed(e, t) {
     // plus the slots.
         const E = {
         id: inheritId(t, n, context),
-        l: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.ue ? CONFIG_NO_SNAPSHOT : 0) | (t?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        xe: t?.equals ?? isEqual,
-        He: null,
+        l: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.ae ? CONFIG_NO_SNAPSHOT : 0) | (t?.xe ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ye: t?.equals ?? isEqual,
+        ke: null,
         A: context?.A ?? defaultContext,
-        ye: 0,
+        be: 0,
         X: e,
         le: o ? t.loadingValue : undefined,
         he: 0,
-        be: undefined,
+        ve: undefined,
         We: null,
         C: null,
         _: null,
-        Ne: 0,
+        de: 0,
         o: null,
-        ve: null,
+        Ze: null,
         _parent: context,
         Ge: null,
-        Ze: null,
+        we: null,
         pe: null,
         R: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
         m: o ? 0 : STATUS_UNINITIALIZED,
-        Se: clock,
-        ie: NOT_PENDING,
+        ie: clock,
+        ue: NOT_PENDING,
         Me: -1,
         ce: o,
         // Cold machinery (async slots) lives one hop away in the lazily-allocated extension — the core literal MUST
@@ -656,7 +696,7 @@ function computed(e, t) {
         // allocation spills to a backing store and creation cost ~4x's).
         T: null
     };
-    if (t?.unobserved) ext(E).we = t.unobserved;
+    if (t?.unobserved) ext(E).Ye = t.unobserved;
     setupComputedNode(E, t);
     return E;
 }
@@ -667,22 +707,22 @@ function computed(e, t) {
  * Never call ext() just to store a field's default. */ function ext(e) {
     return e.T ??= {
         Ee: null,
-        ae: null,
+        Se: null,
         U: undefined,
-        se: undefined,
         fe: undefined,
-        we: undefined,
+        se: undefined,
+        Ye: undefined,
         De: undefined,
-        Ue: null,
         me: null,
+        Le: null,
         Re: null,
         Ve: false,
         je: NOT_PENDING,
         Be: -1,
-        Te: 0,
+        Ie: 0,
         P: NOT_PENDING,
         I: 0,
-        Ie: undefined
+        Te: null
     };
 }
 
@@ -762,6 +802,9 @@ function computed(e, t) {
     // head), and the pass may then read a guess and become the lane's.
         if (E === flushTransaction && !o && !n || bornInto(e, E)) return false;
     staleReader(e, E);
+    // Lane work or a verdict reader no longer waits on `el`'s flight (lanes.ts
+    // `laneServed`, A15).
+        if (o || n) laneServedHook(e, t);
     return true;
 }
 
@@ -775,7 +818,14 @@ function computed(e, t) {
 
 /** The computed whose pass a creation under `owner` belongs to (a root's is
  * its nearest computed ancestor's), or null outside every pass. */ function creatorPass(e) {
-    return e !== null && e.Qe ? e.Ye : e;
+    return e !== null && e.Qe ? e.Ke : e;
+}
+
+/** What `born` and the passes still running around `p` read — its
+ * creator's, theirs — of the future or a staging (REACTIVE_JOINED |
+ * REACTIVE_STAGED_READ): a pass created by one that did has no screen; its
+ * branch exists only in that world (#4341). */ function creatorReads(e, t) {
+    return (e = creatorPass(e._parent))?.R & REACTIVE_RECOMPUTING_DEPS ? creatorReads(e, t | e.R) : t & (REACTIVE_JOINED | REACTIVE_STAGED_READ);
 }
 
 /** L2 — park the previous pass's frame for this node's commit: the children
@@ -784,11 +834,11 @@ function computed(e, t) {
  * the frame that replaces them (`commitPendingNode`) or when the owner does. */ function parkChildren(e) {
     markDisposal(e);
     const t = ext(e);
-    t.me = e.He;
-    t.Ue = e.pe;
-    e.He = null;
+    t.Le = e.ke;
+    t.me = e.pe;
+    e.ke = null;
     e.pe = null;
-    e.ye = 0;
+    e.be = 0;
 }
 
 /**
@@ -808,36 +858,36 @@ function computed(e, t) {
         l: 
         // CONFIG_FRAME for a render effect (EFFECT_RENDER = 1; a user
         // effect's 1 << 24 is unused).
-        o << 23 | (s ? CONFIG_TRANSPARENT : 0) | (E?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (E?.sync ? CONFIG_SYNC : 0) | (E?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        xe: false,
-        He: null,
+        o << 23 | (s ? CONFIG_TRANSPARENT : 0) | (E?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (E?.sync ? CONFIG_SYNC : 0) | (E?.xe ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ye: false,
+        ke: null,
         A: context?.A ?? defaultContext,
-        ye: 0,
+        be: 0,
         X: e,
         le: undefined,
         he: 0,
-        be: undefined,
+        ve: undefined,
         We: null,
         C: null,
         _: null,
-        Ne: 0,
+        de: 0,
         o: null,
-        ve: null,
+        Ze: null,
         _parent: context,
         Ge: null,
-        Ze: null,
+        we: null,
         pe: null,
         R: REACTIVE_LAZY,
         m: STATUS_UNINITIALIZED,
-        Se: clock,
-        ie: NOT_PENDING,
+        ie: clock,
+        ue: NOT_PENDING,
         Me: -1,
         ce: false,
         Ae: false,
-        ke: undefined,
-        Ke: t,
-        qe: n,
-        Je: undefined,
+        ge: undefined,
+        qe: t,
+        Je: n,
+        ze: undefined,
         i: o,
         T: null
     };
@@ -846,7 +896,7 @@ function computed(e, t) {
     // allocation on EVERY effect at creation (an alloc + 19 field stores,
     // +23% effect creation, caught by the creation benches). Only genuinely
     // per-node channels (boundaries) live on _x.
-        if (E?.unobserved) ext(i).we = E.unobserved;
+        if (E?.unobserved) ext(i).Ye = E.unobserved;
     setupComputedNode(i, lazyOptions);
     return i;
 }
@@ -876,7 +926,7 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.We = e;
-    const n = context?.Qe ? context.Ye : context;
+    const n = context?.Qe ? context.Ke : context;
     if (context) linkChild(context, e);
     if (n) e.he = n.he + 1;
     wireExternalSourceHook?.(e);
@@ -892,13 +942,13 @@ function signal(e, t) {
     // createSignal nodes so ownerPath can locate signal subjects; null here,
     // and staying null on internal signals — one shape either way).
     const n = {
-        xe: t?.equals ?? isEqual,
-        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.ue ? CONFIG_NO_SNAPSHOT : 0),
+        ye: t?.equals ?? isEqual,
+        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.ae ? CONFIG_NO_SNAPSHOT : 0),
         le: e,
         o: null,
-        ve: null,
-        Se: clock,
-        ie: NOT_PENDING,
+        Ze: null,
+        ie: clock,
+        ue: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
@@ -907,7 +957,7 @@ function signal(e, t) {
         Me: -1,
         T: null
     };
-    if (t?.unobserved) ext(n).we = t.unobserved;
+    if (t?.unobserved) ext(n).Ye = t.unobserved;
     if (snapshotCaptureActive && !(n.l & CONFIG_NO_SNAPSHOT)) takeSnapshot(n, e);
     return n;
 }
@@ -928,17 +978,17 @@ function isEqual(e, t) {
  * and location slots (the store relabels `store.<key>` and stamps the
  * store's `loc` when the engine is installed). */ function slotSignal(e, t, n, o, E) {
     const s = {
-        xe: t,
+        ye: t,
         l: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
         le: e,
         o: null,
-        ve: null,
-        Se: clock,
-        ie: NOT_PENDING,
+        Ze: null,
+        ie: clock,
+        ue: NOT_PENDING,
         Me: -1,
         T: null,
         O: n,
-        ze: o,
+        Xe: o,
         acc: E,
         px: undefined,
         pxv: undefined
@@ -1064,7 +1114,7 @@ function setVerdict(e) {
  *   never the graph — A32).
  * False means the reader derives from the staged value.
  */ function readerSeesCommitted(e, t) {
-    return !t || e.ie === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
+    return !t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
 }
 
 /** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
@@ -1085,7 +1135,7 @@ function markUnflushedStaged() {
  * is unflushed. Exempt: promoted writes (A28 (4): a write issued inside a
  * recompute is promoted at that recompute's end — boundary and loading
  * machinery, signals declared for in-computation writes). */ function unflushedValue(e) {
-    if (globalQueue.q || e.ie === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
+    if (globalQueue.Y || e.ue === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
     // A held node (L2) carries a staged value between flushes too, but it was
     // flushed — and parked. Not an unflushed write — unless rewritten since:
     // then the flushed staging is what the world sees until the next flush.
@@ -1098,7 +1148,7 @@ function markUnflushedStaged() {
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
     const t = e.T;
     if (t.Be !== clock) {
-        t.je = e.ie;
+        t.je = e.ue;
         t.Be = clock;
         unflushedStaged = true;
     }
@@ -1146,18 +1196,19 @@ function resyncUnflushedCompanions() {
 
 function read(e) {
     let t = context;
-    if (t?.Qe) t = t.Ye;
+    if (t?.Qe) t = t.Ke;
     const n = e;
     // CARVE 1: `owner` was `el._firewall || el` — a store leaf's status,
     // height and error were read off its projection computed. (Typed loosely
     // as the `||` expression was: a signal's `_statusFlags`/`_height` read as
     // undefined and mask to 0 on every site below.)
         const o = e;
-    if (typeof n.X === "function") prepareComputed(e);
     // The verdict windows (`latest`, `isPending`; verdict.ts): one cold path,
-    // off this one, present only while a window is open.
+    // off this one, present only while a window is open. It wakes a lazy or
+    // dormant memo itself, outside the window (#4366).
         if (verdict !== null) return verdict(e, t);
-    if (!n.X && e.T?.De === undefined && !snapshotCaptureActive && (!unflushedStaged || e.ie === NOT_PENDING) && // A28, see readNodeFast
+    if (typeof n.X === "function") prepareComputed(e);
+    if (!n.X && e.T?.De === undefined && !snapshotCaptureActive && (!unflushedStaged || e.ue === NOT_PENDING) && // A28, see readNodeFast
     !(e.l & CONFIG_OVERRIDE) && // lanes: the slow path's one arm
     true) {
         if (t) {
@@ -1178,13 +1229,13 @@ function read(e) {
             }
         }
         // Committed visibility for untracked and children-forbidden readers.
-                if (!t || e.ie === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.le;
+                if (!t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.le;
         // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
         // Lane work over a folded lane (D-34), once the frame has a
         // transaction, reads the screen too.
                 if ((observeFlightHook && t.l & CONFIG_VERDICT || laneStageHook && passLane?.folded) && stagedScreen(t)) return e.le;
         stagedRead(t);
-        return e.ie;
+        return e.ue;
     }
     // Rule 3: this read serves the committed value to a render effect outside a
     // parking flush (decided after the pull below — a pull can join).
@@ -1199,7 +1250,8 @@ function read(e) {
                 // it probed inline: it reads held values as the screen and shows the
                 // verdict now. Not an effect: a render effect is a frame reader
                 // already, and a user effect's posture is its own reads'.
-                                if (!t.i) t.R |= o.l & CONFIG_VERDICT;
+                // (A verdict memo exists only with the verdict engine installed.)
+                                if (observeFlightHook && !t.i) t.R |= o.l & CONFIG_VERDICT;
             }
         }
         // L2, as in the fast block above (tracked or not). A node born into the
@@ -1225,7 +1277,7 @@ function read(e) {
         const n = e.T?.De;
         if (n !== undefined && !(o.m & STATUS_ERROR)) {
             const o = n === NO_SNAPSHOT ? undefined : n;
-            const E = e.ie !== NOT_PENDING ? e.ie : e.le;
+            const E = e.ue !== NOT_PENDING ? e.ue : e.le;
             if (E !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
             return o;
         }
@@ -1244,11 +1296,12 @@ function read(e) {
     // — unless the flight committed beneath inputs already on screen
     // (`observeFlight`), or the reader was born into the flight's transaction
     // (#4010): it has no screen, and waits on the flight with its frame.
-        if (o.m & STATUS_PENDING && !E && !(e.l & CONFIG_OVERRIDE) && !(o.m & STATUS_UNINITIALIZED)) {
+    // (A lane, and a verdict reader, exist only with their engines installed —
+    // the verdict engine imports the lane engine: without it the test folds.)
+        if (laneStageHook && o.m & STATUS_PENDING && !E && !(e.l & CONFIG_OVERRIDE) && !(o.m & STATUS_UNINITIALIZED)) {
         // A reader with no committed value yet sees the flight pending: a
         // boundary a lane mounts shows its fallback (A29's boundary exemption).
-        // (A lane, and a verdict reader, exist only with their engines installed.)
-        if (laneStageHook && passLane !== null && !(t?.m & STATUS_UNINITIALIZED)) E = true; else if (observeFlightHook && t !== null && t.l & CONFIG_VERDICT) E = observeFlightHook(t, o);
+        if (passLane !== null && !(t?.m & STATUS_UNINITIALIZED)) E = true; else if (t !== null && t.l & CONFIG_VERDICT) E = observeFlightHook(t, o);
     }
     if (o.m & STATUS_PENDING && !E) {
         // A reader landing on a pending node throws; an untracked read of an
@@ -1274,16 +1327,24 @@ function read(e) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && o.Se < clock) {
+        if (tracking && o.ie < clock) {
             recompute(o);
             return read(e);
-        } else throw o.T?.U;
+        }
+        // D-41: a staged error replacing the shown one is this flush's answer
+        // (`stageError`): a reader served the staging (`serve`) throws it, as it
+        // would read a staged value, and stages its own error with it; one
+        // served the screen throws the shown error. Thrown the shown error, a
+        // reader born this flush published it, and its readers' stale error
+        // committed after the new one (#4404).
+                if (!E && e.l & CONFIG_STAGED_ERROR) serve(e, t);
+        throw o.T?.U;
     }
-    if (E) return e.le;
-    // D-41: an untracked read reads the screen, and a shown error is on it
-    // until the answer that replaces it commits.
-        if (!t && e.T?.Ie) throw e.T.Ie;
-    const s = serve(e, t);
+    // D-41: an untracked read reads the screen, and so does a frame reader
+    // served the committed value — `serve` hands it that value as it does an
+    // untracked read — a shown error included (`throwShown`).
+        if (E || !t) throwShown(e);
+    const s = serve(e, E ? null : t);
     if (!t && typeof n.X === "function" && e.l & CONFIG_AUTO_DISPOSE && !(o.m & STATUS_PENDING) && !e.o) {
         // Deferred, not inline (#3078): an inline unobserved() here made untracked
         // reads destructive — dispose on this read, full revival recompute on the
@@ -1297,6 +1358,12 @@ function read(e) {
     return s;
 }
 
+/** D-41: a reader served the screen — an untracked read, a frame reader
+ * served the committed value, a verdict reader (`serve`) — reads a shown
+ * error there until the answer that replaces it commits. */ function throwShown(e) {
+    if (e.T?.Te) throw e.T.Te;
+}
+
 /**
  * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step
  * 6c): the value a reader `c` (null = untracked, no pass) is served from
@@ -1311,18 +1378,17 @@ function read(e) {
     // an untracked reader has nothing to serve and holds (A19 exception 1) — a
     // bookkeeping read (`spectate`) likewise, and a children-forbidden reader
     // (A32: the frame, which has nothing here).
-    if (e.ie !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
+    if (e.ue !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
     const n = t && unflushedStaged ? unflushedValue(e) : NOT_PENDING;
     if (n !== NOT_PENDING) {
         markLateLinker(t);
         return n;
     }
-    if (readerSeesCommitted(e, t)) return e.le;
-    if (observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.le;
+    if (readerSeesCommitted(e, t) || observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t) && !throwShown(e)) return e.le;
     stagedRead(t, e);
     // D-41: the staged answer is an error (`stageError`).
-        if (e.l & CONFIG_STAGED_ERROR) throw e.ie;
-    return e.ie;
+        if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
+    return e.ue;
 }
 
 /** A pass read a staging of this flush: it derives from what the flush may
@@ -1342,7 +1408,13 @@ function read(e) {
  * round (#3969: nor does it make a later lane read a re-derive, `enterLane`). */ function stagedRead(e, t) {
     if (!(t?.m & STATUS_UNINITIALIZED)) {
         e.R |= REACTIVE_STAGED_READ;
-        if (laneSeamsHook && passLane !== null) stagedReaders.push(e);
+        // A verdict reader's too when it is an effect, before the frame has a
+        // transaction (after, `stagedScreen` serves it the screen): the staging
+        // is the frame's read, and the pass re-derives once as a verdict reader
+        // if the flush parks (D-22; D-25: the probe decides the posture in either
+        // read order). A memo's is the frame's derivation either way: a memo is
+        // not a leaf (`frameRead`).
+                if (laneSeamsHook && (passLane !== null || e.i && e.l & CONFIG_VERDICT)) stagedReaders.push(e);
     }
 }
 
@@ -1356,6 +1428,14 @@ function read(e) {
  * its only value (A29). Nor has a reader born into the flush's transaction
  * (`bornInto`, #4010): its branch exists only there. */ function stagedScreen(e) {
     if (flushTransaction === null || bornInto(e, flushTransaction)) return false;
+    // A transaction only a `latest()` read opened holds nothing: the staging
+    // is the frame's read for a pass in the frame's seat, as it is before the
+    // frame has one, and the seam re-derives the pass once only if the flush
+    // parks (D-22, F-10). Lane work sees the screen (D-37). Not a pass with no
+    // value yet: its first answer is nobody's hold (D-6) and would commit the
+    // staging whether or not the frame parks — it reads the screen, and runs
+    // again at the landing.
+        if (observeFlightHook && flushTransaction === latestOpened && passLane === null && e.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED)) return !stagedReaders.push(e);
     staleReader(e, flushTransaction);
     return true;
 }
@@ -1363,7 +1443,7 @@ function read(e) {
 /** A28 (4) — written inside a recompute that runs OUTSIDE a flush (a
  * creation-time compute): promoted at that pass's end, visible to the rest of
  * the block. Cold: only contextual writes reach here. */ function notePromotedWrite(e) {
-    if (globalQueue.q || e.l & CONFIG_PROMOTED) return;
+    if (globalQueue.Y || e.l & CONFIG_PROMOTED) return;
     e.l |= CONFIG_PROMOTED;
     promotedWrites.push(e);
 }
@@ -1411,9 +1491,9 @@ function takeSnapshot(e, t) {
  *   unwinding a flush or a setter; answered "same" so nothing commits.
  * @internal
  */ function isSame(e, t, n) {
-    if (e.xe === isEqual) return t === n;
+    if (e.ye === isEqual) return t === n;
     try {
-        return e.xe && e.xe(t, n);
+        return e.ye && e.ye(t, n);
     } catch (t) {
         if (!(t instanceof NotReadyError)) return notifyStatus(e, STATUS_ERROR, t), true;
     }
@@ -1421,7 +1501,7 @@ function takeSnapshot(e, t) {
 
 function setSignal(e, t) {
     if (writeHook !== null) writeHook(e);
-    const n = e.ie === NOT_PENDING ? e.le : e.ie;
+    const n = e.ue === NOT_PENDING ? e.le : e.ue;
     if (typeof t === "function") t = t(n);
     // Lanes: a write landing on a guess is its truth (A18 — an async guess's
     // own landing), judged against the guess; one landing on a lane's
@@ -1436,7 +1516,7 @@ function setSignal(e, t) {
     // user comparator must not run against `undefined` (matches recompute).
     // D-41: a write over a shown error is a change whatever the last good
     // value was — the error leaves at its commit (`commitPendingNode`).
-        const o = !!(e.m & STATUS_UNINITIALIZED) || !!e.T?.Ie || !isSame(e, n, t);
+        const o = !!(e.m & STATUS_UNINITIALIZED) || !!e.T?.Te || !isSame(e, n, t);
     if (!o) return t;
     // A write during hydration's snapshot capture to a source that has no
     // snapshot — created BEFORE capture began (module-level state: an identity
@@ -1448,16 +1528,16 @@ function setSignal(e, t) {
     // pass reads a value the server never had. Store leaves written here are
     // plain signals and qualify the same way.
         if (snapshotCaptureActive) captureWriteSnapshot(e, n);
-    const E = e.ie !== NOT_PENDING;
+    const E = e.ue !== NOT_PENDING;
     if (!E) queuePendingNode(e);
     // A28: a held node rewritten outside a flush keeps its flushed staging
     // for every reader until the flush that carries the rewrite.
-     else if (e.l & CONFIG_HELD && !globalQueue.q) stashFlushed(e);
-    e.ie = t;
+     else if (e.l & CONFIG_HELD && !globalQueue.Y) stashFlushed(e);
+    e.ue = t;
     if (context !== null) notePromotedWrite(e);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
-        if (e.X !== undefined) e.Se = clock;
+        if (e.X !== undefined) e.ie = clock;
     // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
     // were already walked — and where nothing has recomputed or linked since
     // (epoch) — re-stages the value and stops. The walk is idempotent (subs
@@ -1498,8 +1578,8 @@ function setSignal(e, t) {
     // every later read keeps throwing the error the derivation left behind.
     // The error stays the display until the write commits (D-41).
         if (e.m & STATUS_ERROR) {
-        e.T.Ie = e.T.U;
-        notifyStatus(e, STATUS_NONE, undefined);
+        e.T.Te = e.T.U;
+        notifyStatus(e, STATUS_NONE);
     }
     t = setSignal(e, t);
     // A write replaces an error a pass staged (D-41): it is a value again.
@@ -1510,7 +1590,7 @@ function setSignal(e, t) {
         e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(e, dirtyQueue);
         schedule();
-    } else if (e.ie !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
+    } else if (e.ue !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
     return t;
 }
 
@@ -1571,4 +1651,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, joinPassAt, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };
+export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, creatorPass, creatorReads, effectStatusNotify, ext, isEqual, isSame, joinPass, joinPassAt, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };