@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/observe/core/core.js

@@ -1,10 +1,10 @@
-import { releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settlePendingSource, settleErroredDependents } from "./async.js";
+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_PLUMBING, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, REACTIVE_MANUAL_WRITE, REACTIVE_DIRTY, CONFIG_OVERRIDE, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, EFFECT_RENDER, CONFIG_VERDICT, EFFECT_TRACKED, CONFIG_STAGED, STATUS_ERROR, STATUS_PENDING, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_STAGED_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CONFIG_CHILDREN_FORBIDDEN, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER } 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_PLUMBING, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, 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, STATUS_NONE } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
-import { clearDeps, trimStaleDeps, link, dormantNodes } from "./graph.js";
+import { link, dormantNodes, clearDeps, trimStaleDeps, deferReleases, deferredReleases } from "./graph.js";
 
 import { insertIntoHeap, deleteFromHeap, insertIntoHeapHeight, enqueueSub, markNode, markHeap } from "./heap.js";
 
@@ -12,9 +12,9 @@ import { GRAPH_SIZE_WARN_AT, noteFanIn } from "./dev.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
-import { inheritId, disposeChildren, linkChild, markDisposal } from "./owner.js";
+import { inheritId, linkChild, disposeChildren, markDisposal } from "./owner.js";
 
-import { schedule, GlobalQueue, clock, txOf, flushTransaction, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, bumpNotifyEpoch, setPassLane, passLane, joinPassTx, passTx, holdNode, laneDirty, heldTrim, staleReader, stagedReaders, deferZombie } from "./scheduler.js";
+import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneReadHook, laneStageHook, passLane, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, 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
@@ -24,11 +24,11 @@ import { schedule, GlobalQueue, clock, txOf, flushTransaction, joinFuture, queue
 // render-effect callback stages its value for the next pass, but a wake pushed
 // directly into the user queue ran in the SAME pass, read the old value, and
 // nothing re-notified it when the value landed (#3291).
-GlobalQueue.et = e => {
+GlobalQueue.Ze = e => {
     if (e.i === EFFECT_TRACKED) {
         deleteFromHeap(e, dirtyQueue);
-        e.lt = true;
-        globalQueue.enqueue(EFFECT_USER, e.q);
+        e.Qe = true;
+        globalQueue.enqueue(EFFECT_USER, e.M);
     }
     // L2: a zombie's fate is the seam's — its owner's commit disposes it, or
     // the park cancels the pass (the write that dirtied it is held). It runs
@@ -36,10 +36,29 @@ GlobalQueue.et = e => {
     // owner is held in the future). Its lane's own re-staging is a live write
     // (REACTIVE_LANE_DIRTY — a lane shows ahead of any park): it runs now, as
     // the lane's work, for the reveal this seam (#3463).
-     else if (e.R & REACTIVE_ZOMBIE && !(e.R & REACTIVE_LANE_DIRTY)) deferZombie(e); else recompute(e);
+     else if (e.R & REACTIVE_ZOMBIE && !(e.R & REACTIVE_LANE_DIRTY)) deferZombie(e);
+    // A lane frame's member (parked by a lane pass, #3698) follows mainline
+    // writes only: a lane's dirty on it is cancelled — the lane's apply retires
+    // it, and the pass that replaced it already decided what that screen shows
+    // (#4137: a `<Show>` branch withdrawn by its own lane re-ran on a falsy
+    // condition).
+    // (Lanes exist only with the lane engine installed: folded away without.)
+     else if (laneStageHook && e.R & REACTIVE_ZOMBIE && laneFrameMember(e)) {
+        deleteFromHeap(e, dirtyQueue);
+        e.R &= -65540;
+    } else recompute(e);
 };
 
-GlobalQueue.st = disposeChildren;
+/** The zombie's frame was parked by lane work: the nearest non-zombie owner
+ * (the one whose pass parked it) carries a lane's derived value — or, an
+ * effect (no lane value: `laneStage`), is listed in a lane (an `insert()`
+ * hole's render effect). */ function laneFrameMember(e) {
+    let t = e._parent;
+    while (t.R & REACTIVE_ZOMBIE) t = t._parent;
+    return (t.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE || t.i && t.T?.Je?.V;
+}
+
+GlobalQueue.et = disposeChildren;
 
 let tracking = false;
 
@@ -47,11 +66,15 @@ let context = null;
 
 let snapshotCaptureActive = false;
 
+/** The lane at the root of the running chain of first passes: the lane whose
+ * pass created the chain's first node (a mount), inherited by every first
+ * pass nested under it, whose seats are mainline (`recompute`, #4166). */ let laneRoot;
+
 let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.Et) return true;
+        if (e.ot) return true;
         e = e._parent;
     }
     return false;
@@ -63,34 +86,34 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.Et = true;
+    e.ot = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.Et = false;
+    e.ot = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.sn;
+    let t = e.ze;
     while (t) {
-        if (t.Et) {
-            t = t.rn;
+        if (t.ot) {
+            t = t.Xe;
             continue;
         }
-        if (t.re) {
+        if (t.X) {
             const e = t;
-            e.u &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            e.l &= ~CONFIG_IN_SNAPSHOT_SCOPE;
             if (e.R & REACTIVE_SNAPSHOT_STALE) {
                 e.R &= ~REACTIVE_SNAPSHOT_STALE;
                 e.R |= REACTIVE_DIRTY;
-                if (dirtyQueue.ut > e.it) dirtyQueue.ut = e.it;
+                if (dirtyQueue.st > e.Et) dirtyQueue.st = e.Et;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.rn;
+        t = t.Xe;
     }
 }
 
@@ -101,8 +124,8 @@ function clearSnapshots() {
             // pre-initialized to undefined (see ext()), and every reader tests
             // `!== undefined` — assign, don't `delete`: deleting a field pushes the
             // object to dictionary mode for every later read of every field.
-            const t = e.m;
-            if (t != null) t.ot = undefined;
+            const t = e.T;
+            if (t != null) t.lt = undefined;
         }
         snapshotSources = null;
     }
@@ -113,6 +136,7 @@ function recompute(e, t = false) {
     // §12d: any recompute can clean a marked subscriber — invalidate skips.
     bumpNotifyEpoch();
     const n = e.i;
+    let o;
     // Lanes (plan sec. 28): the seat of a pass is its node's. A node carrying a lane's
     // derived value runs as the lane's whoever dirtied it — a sync write, a
     // boundary reset, a frame rerun — so its children and its result are the
@@ -128,23 +152,30 @@ function recompute(e, t = false) {
     // derivation's pass into the lane (`read`); a leaf's never moves.
     // Restored at the end, after this pass's staging and runs have been
     // routed.
-        const l = passLane;
-    setPassLane((e.R & REACTIVE_LANE_DIRTY || (e.u & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.m?._t?.Z ? e.m._t : // Loose `!=`: false with no creator lane (undefined == null).
-    t && l?._parent.rt != l && (creatorPass(context)?.R ?? 0) & REACTIVE_RECOMPUTING_DEPS ? l : null);
+    // Lanes exist only with the lane engine installed (`laneStageHook`): a
+    // bundle without it seats every pass on mainline, and folds the seat away.
+        const s = 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 E = laneRoot;
+    const l = laneStageHook && (laneRoot = t && (s || E));
+    setPassLane(!laneStageHook ? null : (e.R & REACTIVE_LANE_DIRTY || (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.T?.Je?.V ? e.T.Je : // Loose `!=`: false with no creator lane (undefined == null).
+    t && s?._parent.it != s && creatorPass(context)?.R & REACTIVE_RECOMPUTING_DEPS ? s : null);
     // Attribution hook: fired before this run touches the dep list — `_deps`
     // still holds the previous run's links (the subscriptions that could have
     // triggered this run, and the baseline for the engine's subscription diff).
-        let s = false;
+        let i = false;
     {
-        e.en = 0;
+        e.Ve = 0;
         if (attrHooks !== null) attrHooks.recomputeStart(e, t);
     }
     // CARVE 2: lane posture resolution (OPTIMISTIC_DIRTY, derived-override
     // re-derivation, lane adoption through deps) went with the optimistic engine.
         if (!t) {
         deleteFromHeap(e, dirtyQueue);
-        if (e.m !== null) {
-            e.m.De = null;
+        if (e.T !== null) {
+            e.T.Se = null;
             // Supersede is where an iterator flight dies (#3122): close it now.
             // Idempotent with the cleanup-channel close.
                         releaseFlightTeardown(e);
@@ -156,23 +187,32 @@ function recompute(e, t = false) {
         // joins all the same. Not a render effect (rule 3): it is the frame.
         // Re-run outside its transaction's flush it publishes mainline — the
         // value it staged there is superseded (`frameRead` remembers it for the
-        // landing). A frame born into the transaction (uninitialized: never run,
-        // A29) keeps staging: live writes keep it current, it effects at the
-        // swap (ruling A).
-                if (e.u & CONFIG_HELD) {
+        // landing). A frame born into the transaction (`bornInto`: never run,
+        // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
+        // staging: live writes keep it current, it effects at the swap (ruling
+        // A).
+        // 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) {
             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
             // world (`read`), and has left it otherwise.
-                        if (t.Z) ; else if (n !== EFFECT_RENDER && !(e.u & CONFIG_VERDICT)) joinPassTx(t); else if (t !== flushTransaction && !(e.G & STATUS_UNINITIALIZED)) {
+            // An answered deferred node's re-pass is a lagging question (D-40):
+            // it joins nothing, so the write that reached it commits mainline.
+                        if (t.V || e.l & CONFIG_LAGS) ; else if (n !== EFFECT_RENDER && !(e.l & CONFIG_VERDICT)) joinPassTx(t, freshHook?.(e, e.m & STATUS_UNINITIALIZED)); else if (t !== flushTransaction && !(e.m & STATUS_UNINITIALIZED || e.l & CONFIG_HELD_FRAME)) {
                 // Published mainline, it is not held: the frame this pass builds is
                 // replaced on the spot (#3404) — this flush's commit retires the
                 // committed frame the held pass had parked (`commitPendingNode`),
                 // after the new frame's first runs, and the held pass's own
                 // children die below (`disposeChildren`). The landing re-derives a
                 // fresh held frame for the reveal (`_reruns`).
-                e.Ae = NOT_PENDING;
-                if (n === EFFECT_RENDER) e.u &= ~CONFIG_HELD;
+                e.ue = NOT_PENDING;
+                if (n === EFFECT_RENDER) e.l &= ~CONFIG_HELD;
             }
         }
         // The previous pass's frame. If that pass is still awaiting its commit
@@ -180,75 +220,91 @@ function recompute(e, t = false) {
         // frame parked before it stays parked. Otherwise they ARE the frame:
         // park them until this pass commits. Tracked effects run after the seam
         // and own nothing to park.
-                if (n === EFFECT_TRACKED || e.u & CONFIG_STAGED) disposeChildren(e); else if (e.sn !== null || e.Pe !== null) parkChildren(e);
+                if (n === EFFECT_TRACKED || e.l & CONFIG_STAGED) {
+            // A lazy node only those children read is released when this pass
+            // ends, if the pass doesn't read it again (#4142).
+            const t = deferredReleases;
+            deferReleases(o = []);
+            disposeChildren(e);
+            deferReleases(t);
+        } else if (e.ze !== null || e.rt !== 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.ue = NOT_PENDING;
+            e.l ^= CONFIG_STAGED_ERROR;
+        }
     }
-    const E = !!(e.G & 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 u = e.G & STATUS_ERROR ? e.m?.v : undefined;
-    const i = (e.G & STATUS_PENDING) !== 0;
-    const o = i ? e.m?.Se : undefined;
+        const u = e.m & STATUS_ERROR ? e.T?.F : undefined;
+    const _ = (e.m & STATUS_PENDING) !== 0;
+    const a = _ ? e.T?.fe : undefined;
     // 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.m?.Se?.has(e);
+        const I = e.T?.fe?.has(e);
+    // D-41: this pass's error is staged, not published (`stageError`).
+        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 r = (e.R & REACTIVE_REASK) !== 0 && !(e.G & STATUS_PENDING && e.m !== null && !e.m.It);
-    const a = context;
+        const f = (e.R & REACTIVE_REASK) !== 0 && !(e.m & STATUS_PENDING && e.T !== null && !e.T.ut);
+    const T = context;
     context = e;
-    e.S = null;
-    e.he++;
+    e._ = null;
+    e.Ne++;
     // 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;
-    e.Ne = clock;
-    // The pass's previous value: its staging, else the lane's value for a
-    // lane's node (lanes.ts), else the committed one.
-        let I = e.Ae !== NOT_PENDING ? e.Ae : e.u & CONFIG_OVERRIDE ? e.m.Z : e.pe;
-    let N = e.it;
-    let f = false;
-    // L2: did this pass read the future (REACTIVE_JOINED, set by read)?
-        let T = false;
-    let S = tracking;
+        e.R = REACTIVE_RECOMPUTING_DEPS | e.R & (REACTIVE_ZOMBIE | REACTIVE_REASK);
+    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 S = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.V !== NOT_PENDING ? e.T.V : e.Ie;
+    let c = e.Et;
+    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 R = false;
+    let d = tracking;
     tracking = true;
     try {
-        if (!false && e.u & CONFIG_SYNC) {
-            I = e.re(I);
-            if (e.m !== null) e.m.De = null;
-            e._e = false;
+        if (!false && e.l & CONFIG_SYNC) {
+            S = e.X(S);
+            if (e.T !== null) e.T.Se = null;
+            e.ce = false;
         } else {
             // A projection's body self-registers its flight through handleAsync
             // (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.m?.De;
-            const n = e.re(I);
-            const l = typeof n === "object" && n !== null;
-            const s = e.m?.De !== t;
-            I = s || !l ? n : handleAsync(e, n);
-            if (!s && !l) {
-                if (e.m !== null) e.m.De = null;
+            const t = e.T?.Se;
+            const n = e.X(S);
+            const o = typeof n === "object" && n !== null;
+            const s = e.T?.Se !== t;
+            S = s || !o ? n : handleAsync(e, n);
+            if (!s && !o) {
+                if (e.T !== null) e.T.Se = null;
                 // 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.
-                                e._e = false;
+                                e.ce = false;
             }
         }
         // On a status-free node clearStatus is a guaranteed no-op: every field
         // its body gates on is either _statusFlags or lives in the cold
         // extension — no extension, no status to clear. (_x from an unrelated
         // installer just makes clearStatus a cheap re-verified no-op.)
-                if (e.G !== 0 || e.m !== null) clearStatus(e, t);
+                if (e.m !== 0 || e.T !== null) clearStatus(e, t);
     } catch (t) {
         const n = t instanceof NotReadyError;
-        if (n && e._e) {
+        if (n && e.ce) {
             // Loading window with an unready sync dependency: register for the
             // source's settle (the settlePendingSource walk runs off
             // _pendingSources + _blocked alone) but take NO read-visible pending
@@ -258,11 +314,15 @@ function recompute(e, t = false) {
             // retry can actually run.
             parkLoadingWindow(e, t);
         } else {
-            if (n) ext(e).Ie = 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.m?.De) settlePendingSource(e);
+            // D-41: a pass of a held node, or one that read a staging of this
+            // flush, stages its error (`stageError`).
+            if (n || !(N = stageError(e, t, true))) {
+                if (n) ext(e).se = 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 && I && !e.T?.Se) 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
             // replaced the inputs' pending with its own — stays copied onto
@@ -270,21 +330,24 @@ function recompute(e, t = false) {
             // stops at this node (nothing left to retire) before it finds them. A
             // dependent then waits forever on a flight it has no path to. The
             // re-park twin of the unchanged-value recovery sweep below; dependents
-            // with another path keep the source (retryReaches).
-                        if (n && o) for (const t of o) if (t !== e && !e.m?.Se?.has(t)) settlePendingSource(e, t);
+            // with another path keep the source (retryReaches). A staged error
+            // answered what the pass carried: the same.
+                        if ((n || N) && a) for (const t of a) if (t !== e && !e.T?.fe?.has(t)) settlePendingSource(e, t);
         }
     } finally {
-        tracking = S;
+        tracking = d;
+        if (laneStageHook) laneRoot = E;
         // 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.
-                f = (e.R & REACTIVE_MISSED_WAKE) !== 0;
-        T = (e.R & REACTIVE_JOINED) !== 0;
-        // A verdict reader is one for as long as it probes: a pass that entered
-        // no window (REACTIVE_PROBED) is an ordinary derivation again.
-                if (!(e.R & REACTIVE_PROBED)) e.u &= ~CONFIG_VERDICT;
+                A = (e.R & REACTIVE_MISSED_WAKE) !== 0;
+        R = !!(e.R & (l ? REACTIVE_JOINED | REACTIVE_STAGED_READ : 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;
         // 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
@@ -293,11 +356,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 = a;
+        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.m !== null) e.m.It = r && (e.G & STATUS_PENDING) !== 0;
+                if (e.T !== null) e.T.ut = 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,
@@ -312,9 +376,9 @@ function recompute(e, t = false) {
     // attribution frame opened at the top is still closed.
         if (e.R & REACTIVE_DISPOSED) {
         clearDeps(e);
-        if (e.m !== null) e.m.De = null;
+        if (e.T !== null) e.T.Se = null;
         if (attrHooks !== null) attrHooks.recomputeEnd(e, t, false, false, false, false);
-        setPassLane(l);
+        setPassLane(s);
         return;
     }
     // The lane this pass is work of, if any: its seat (the node's, its
@@ -322,14 +386,14 @@ 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 = passLane;
+        let C = !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 A = !!e.m?.v;
-    if (c !== null) {
-        if (GlobalQueue.M(e, c, t, A)) setPassLane(c); else c = null;
+        const O = !!e.T?.F || N;
+    if (laneStageHook && C !== null) {
+        if (laneStageHook(e, C, t, O)) setPassLane(C); else C = null;
     }
-    if (!e.m?.v) {
+    if (!O) {
         // Observe-tier fan-in (HUGE_FAN_IN): the validated prefix [_deps.._depsTail]
         // IS this pass's distinct sources — count it here rather than per link. A
         // begin/end bracket around the pass plus a per-link increment measured
@@ -340,9 +404,9 @@ function recompute(e, t = false) {
         // this pass, or at its commit — see recompute's tail.)
         {
             let t = 0;
-            for (let n = e._; n !== null; n = n.p) {
+            for (let n = e.C; n !== null; n = n.G) {
                 t++;
-                if (n === e.S) break;
+                if (n === e._) break;
             }
             if (t >= GRAPH_SIZE_WARN_AT) noteFanIn(e, t);
         }
@@ -350,41 +414,33 @@ function recompute(e, t = false) {
         // 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 i = e.Ae !== NOT_PENDING ? e.Ae : e.u & CONFIG_OVERRIDE && e.m.Z !== NOT_PENDING ? e.m.Z : e.pe;
-        let r = false;
-        try {
-            r = !n && E || !e.tn || !e.tn(i, I);
-        } catch (t) {
-            // A throwing user comparator is an error of this node's computation.
-            // Route it through the same status path as a compute-phase throw so
-            // error boundaries contain it; otherwise it unwinds the scheduler
-            // flush, bypassing every boundary and wedging the queue (#2837).
-            notifyStatus(e, STATUS_ERROR, t);
-        }
+                const o = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.V !== NOT_PENDING ? e.T.V : e.Ie;
+        // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
+                const s = !n && r || !!e.T?.de || !isSame(e, o, S);
         // A committed derived change becomes a cause for this node's subscribers,
         // chaining their attribution through this node to the root write.
                 if (attrHooks !== null) {
-            s = r && !e.m?.v;
-            if (s && !n && !t) attrHooks.derivedChanged(e);
+            i = s && !e.T?.F;
+            if (i && !n && !t) attrHooks.derivedChanged(e);
         }
         // 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`
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
-                if (n && r && 
+                if (n && s && 
         // 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.lt && Object.is(e.Nt, I)) && 
+        !(e.R & REACTIVE_SCREEN_READ && !e.Qe && Object.is(e._t, S)) && 
         // A re-staging pass owes no run: the commit replays the effect (#3802).
-        e.Ae === NOT_PENDING) {
-            e.lt = !e.m?.v;
+        e.ue === NOT_PENDING) {
+            e.Qe = !e.T?.F;
             // 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.J ??= GlobalQueue.X.bind(null, e), c);
+                        if (!t || C !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.K.bind(null, e), C);
         }
         // Lanes. A written guess's own pass from the frame: its source
         // recomputed it — the truth (A18: "the source is whatever recomputes the
@@ -392,7 +448,7 @@ function recompute(e, t = false) {
         // confirm is a landing too — the lane's end commits it) and notifies
         // only a correction: an equal truth re-runs nothing (lanes.ts). (As the
         // lane's own work the lane judged it — `laneStage`.)
-                if (!t && c === null && e.u & CONFIG_GUESS && GlobalQueue.ft(e, I, A)) ; else if (A) ; else if (r) {
+                if (!t && C === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, S, O)) ; else if (O) ; else if (s) {
             // 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
@@ -409,15 +465,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 (C !== 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.Ae === NOT_PENDING) e.pe = I; else if (n || c.Tt) e.Ae = I; else e.m.Z = I;
-            } else if (t ? !((flushTransaction !== null || passTx !== null) && (T || l && e.R & REACTIVE_STAGED_READ || (creatorPass(a)?.R ?? 0) & REACTIVE_JOINED)) : n && e.Ae === NOT_PENDING) {
+                if (n && e.ue === NOT_PENDING) e.Ie = S; else if (n || C.It) e.ue = S; else e.T.V = 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
@@ -428,9 +484,9 @@ 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.pe = I;
+                e.Ie = S;
             } else {
-                e.Ae = I;
+                e.ue = S;
                 // 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.
@@ -440,41 +496,55 @@ function recompute(e, t = false) {
                     // (`commitPendingNode` initializes it) — every reader of it
                     // derives from the future (`read`), an untracked one throws
                     // (A19 exc. 1).
-                                        e.G |= STATUS_UNINITIALIZED;
+                                        e.m |= STATUS_UNINITIALIZED;
+                    // A boundary that has not shown content catches it: its fallback
+                    // waits for the commit (#3540). (The pass's own status clear above
+                    // dropped what the read recorded.) Not when the flush has joined
+                    // the hold and the pass is its own (not a verdict lane's mount,
+                    // #3851): the mount is part of the hold, and the boundary appears
+                    // at its commit, its fallback never seen (D-13, U-3) — a `<Show>`
+                    // mounting it over a landing included.
+                                        freshHook?.(e, !l && flushTransaction);
                 }
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.t !== null) {
+                        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 (C !== null) laneDirty(e, C);
             }
-        } else if (e.it != N) {
-            for (let t = e.t; t !== null; t = t.l) insertIntoHeapHeight(t.o, dirtyQueue);
+        } else if (e.Et != c) {
+            for (let t = e.o; t !== null; t = t.t) insertIntoHeapHeight(t.u, dirtyQueue);
         }
         // Silent recovery: errored → unchanged value fires no notification, but
         // dependents still holding the propagated error consumed their dirty flag
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // 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 (!r && !e.m?.v) {
+                if (!s && !e.T?.F) {
             if (u !== undefined) settleErroredDependents(e, u);
             // Self-registration (this node's own superseded flight) is the #3181
             // sweep's business below — retiring it here too would walk twice.
-                        if (o) for (const t of o) if (t !== e) settlePendingSource(e, t);
+                        if (a) for (const t of a) 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.G & (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,
-    // #3851) is born into that transaction without holding it: the hold never
-    // waits for a first load (the direction rule), but the answer lands into it
-    // while it is live (A29, #3800).
-        if (t && c === null && (T || l && e.R & REACTIVE_STAGED_READ) && e.G & STATUS_PENDING) ext(e).Re = flushTransaction ?? passTx;
+    // #3851) is held like it: its answer is the hold's, and the hold waits
+    // for it (A29, #3800). A boundary that has not shown content catches it
+    // and it is held all the same — its answer reveals no earlier than the
+    // 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 && R && e.m & STATUS_PENDING) {
+        const t = flushTransaction ?? passTx;
+        if (t && !t.V && freshHook?.(e) !== CAUGHT_REARMED) holdNode(e, t);
+    }
     // Dependencies are the committed frame's until it is replaced (A30, #3410):
     // a pass that staged its value leaves the previous pass's tail linked for
     // `commitPendingNode` to trim, so a write to a dependency the committed
@@ -492,29 +562,29 @@ 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.m?.v && e.Ae === NOT_PENDING && !(n && e.lt)) {
+        if (!e.T?.F && e.ue === NOT_PENDING && !(n && e.Qe)) {
         if (t || n === EFFECT_TRACKED) trimStaleDeps(e); else heldTrim(e);
     }
     // Observe: the posture the run executed under — lane work (optimistic:
     // overlay, never waste), a transaction's pass (held), or plain.
-        if (attrHooks !== null) attrHooks.recomputeEnd(e, t, s, c !== null, flushTransaction !== null || passTx !== null || (e.u & CONFIG_HELD) !== 0, e.Ae !== NOT_PENDING);
+        if (attrHooks !== null) attrHooks.recomputeEnd(e, t, i, C !== null, flushTransaction !== null || passTx !== null || (e.l & CONFIG_HELD) !== 0, e.ue !== NOT_PENDING);
     // A staged value, a parked frame (L2: the commit retires it), or status the
     // commit sweep must settle (a pending or uninitialized pass), queues the
     // 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.Ae !== NOT_PENDING || e.m !== null && (e.m.St !== null || e.m.ct !== null) || (e.G & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.G & STATUS_PENDING) !== 0)) {
-        e.u |= CONFIG_STAGED;
+        if (e.ue !== NOT_PENDING || e.T !== null && (e.T.Nt !== null || e.T.ft !== 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 (C === null) queuePendingNode(e);
     }
-    setPassLane(l);
+    setPassLane(s);
     // 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 (f) {
+        if (A) {
         enqueueSub(e);
         schedule();
     }
@@ -529,9 +599,9 @@ function updateIfNecessary(e) {
     // would resurrect it (#2983) — readers serve its last value.
     if (e.R & (REACTIVE_RECOMPUTING_DEPS | REACTIVE_DISPOSED)) return;
     if (e.R & REACTIVE_CHECK) {
-        for (let t = e._; t; t = t.p) {
-            const n = t.I;
-            if (n.re) {
+        for (let t = e.C; t; t = t.G) {
+            const n = t.S;
+            if (n.X) {
                 updateIfNecessary(n);
             }
             if (e.R & REACTIVE_DIRTY) {
@@ -539,7 +609,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.R & REACTIVE_DIRTY || e.m?.v && e.Ne < clock && !e.m?.De) {
+    if (e.R & REACTIVE_DIRTY || e.T?.F && e.ie < clock && !e.T?.Se) {
         recompute(e);
     }
     // The guard above refused an already-disposed node; the recompute it just
@@ -558,54 +628,55 @@ function computed(e, t) {
     // `in` (not `!== undefined`): an explicit `loadingValue: undefined` on a
     // `T | undefined` node is a real commit #0. The typeof guard tolerates
     // non-object option values that older call shapes force through `as any`.
-        const l = t !== null && typeof t === "object" && "loadingValue" in t;
+        const o = t !== null && typeof t === "object" && "loadingValue" in t;
     // Two literals, one per tier, selected at build time (the observe flag is
     // a literal after replacement; the untaken branch is dead code). The observe
-    // literal is the prod literal plus its `_name` slot — a slot in the
-    // boilerplate, because a post-construction `self._name = …` forces a
+    // literal is the prod literal plus its `_name` and `_loc` slots — slots in
+    // the boilerplate, because a post-construction `self._name = …` forces a
     // hidden-class transition and an out-of-object property store on EVERY node
     // (measured: the whole of the observe tier's creation overhead). Keep the
     // two in sync — the dist artifact test pins observe's key set to prod's
-    // plus `_name`.
+    // plus the slots.
         const s = {
         id: inheritId(t, n, context),
-        u: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.ie ? CONFIG_NO_SNAPSHOT : 0) | (
+        l: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.le ? CONFIG_NO_SNAPSHOT : 0) | (
         // Plumbing is an observe-tier notion (a name and records to
         // withhold); the prod literal never carries the bit.
-        t?.At ? CONFIG_PLUMBING : 0) | (t?.dt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        tn: t?.equals ?? isEqual,
-        Pe: null,
-        U: context?.U ?? defaultContext,
-        Ct: 0,
-        re: e,
-        pe: l ? t.loadingValue : undefined,
-        it: 0,
-        Ot: undefined,
+        t?.Tt ? CONFIG_PLUMBING : 0) | (t?.St ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ye: t?.equals ?? isEqual,
+        rt: null,
+        A: context?.A ?? defaultContext,
+        ct: 0,
+        X: e,
+        Ie: o ? t.loadingValue : undefined,
+        Et: 0,
+        At: undefined,
         Rt: null,
+        C: null,
         _: null,
-        S: null,
-        he: 0,
-        t: null,
-        Dt: null,
+        Ne: 0,
+        o: null,
+        dt: null,
         _parent: context,
-        rn: null,
-        Gt: null,
-        sn: null,
+        Xe: null,
+        Ct: null,
+        ze: null,
         R: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        G: l ? 0 : STATUS_UNINITIALIZED,
-        Ne: clock,
-        Ae: NOT_PENDING,
-        Pt: -1,
-        _e: l,
-        m: null,
+        m: o ? 0 : STATUS_UNINITIALIZED,
+        ie: clock,
+        ue: NOT_PENDING,
+        Ot: -1,
+        ce: o,
+        T: null,
         // The slot is always present (hidden class); plumbing leaves it
         // unset, which `ownerPath` skips.
-        _name: t?.At ? undefined : t?.name ?? "computed",
+        _name: t?.Tt ? undefined : t?.name ?? "computed",
+        _loc: t?.loc,
         // Observe: the verdict windows this pass entered (verdict.ts) — a
         // slot, so the stamp is never a write after construction.
-        en: 0
+        Ve: 0
     };
-    if (t?.unobserved) ext(s).Ft = t.unobserved;
+    if (t?.unobserved) ext(s).Dt = t.unobserved;
     setupComputedNode(s, t);
     return s;
 }
@@ -614,24 +685,24 @@ function computed(e, t) {
  * computeds — `_x` access stays monomorphic). Installers write through
  * this; hot paths read `el._x?._field` gated by the _config presence bits.
  * Never call ext() just to store a field's default. */ function ext(e) {
-    return e.m ??= {
-        De: null,
-        Te: null,
-        v: undefined,
-        Ie: undefined,
-        Se: undefined,
-        Ft: undefined,
-        ot: undefined,
-        St: null,
-        ct: null,
-        _t: null,
-        Re: null,
-        It: false,
-        ht: NOT_PENDING,
-        Vt: -1,
-        Oe: 0,
-        Z: NOT_PENDING,
-        T: 0
+    return e.T ??= {
+        Se: null,
+        ae: null,
+        F: undefined,
+        se: undefined,
+        fe: undefined,
+        Dt: undefined,
+        lt: undefined,
+        Nt: null,
+        ft: null,
+        Je: null,
+        ut: false,
+        Gt: NOT_PENDING,
+        Ft: -1,
+        Ee: 0,
+        V: NOT_PENDING,
+        I: 0,
+        de: undefined
     };
 }
 
@@ -647,7 +718,12 @@ function computed(e, t) {
  * the boundary collects it and shows its fallback, and the pass is the
  * boundary's, not the tick's (A29's boundary exemption, #3540). */ function joinPass(e, t) {
     e.R |= REACTIVE_JOINED;
-    if (t.G & STATUS_UNINITIALIZED || e.i !== EFFECT_RENDER) joinPassTx(txOf(t), GlobalQueue.ce?.(e));
+    // A new memo's first pass is the hold's work (born held) but not the
+    // tick's: a render effect that reads it decides — under a boundary that
+    // catches it, the boundary's; otherwise the tick joins the hold (#3540:
+    // the reader's position, not where the memo was created). Its catch, if
+    // any, is at its staging.
+        if (t.m & STATUS_UNINITIALIZED || e.i !== EFFECT_RENDER) joinPassTx(txOf(t), !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
 }
 
 /** A15's stale reader (shared-hole and reveal corollaries): a render effect
@@ -656,11 +732,11 @@ function computed(e, t) {
  * re-derived after that transaction's landing (`_reruns`,
  * REACTIVE_FRAME_READ) so the frame catches up with it once it is the
  * committed world. Not a frame born into that transaction (held and never
- * committed — created by one of its held passes, A29): that one reads its
- * transaction's values and keeps staging. Not of a flight whose inputs are
- * already visible (CONFIG_INPUTS_PUBLISHED, #3305): its committed value
- * would tear against them, so the reveal observes the flight instead. Once
- * per pass.
+ * committed — created by one of its held passes, A29; `bornInto`): that
+ * one reads its transaction's values and keeps staging. Not of a flight
+ * whose inputs are already visible (CONFIG_INPUTS_PUBLISHED, #3305): its
+ * committed value would tear against them, so the reveal observes the
+ * flight instead. Once per pass.
  *
  * Lane work is a stale reader too (maintainer, 2026-10-01: a lane sees the
  * screen plus its own guesses). A held write is held because showing it
@@ -684,20 +760,30 @@ function computed(e, t) {
     // read the screen. Lane work with no committed value yet reads a flight
     // as a mount's memo does: it enters, and the boundary it mounts catches
     // the pending (#3540).
-    const n = e.u & CONFIG_VERDICT;
-    if ((passLane === null || e.G & STATUS_UNINITIALIZED && t.G & STATUS_PENDING) && !n && (e.i !== EFFECT_RENDER || t.u & CONFIG_INPUTS_PUBLISHED)) return false;
-    const l = txOf(t);
+    // (Verdict readers and lanes exist only with their engines installed.)
+    const n = observeFlightHook && e.l & CONFIG_VERDICT;
+    const o = laneStageHook && passLane !== null;
+    if ((!o || e.m & STATUS_UNINITIALIZED && t.m & STATUS_PENDING) && !n && (e.i !== EFFECT_RENDER || t.l & CONFIG_INPUTS_PUBLISHED)) return false;
+    const s = txOf(t);
     // Lane work and verdict readers are never the transaction's pass, whichever
     // flush runs it: a node T holds re-enters T when it re-runs (`recompute`'s
     // head), and the pass may then read a guess and become the lane's.
-        if (l === flushTransaction && passLane === null && !n || e.G & STATUS_UNINITIALIZED && e.u & CONFIG_HELD && txOf(e) === l) return false;
-    staleReader(e, l);
+        if (s === flushTransaction && !o && !n || bornInto(e, s)) return false;
+    staleReader(e, s);
     return true;
 }
 
+/** A node born into transaction `t`: held by it and never committed (A29,
+ * ruling A) — uninitialized (born held), or a member of the frame one of its
+ * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
+ * has no screen to read, so it reads `t`'s values, whichever flush runs it,
+ * and keeps staging (#4010). */ function bornInto(e, t) {
+    return (e.m & STATUS_UNINITIALIZED || e.l & CONFIG_HELD_FRAME) && e.l & CONFIG_HELD && txOf(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.Ht ? e.gt : e;
+    return e !== null && e.Pt ? e.Ht : e;
 }
 
 /** L2 — park the previous pass's frame for this node's commit: the children
@@ -706,11 +792,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.ct = e.Pe;
-    t.St = e.sn;
-    e.Pe = null;
-    e.sn = null;
-    e.Ct = 0;
+    t.ft = e.rt;
+    t.Nt = e.ze;
+    e.rt = null;
+    e.ze = null;
+    e.ct = 0;
 }
 
 /**
@@ -718,58 +804,59 @@ function computed(e, t) {
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
- */ function createEffectNode(e, t, n, l, s) {
+ */ function createEffectNode(e, t, n, o, s) {
     const E = s?.transparent ?? false;
     // Prod and observe boilerplates — see computed() for why the observe tier
     // gets its `_name` as a literal slot rather than a write after the fact.
     // The default label is the node kind (tracked effects relabel their computed
     // in trackedEffect); the wrappers in signals.ts no longer spread a name into
     // the options to get it.
-        const u = {
+        const l = {
         id: inheritId(s, E, context),
-        u: (E ? CONFIG_TRANSPARENT : 0) | (s?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (s?.sync ? CONFIG_SYNC : 0) | (s?.dt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        tn: false,
-        Pe: null,
-        U: context?.U ?? defaultContext,
-        Ct: 0,
-        re: e,
-        pe: undefined,
-        it: 0,
-        Ot: undefined,
+        l: (E ? CONFIG_TRANSPARENT : 0) | (s?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (s?.sync ? CONFIG_SYNC : 0) | (s?.St ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ye: false,
+        rt: null,
+        A: context?.A ?? defaultContext,
+        ct: 0,
+        X: e,
+        Ie: undefined,
+        Et: 0,
+        At: undefined,
         Rt: null,
+        C: null,
         _: null,
-        S: null,
-        he: 0,
-        t: null,
-        Dt: null,
+        Ne: 0,
+        o: null,
+        dt: null,
         _parent: context,
-        rn: null,
-        Gt: null,
-        sn: null,
+        Xe: null,
+        Ct: null,
+        ze: null,
         R: REACTIVE_LAZY,
-        G: STATUS_UNINITIALIZED,
-        Ne: clock,
-        Ae: NOT_PENDING,
-        Pt: -1,
-        _e: false,
-        lt: false,
-        Nt: undefined,
-        Ut: t,
-        Lt: n,
+        m: STATUS_UNINITIALIZED,
+        ie: clock,
+        ue: NOT_PENDING,
+        Ot: -1,
+        ce: false,
+        Qe: false,
+        _t: undefined,
+        Ge: t,
+        ht: n,
         kt: undefined,
-        i: l,
-        m: null,
+        i: o,
+        T: null,
         _name: s?.name ?? "effect",
-        en: 0
+        _loc: s?.loc,
+        Ve: 0
     };
     // Effects dispatch status through the SHARED notifier (statusNotifierOf,
     // keyed off _type) — storing it per node forced a full NodeExtension
     // 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 (s?.unobserved) ext(u).Ft = s.unobserved;
-    setupComputedNode(u, lazyOptions);
-    return u;
+        if (s?.unobserved) ext(l).Dt = s.unobserved;
+    setupComputedNode(l, lazyOptions);
+    return l;
 }
 
 /**
@@ -797,15 +884,15 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.Rt = e;
-    const n = context?.Ht ? context.gt : context;
+    const n = context?.Pt ? context.Ht : context;
     if (context) linkChild(context, e);
-    if (n) e.it = n.it + 1;
-    GlobalQueue.xt?.(e);
+    if (n) e.Et = n.Et + 1;
+    wireExternalSourceHook?.(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.G & STATUS_PENDING) && !(e.u & CONFIG_NO_SNAPSHOT)) {
-            ext(e).ot = e.pe === undefined ? NO_SNAPSHOT : e.pe;
-            e.u |= CONFIG_HAS_SNAPSHOT;
+        if (!(e.m & STATUS_PENDING) && !(e.l & CONFIG_NO_SNAPSHOT)) {
+            ext(e).lt = e.Ie === undefined ? NO_SNAPSHOT : e.Ie;
+            e.l |= CONFIG_HAS_SNAPSHOT;
             snapshotSources.add(e);
         }
     }
@@ -813,26 +900,27 @@ function setupComputedNode(e, t) {
 
 function signal(e, t) {
     // Prod and observe boilerplates — see computed(). The observe literal adds
-    // `_name` and `_owner` (the creating owner, stamped by registerGraph for
+    // `_name`, `_loc` and `_owner` (the creating owner, stamped by registerGraph for
     // createSignal nodes so ownerPath can locate signal subjects; null here,
     // and staying null on internal signals — one shape either way).
     const n = {
-        tn: t?.equals ?? isEqual,
-        u: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.ie ? CONFIG_NO_SNAPSHOT : 0),
-        pe: e,
-        t: null,
-        Dt: null,
-        Ne: clock,
-        Ae: NOT_PENDING,
-        Pt: -1,
-        m: null,
+        Ye: t?.equals ?? isEqual,
+        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.le ? CONFIG_NO_SNAPSHOT : 0),
+        Ie: e,
+        o: null,
+        dt: null,
+        ie: clock,
+        ue: NOT_PENDING,
+        Ot: -1,
+        T: null,
         _name: t?.name ?? "signal",
+        _loc: t?.loc,
         H: null
     };
-    if (t?.unobserved) ext(n).Ft = t.unobserved;
-    if (snapshotCaptureActive && !(n.u & CONFIG_NO_SNAPSHOT)) {
-        ext(n).ot = e === undefined ? NO_SNAPSHOT : e;
-        n.u |= CONFIG_HAS_SNAPSHOT;
+    if (t?.unobserved) ext(n).Dt = t.unobserved;
+    if (snapshotCaptureActive && !(n.l & CONFIG_NO_SNAPSHOT)) {
+        ext(n).lt = e === undefined ? NO_SNAPSHOT : e;
+        n.l |= CONFIG_HAS_SNAPSHOT;
         snapshotSources.add(n);
     }
     return n;
@@ -851,23 +939,25 @@ function isEqual(e, t) {
  * object, no NodeExtension, no post-construction expandos. `ownedWrite` is
  * baked in: the setter carries the owned-scope guard; node-level writes are
  * the store's notification machinery. The observe literal adds the label
- * slot (the store relabels it `store.<key>` when the engine is installed). */ function slotSignal(e, t, n, l, s) {
+ * 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, s) {
     const E = {
-        tn: t,
-        u: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
-        pe: e,
-        t: null,
-        Dt: null,
-        Ne: clock,
-        Ae: NOT_PENDING,
-        Pt: -1,
-        m: null,
-        yt: n,
-        bt: l,
+        Ye: t,
+        l: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
+        Ie: e,
+        o: null,
+        dt: null,
+        ie: clock,
+        ue: NOT_PENDING,
+        Ot: -1,
+        T: null,
+        O: n,
+        Vt: o,
         acc: s,
         px: undefined,
         pxv: undefined,
         _name: "signal",
+        _loc: undefined,
         H: null
     };
     return E;
@@ -892,6 +982,16 @@ function setVerdict(e) {
  * Use `untrack` inside a memo or effect when you need to read a signal once
  * without making the surrounding computation depend on its future changes.
  *
+ * `untrack` stops dependency tracking, not async settlement. Reading an
+ * uninitialized async source still suspends the owning computation; it runs
+ * again when that source first resolves. Afterward, the untracked read is a
+ * snapshot and does not subscribe the computation to later changes.
+ *
+ * If the first read must return immediately, give the async source a
+ * `loadingValue` before reading it with `untrack`. `isPending` and `latest`
+ * inspect updates to an existing value; neither supplies a missing initial
+ * value.
+ *
  * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
  * read inside `fn` that isn't inside a nested tracking scope will log a
  * warning naming the label.
@@ -905,13 +1005,15 @@ function setVerdict(e) {
  *     log(snapshot);
  *   }
  * );
+ *
+ * const color = createMemo<string>(() => fetchColor(), { loadingValue: "gray" });
+ * const initialColor = untrack(color); // "gray" while the fetch is unresolved
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.Wt === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.Wt) return GlobalQueue.Wt(e);
+        if (externalUntrackHook) return externalUntrackHook(e);
         return e();
     } finally {
         tracking = n;
@@ -945,13 +1047,13 @@ function setVerdict(e) {
         // pay-for-use contract. Owner-lifecycle nodes are dead: recomputing would
         // re-run user code in a torn-down tree (and discard manual writes on
         // derived-writable signals), so reads return the last committed value.
-        if (e.u & CONFIG_AUTO_DISPOSE) {
+        if (e.l & CONFIG_AUTO_DISPOSE) {
             const t = e._parent;
             if (t !== null) {
                 // A dormant node was off the chain when its owner died, so the strip
                 // in disposeChildren missed it: freeze here instead (#3024).
                 if (t.R & REACTIVE_DISPOSED) {
-                    e.u &= ~CONFIG_AUTO_DISPOSE;
+                    e.l &= ~CONFIG_AUTO_DISPOSE;
                     return;
                 }
                 // A zombie never left its chain (the parked frame is drained whole,
@@ -979,7 +1081,7 @@ function setVerdict(e) {
  *   never the graph — A32).
  * False means the reader derives from the staged value.
  */ function readerSeesCommitted(e, t) {
-    return !!(!t || e.Ae === NOT_PENDING || t.u & 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;
@@ -1000,21 +1102,21 @@ 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.ee || e.Ae === NOT_PENDING || e.u & CONFIG_PROMOTED) return NOT_PENDING;
+    if (globalQueue.q || 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.
-        if (e.u & CONFIG_HELD) return e.m.Vt === clock ? e.m.ht : NOT_PENDING;
-    return e.pe;
+        if (e.l & CONFIG_HELD) return e.T.Ft === clock ? e.T.Gt : NOT_PENDING;
+    return e.Ie;
 }
 
 /** A28: a held node rewritten outside a flush keeps the staging the last
  * flush left (`_flushed`) until the flush that carries the rewrite — the
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
-    const t = e.m;
-    if (t.Vt !== clock) {
-        t.ht = e.Ae;
-        t.Vt = clock;
+    const t = e.T;
+    if (t.Ft !== clock) {
+        t.Gt = e.ue;
+        t.Ft = clock;
         unflushedStaged = true;
     }
 }
@@ -1034,7 +1136,7 @@ function resyncUnflushedCompanions() {
     unflushedStaged = false;
     // Length-guarded: the common flush has nothing here and allocates nothing.
         if (promotedWrites.length !== 0) {
-        for (const e of promotedWrites) e.u &= ~CONFIG_PROMOTED;
+        for (const e of promotedWrites) e.l &= ~CONFIG_PROMOTED;
         promotedWrites.length = 0;
     }
 }
@@ -1042,7 +1144,7 @@ function resyncUnflushedCompanions() {
 /** A tracked read's pull of a computed: bring it current when the flush has
  * reached its height (or the reader is a fresh-pull waiter), and sit the
  * reader above it. */ function pullComputed(e, t) {
-    if (e.it >= dirtyQueue.ut) {
+    if (e.Et >= dirtyQueue.st) {
         markNode(t);
         markHeap(dirtyQueue);
         updateIfNecessary(e);
@@ -1053,27 +1155,27 @@ function resyncUnflushedCompanions() {
     // never read the PRE-re-ask value as settled. Self-guarded: a clean
     // node no-ops and updateIfNecessary refuses disposed nodes (#2983) —
     // a dead target serves its last value, which is already quiescent.
-     else if (t.u & CONFIG_FRESH_READ) updateIfNecessary(e);
-    const n = e.it;
+     else if (t.l & CONFIG_FRESH_READ) updateIfNecessary(e);
+    const n = e.Et;
     // parent check is shallow, might need to be recursive
-        if (n >= t.it && e._parent !== t) t.it = n + 1;
+        if (n >= t.Et && e._parent !== t) t.Et = n + 1;
 }
 
 function read(e) {
     let t = context;
-    if (t?.Ht) t = t.gt;
+    if (t?.Pt) t = t.Ht;
     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 l = e;
-    if (typeof n.re === "function") prepareComputed(e);
+        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.
         if (verdict !== null) return verdict(e, t);
-    if (!n.re && e.m?.ot === undefined && !snapshotCaptureActive && (!unflushedStaged || e.Ae === NOT_PENDING) && // A28, see readNodeFast
-    !(e.u & CONFIG_OVERRIDE) && // lanes: the slow path's one arm
+    if (!n.X && e.T?.lt === undefined && !snapshotCaptureActive && (!unflushedStaged || e.ue === NOT_PENDING) && // A28, see readNodeFast
+    !(e.l & CONFIG_OVERRIDE) && // lanes: the slow path's one arm
     true) {
         if (t) {
             if (tracking) link(e, t);
@@ -1087,17 +1189,17 @@ function read(e) {
             // stays out too (rule 3, `frameRead`). The pass remembers it read the
             // future (REACTIVE_JOINED): a first pass that did is born held (A29),
             // wherever it was created. Lane work sees the screen (`frameRead`).
-                        if (e.u & CONFIG_HELD && !(t.u & CONFIG_CHILDREN_FORBIDDEN)) {
-                if (frameRead(t, e)) return e.pe;
+                        if (e.l & CONFIG_HELD && !(t.l & CONFIG_CHILDREN_FORBIDDEN)) {
+                if (frameRead(t, e)) return e.Ie;
                 joinPass(t, e);
             }
         }
         // Committed visibility for untracked and children-forbidden readers.
-                if (!t || e.Ae === NOT_PENDING || t.u & CONFIG_CHILDREN_FORBIDDEN) return e.pe;
+                if (!t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.Ie;
         // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
-                if (t.u & CONFIG_VERDICT && stagedScreen(t)) return e.pe;
+                if (observeFlightHook && t.l & CONFIG_VERDICT && stagedScreen(t)) return e.Ie;
         stagedRead(t);
-        return e.Ae;
+        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).
@@ -1105,20 +1207,29 @@ function read(e) {
     if (t) {
         if (tracking) {
             link(e, t);
-            if (l.re) pullComputed(l, t);
+            if (o.X) {
+                pullComputed(o, t);
+                // F-6 (#4050): a memo over a verdict reader's value derives from a
+                // display-ahead read — a verdict reader from this pass's end, as if
+                // 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;
+            }
         }
         // L2, as in the fast block above (tracked or not). A node born into the
         // future (uninitialized) has no committed value: every reader derives
         // from the future there, a render effect included (A29: a stale reader
         // of it cannot fall back to the committed frame and enters instead).
-                if (e.u & CONFIG_HELD && !(e.u & CONFIG_OVERRIDE) && !(t.u & CONFIG_CHILDREN_FORBIDDEN)) {
-            if (l.G & STATUS_UNINITIALIZED || !frameRead(t, e)) joinPass(t, e); else s = true;
+                if (e.l & CONFIG_HELD && !(e.l & CONFIG_OVERRIDE) && !(t.l & CONFIG_CHILDREN_FORBIDDEN)) {
+            if (o.m & STATUS_UNINITIALIZED || !frameRead(t, e)) joinPass(t, e); else s = true;
         }
     }
     // Lanes: a lane's node (after the pull — the node is current). NOT_PENDING
     // falls through: lane work's read of a pending member throws like any.
-        if (e.u & CONFIG_OVERRIDE) {
-        const n = GlobalQueue.Zt(t, e);
+    // (CONFIG_OVERRIDE is the lane engine's: no engine, no lane's node.)
+        if (laneReadHook && e.l & CONFIG_OVERRIDE) {
+        const n = laneReadHook(t, e);
         if (n !== NOT_PENDING) return n;
     }
     // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
@@ -1133,53 +1244,58 @@ function read(e) {
     // effect keeps its DOM by throwing, a memo has no DOM and is handed the
     // value. `[isPending(x), x()]` reads `[true, stale]` in either order (A10)
     // — unless the flight committed beneath inputs already on screen
-    // (`observeFlight`).
-        if (l.G & STATUS_PENDING && !s && !(e.u & CONFIG_OVERRIDE) && !(l.G & STATUS_UNINITIALIZED)) {
+    // (`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 && !s && !(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).
-        if (passLane !== null && !(t?.G & STATUS_UNINITIALIZED)) s = true; else if (t !== null && t.u & CONFIG_VERDICT) s = GlobalQueue.vt(t, l);
+        // (A lane, and a verdict reader, exist only with their engines installed.)
+        if (laneStageHook && passLane !== null && !(t?.m & STATUS_UNINITIALIZED)) s = true; else if (observeFlightHook && t !== null && t.l & CONFIG_VERDICT) s = observeFlightHook(t, o);
     }
-    if (l.G & STATUS_PENDING && !s) {
+    if (o.m & STATUS_PENDING && !s) {
         // A reader landing on a pending node throws; an untracked read of an
         // UNINITIALIZED node has no committed value to serve and throws too. A
         // children-forbidden reader (createTrackedEffect / onSettled) sees the
         // frame, not the graph (A32): the committed value, and the NotReady only
         // where there is none (uninitialized).
         if (t) {
-            if (!(t.u & CONFIG_CHILDREN_FORBIDDEN) || l.G & STATUS_UNINITIALIZED) {
+            if (!(t.l & CONFIG_CHILDREN_FORBIDDEN) || o.m & STATUS_UNINITIALIZED) {
                 // An untracked read of a pending node still re-runs its reader when
                 // the node settles — unless nobody is reading (`spectating`, #3528)
                 // or the reader is the node itself.
                 if (!tracking && !spectating && e !== t) link(e, t);
-                throw l.m?.v;
+                throw o.T?.F;
             }
-        } else if (l.G & STATUS_UNINITIALIZED) {
-            throw l.m?.v;
+        } else if (o.m & STATUS_UNINITIALIZED) {
+            throw o.T?.F;
         }
     }
     // An errored derive throws for every late reader instead of silently
     // serving node values (memo parity, #2897 ruling).
-        if (l.re && l.G & STATUS_ERROR) {
+        if (o.X && o.m & STATUS_ERROR) {
         // 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 && l.Ne < clock) {
-            recompute(l);
+        if (tracking && o.ie < clock) {
+            recompute(o);
             return read(e);
-        } else throw l.m?.v;
+        } else throw o.T?.F;
     }
-    if (snapshotCaptureActive && t && t.u & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.m?.ot;
+    if (snapshotCaptureActive && t && t.l & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.T?.lt;
         if (n !== undefined) {
-            const l = n === NO_SNAPSHOT ? undefined : n;
-            const s = e.Ae !== NOT_PENDING ? e.Ae : e.pe;
-            if (s !== l) t.R |= REACTIVE_SNAPSHOT_STALE;
-            return l;
+            const o = n === NO_SNAPSHOT ? undefined : n;
+            const s = e.ue !== NOT_PENDING ? e.ue : e.Ie;
+            if (s !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
+            return o;
         }
     }
-    if (s) return e.pe;
+    if (s) return e.Ie;
+    // 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?.de) throw e.T.de;
     const E = serve(e, t);
-    if (!t && typeof n.re === "function" && e.u & CONFIG_AUTO_DISPOSE && !(l.G & STATUS_PENDING) && !e.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
         // next — so consecutive reads could answer differently with no write in
@@ -1206,16 +1322,18 @@ 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.Ae !== NOT_PENDING && e.G & STATUS_UNINITIALIZED && (!t || spectating || t.u & 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.pe;
-    if (t.u & CONFIG_VERDICT && !(e.G & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.pe;
+    if (readerSeesCommitted(e, t)) return e.Ie;
+    if (observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.Ie;
     stagedRead(t, e);
-    return e.Ae;
+    // D-41: the staged answer is an error (`stageError`).
+        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
@@ -1227,10 +1345,13 @@ function read(e) {
  * write never shows through the lane. A verdict lane's work likewise: the
  * lane holds verdicts, not the frame's other stagings (#3851) — except a
  * verdict reader, which answered for itself (the lane seam, lanes.ts). Not
- * a read of a node born staged: it has no committed value to re-derive on,
- * and a re-run would read the same staging and re-queue every round. */ function stagedRead(e, t) {
-    e.R |= REACTIVE_STAGED_READ;
-    if (passLane !== null && !(t?.G & STATUS_UNINITIALIZED)) stagedReaders.push(e);
+ * a read of a node born staged at all: it has no committed value to
+ * re-derive on, and a re-run would read the same staging and re-queue every
+ * 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);
+    }
 }
 
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
@@ -1240,8 +1361,9 @@ function read(e) {
  * #3322 — one run, on the committed world), or with the hold. Before any
  * transaction the answer is the seam's and the reader watches it
  * (verdict.ts). A node born into the future has no screen: its staging is
- * its only value (A29). */ function stagedScreen(e) {
-    if (flushTransaction === null) return false;
+ * 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;
     staleReader(e, flushTransaction);
     return true;
 }
@@ -1249,40 +1371,77 @@ 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.ee || e.u & CONFIG_PROMOTED) return;
-    e.u |= CONFIG_PROMOTED;
+    if (globalQueue.q || e.l & CONFIG_PROMOTED) return;
+    e.l |= CONFIG_PROMOTED;
     promotedWrites.push(e);
 }
 
-/** Cold half of setSignal's snapshot arm (see there): first write during
- * capture to a plain signal without a live snapshot records the pre-write
- * value. Only plain user signals qualify. Computeds reach setSignal from an
+/** Cold half of setSignal's snapshot arm (see there), shared with a store
+ * container's structural notify: first write during capture to a plain
+ * signal without a live snapshot records the pre-write value. Only plain
+ * user signals qualify. Computeds reach setSignal from an
  * async landing (asyncWrite), and a value arriving from async during the pass
  * REVEALS — the creation-time arm skips pending computeds for the same
  * reason. Firewall leaves belong to a projection whose compute is the tree's
  * own work, captured (or deliberately not) at creation. */ function captureWriteSnapshot(e, t) {
-    if (e.u & CONFIG_NO_SNAPSHOT || e.re !== undefined || e.m?.ot !== undefined) return;
-    ext(e).ot = t === undefined ? NO_SNAPSHOT : t;
-    e.u |= CONFIG_HAS_SNAPSHOT;
+    if (e.l & CONFIG_NO_SNAPSHOT || e.X !== undefined || e.T?.lt !== undefined) return;
+    ext(e).lt = t === undefined ? NO_SNAPSHOT : t;
+    e.l |= CONFIG_HAS_SNAPSHOT;
     snapshotSources.add(e);
 }
 
+/**
+ * A callback run before every signal or store write lands, while set, with
+ * the written signal or the store proxy whose setter runs. The
+ * server-components client sets it while slot occurrences are left
+ * unmounted after hydration (deferred hydration): a write may be one an
+ * unmounted component would have observed, so the client mounts what is
+ * left before the write applies, and clears the hook. `null` otherwise.
+ */ let writeHook = null;
+
+/** @internal */ function setWriteHook(e) {
+    writeHook = e;
+}
+
+/**
+ * `el`'s comparator verdict (`_equals`), the one guarded call for recompute,
+ * setSignal (user setters and async landings) and the seam's
+ * staged-equals-committed check.
+ * - A comparator that read an unresolved async source has not shown the
+ *   values equal (#4111): falsy, a change, whose readers suspend in their own
+ *   tracked context.
+ * - Any other throw is an error of `el`'s computation (A3, #2837): routed
+ *   through the status path so error boundaries contain it, instead of
+ *   unwinding a flush or a setter; answered "same" so nothing commits.
+ * @internal
+ */ function isSame(e, t, n) {
+    if (e.Ye === isEqual) return t === n;
+    try {
+        return e.Ye && e.Ye(t, n);
+    } catch (t) {
+        if (!(t instanceof NotReadyError)) return notifyStatus(e, STATUS_ERROR, t), true;
+    }
+}
+
 function setSignal(e, t) {
-    const n = e.Ae === NOT_PENDING ? e.pe : e.Ae;
+    if (writeHook !== null) writeHook(e);
+    const n = e.ue === NOT_PENDING ? e.Ie : 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
     // derivation (its flight) is the lane's staging (lanes.ts).
-        if (e.u & CONFIG_OVERRIDE) return GlobalQueue.Qt(e, t);
+        if (laneWriteHook && e.l & CONFIG_OVERRIDE) return laneWriteHook(e, t);
     // L2 (T4) / A34 (1): a write to a node whose staged state is held is a
     // second proposal for the slot — the same value again or another — and
     // the two cannot finish at different times: the writer's tick joins the
     // hold, before the equality gate.
-        if (e.u & CONFIG_HELD) joinFuture(txOf(e));
+        if (e.l & CONFIG_HELD) joinFuture(txOf(e));
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const l = !!(e.G & STATUS_UNINITIALIZED) || !e.tn || !e.tn(n, t);
-    if (!l) return t;
+    // 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?.de || !isSame(e, n, t);
+    if (!o) return t;
     // Attribution hook: this committed write is where a re-run chain begins.
         if (attrHooks !== null) attrHooks.write(e, n, t);
     // A write during hydration's snapshot capture to a source that has no
@@ -1295,21 +1454,21 @@ 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 s = e.Ae !== NOT_PENDING;
+    const s = e.ue !== NOT_PENDING;
     if (!s) 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.u & CONFIG_HELD && !globalQueue.ee) stashFlushed(e);
-    e.Ae = t;
+     else if (e.l & CONFIG_HELD && !globalQueue.q) 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.re !== undefined) e.Ne = 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
     // marked, heap entries flag-guarded, effects queued once).
-        if (s && e.Pt === notifyEpoch) return t;
+        if (s && e.Ot === notifyEpoch) return t;
     insertSubs(e);
     schedule();
     return t;
@@ -1334,18 +1493,31 @@ function setSignal(e, t) {
     // of replacing it. A write made under the hold carries the mark and keeps
     // (1)'s last-write-wins. Only the user setter asks; an async landing
     // writing a held node is the transaction's own work.
-    const n = e.u & CONFIG_HELD && !(e.R & REACTIVE_MANUAL_WRITE) && txOf(e) !== flushTransaction;
+    const n = e.l & CONFIG_HELD && !(e.R & REACTIVE_MANUAL_WRITE) && txOf(e) !== flushTransaction;
     // The writer read the committed frame; its updater composes on it.
-        if (n && typeof t === "function") t = t(e.pe);
-    const l = setSignal(e, t);
+        if (n && typeof t === "function") {
+        const n = t(e.Ie);
+        t = () => n;
+    }
+    // #4110: the write replaces a failed derivation's outcome. It lands without
+    // re-running `_fn`, and nothing else clears STATUS_ERROR, so without this
+    // 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.de = e.T.F;
+        notifyStatus(e, STATUS_NONE, undefined);
+    }
+    t = setSignal(e, t);
+    // A write replaces an error a pass staged (D-41): it is a value again.
+        e.l &= ~CONFIG_STAGED_ERROR;
     if (n) {
         // The one write that re-runs: the staging it replaced was derived from
         // inputs the writer never saw, so the hold re-derives over the write.
         e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(e, dirtyQueue);
         schedule();
-    } else if (e.Ae !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
-    return l;
+    } else if (e.ue !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
+    return t;
 }
 
 /**
@@ -1368,14 +1540,14 @@ function setSignal(e, t) {
  * ```
  */ function runWithOwner(e, t) {
     const n = context;
-    const l = tracking;
+    const o = tracking;
     context = e;
     tracking = false;
     try {
         return t();
     } finally {
         context = n;
-        tracking = l;
+        tracking = o;
     }
 }
 
@@ -1392,7 +1564,7 @@ function staleValues(e, t = true) {
  * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
  * disposed targets.
  */ function markRefresh(e) {
-    if (typeof e.re === "function" && !(e.R & REACTIVE_DISPOSED)) {
+    if (typeof e.X === "function" && !(e.R & REACTIVE_DISPOSED)) {
         // A manual write never refuses the re-run (A34 rule B): a refresh in the
         // write's own frame re-asks with the write as `prev`, like any source
         // change (#3026 generalized).
@@ -1408,4 +1580,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict };
+export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, 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 };