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

package/dist/prod/core/core.js

@@ -1,104 +1,139 @@
-import { handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settleErroredDependents } from "./async.js";
+import { notifyStatus, releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, stageError, settlePendingSource, releaseIfSettledUnobserved, settleErroredDependents } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, STATUS_PENDING, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, CONFIG_FW_CHILDREN, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, STORE_SNAPSHOT_PROPS, 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_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";
 
-import { trimStaleDeps, link, unobserved } from "./graph.js";
+import { link, dormantNodes, clearDeps, trimStaleDeps, deferReleases, deferredReleases } from "./graph.js";
 
-import { deleteFromHeap, queueFor, insertIntoHeapHeight, enqueueSub, markNode, markHeap, insertIntoHeap } from "./heap.js";
+import { insertIntoHeap, deleteFromHeap, insertIntoHeapHeight, enqueueSub, markNode, markHeap } from "./heap.js";
 
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, runInTransition, schedule, notifyEpoch, dirtyQueue, bumpNotifyEpoch, projectionWriteActive, reaskArmed, armReaskClear } from "./scheduler.js";
+import { inheritId, linkChild, disposeChildren, markDisposal } from "./owner.js";
 
-import "./invariants.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";
 
-import { disposeChildren, markDisposal, inheritId } from "./owner.js";
-
-GlobalQueue.Ce = recompute;
-
-GlobalQueue.Fe = disposeChildren;
-
-let tracking = false;
-
-/** @internal verdict-module glue */ function setPendingCheckActive(e) {
-    pendingCheckActive = e;
-}
-
-/** @internal verdict-module glue */ function setLatestReadActive(e) {
-    latestReadActive = e;
-}
+// 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
+// the callback to the user queue. Routing the wake through the heap, rather
+// than straight into the queue at notify time, is what orders the run after
+// the commit regardless of which phase the write came from: a write in a
+// 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._e = e => {
+    if (e.i === EFFECT_TRACKED) {
+        deleteFromHeap(e, dirtyQueue);
+        e.Ae = true;
+        globalQueue.enqueue(EFFECT_USER, e.Z);
+    }
+    // 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
+    // only past a seam that left it alive (a live write to a frame whose
+    // 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);
+    // 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);
+};
 
-/** @internal verdict-module glue */ function setContextInternal(e) {
-    context = e;
+/** 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?.Re?.P;
 }
 
-let stale = false;
-
-let pendingCheckActive = false;
+GlobalQueue.Ce = disposeChildren;
 
-let latestReadActive = false;
+let tracking = false;
 
 let context = null;
 
-let currentOptimisticLane = 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.He) return true;
-        e = e.ve;
+        if (e.Oe) return true;
+        e = e._parent;
     }
     return false;
 }
 
 function setSnapshotCapture(e) {
     snapshotCaptureActive = e;
-    if (e && !snapshotSources) snapshotSources = new Set;
+    if (e && !snapshotSources) snapshotSources = new NewSet;
 }
 
-function markSnapshotScope(e) {
-    e.He = true;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */ function markSnapshotScope(e, t) {
+    if (arguments.length < 2) e.Oe = true; else if (snapshotCaptureActive && e.T?.De === undefined) takeSnapshot(e, t);
 }
 
 function releaseSnapshotScope(e) {
-    e.He = false;
+    e.Oe = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.ke;
+    let t = e.pe;
     while (t) {
-        if (t.He) {
-            t = t.Ve;
+        if (t.Oe) {
+            t = t.Ge;
             continue;
         }
-        if (t.Se) {
+        if (t.X) {
             const e = t;
-            e.T &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.ie & REACTIVE_SNAPSHOT_STALE) {
-                e.ie &= ~REACTIVE_SNAPSHOT_STALE;
-                e.ie |= REACTIVE_DIRTY;
-                if (dirtyQueue.xe > e.Le) dirtyQueue.xe = e.Le;
+            e.l &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.R & REACTIVE_SNAPSHOT_STALE) {
+                e.R &= ~REACTIVE_SNAPSHOT_STALE;
+                e.R |= REACTIVE_DIRTY;
+                if (dirtyQueue.Fe > e.he) dirtyQueue.Fe = e.he;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.Ve;
+        t = t.Ge;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.o?.Qe;
-            // StoreNode targets share one pre-initialized hidden class (see
-            // createStoreProxy) — assign undefined instead of deleting, and only
-            // when present so signal-node sources don't grow the field.
-                        if (e[STORE_SNAPSHOT_PROPS] !== undefined) e[STORE_SNAPSHOT_PROPS] = undefined;
+            // The extension is a fixed-shape object with `_snapshotValue`
+            // 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.T;
+            if (t != null) t.De = undefined;
         }
         snapshotSources = null;
     }
@@ -108,240 +143,474 @@ function clearSnapshots() {
 function recompute(e, t = false) {
     // §12d: any recompute can clean a marked subscriber — invalidate skips.
     bumpNotifyEpoch();
-    const n = e.Re;
+    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
+    // lane's; so does a member the lane's own re-staging dirtied
+    // (REACTIVE_LANE_DIRTY, lanes.ts — a leaf the lane owns). A written guess's
+    // own pass is its truth arriving (A18), the frame's. A first pass is its
+    // creator's (ruling A: a lane pass's children are the lane's frame), and
+    // under a guess's lane it reads as the lane's too — a binding the lane
+    // mounts sees the screen, like the pass that mounted it (#3835). Not
+    // under a verdict lane, for its reads or its result: a verdict lane holds
+    // verdicts, and a mount it makes is a mainline mount (A29's boundary
+    // exemption, #3851). A tracked read of a lane's value moves a
+    // 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.
+    // Lanes exist only with the lane engine installed (`laneStageHook`): a
+    // 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));
+    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.
+    // An error a pass staged, which this pass replaces (`valueChanged`).
+        const l = e.l & CONFIG_STAGED_ERROR;
     if (!t) {
-        if (e._e && (!n || activeTransition) && activeTransition !== e._e) globalQueue.initTransition(e._e);
-        deleteFromHeap(e, queueFor(e));
-        if (e.o !== null) e.o.Ee = null;
-        // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e._e || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ke !== null || e.he !== null) {
-            markDisposal(e);
-            const t = ext(e);
-            t.We = e.he;
-            t.qe = e.ke;
-            e.he = null;
-            e.ke = null;
-            e.Me = 0;
-        } else ;
-    }
-    let i = !!(e.ie & REACTIVE_OPTIMISTIC_DIRTY);
-    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.De !== NOT_PENDING && e.o?.De !== undefined;
-    const l = !!(e.S & STATUS_UNINITIALIZED);
-    // Outgoing error, captured before the compute clears status: if this run
-    // recovers to an unchanged value, dependents still holding this object must
-    // be swept (settleErroredDependents, #2949).
-        const o = e.S & STATUS_ERROR ? e.o?._ : undefined;
-    // Re-ask classification lives in the verdict module; capture the flag before
-    // the recompute wipes _flags below.
-        const s = (e.ie & REACTIVE_REASK) !== 0;
-    // Captured before the compute clears it on a sync landing: if that landing
-    // is transition-held below, the window must stay open until the hold
-    // commits (commitPendingNode) — a closed window plus a held value reads as
-    // a pending frame to live observers of the verdict (#2990).
-        const a = e.Ie;
-    const r = context;
-    context = e;
-    e.Ye = null;
-    e.Ze++;
-    e.ie = REACTIVE_RECOMPUTING_DEPS;
-    e.Te = clock;
-    let c = e.Pe === NOT_PENDING ? e.be : e.Pe;
-    let _ = e.Le;
-    let f = false;
-    let E = tracking;
-    let I = currentOptimisticLane;
-    tracking = true;
-    // A computed's fn establishes its OWN dependencies, so it must never run
-    // inside a latest() read window: read() short-circuits through the
-    // companion path before dependency linking, so a memo created (eagerly
-    // computed) inside latest(fn) came out permanently dependency-less (#2926).
-    // latestRead() already suspends the flag for its pull-recomputes; this
-    // covers creation-time computes and flushes that run inside the window.
-        const N = latestReadActive;
-    latestReadActive = false;
-    // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
-    // engine-driven paths, and _optimisticNodes is only pushed by
-    // _optimisticWrite, so the hook is installed whenever either gate holds.
-        if (i) {
-        const t = GlobalQueue.je(e, true);
-        if (t) currentOptimisticLane = t;
-        // `false` = wake-only lane demotion: recompute plain so a mid-tick
-        // latest()/isPending() pull stages instead of direct-committing (#3009).
-        // The predicate lives with the engine (recomputeLane).
-         else if (t === false) i = false;
-    } else if (activeTransition && !t && activeTransition.Ke.length) {
-        // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
-        // child propagates. Walk deps once and inherit the OPT lane so this node
-        // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.je(e, false);
-        if (t) {
-            i = true;
-            currentOptimisticLane = 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.
+                        releaseFlightTeardown(e);
+        }
+        // L2: a pass over a held derivation joins its transaction — the
+        // propagation that reached this node reached the transaction, and this
+        // pass's answer replaces the held one there. A node held with nothing
+        // staged — pending when its flush parked, or a member of a held frame —
+        // 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 (`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 boundary's structure (CONFIG_FRAME) is the frame like a render
+        // effect: it publishes mainline outside its transaction's flush (#4283).
+                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.
+            // An answered deferred node's re-pass is a lagging question (D-40):
+            // it joins nothing, so the write that reached it commits mainline.
+            // `EFFECT_RENDER << 23` is CONFIG_FRAME (a render effect, a boundary's
+            // tree and output), spelled from the effect type as at creation.
+                        if (t.P || e.l & CONFIG_LAGS) ; else if (!(e.l & (CONFIG_VERDICT | EFFECT_RENDER << 23))) 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`).
+                // Not held any more, whichever frame reader it is: its readers read
+                // 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;
+            }
+        }
+        // The previous pass's frame. If that pass is still awaiting its commit
+        // (CONFIG_STAGED) its children were never shown and die on the spot — the
+        // 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.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). A cleanup or
+            // `unobserved` hook that throws here neither stops the pass nor skips
+            // that drain: its error is rethrown when the flush ends (owner.ts).
+            const t = deferredReleases;
+            deferReleases(o = []);
+            disposeChildren(e);
+            deferReleases(t);
+        } 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.ue = NOT_PENDING;
+            e.l ^= CONFIG_STAGED_ERROR;
         }
     }
-    const T = n && n !== EFFECT_USER;
-    const d = stale;
-    if (T) stale = true;
+    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 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 I = e.T?.se?.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).
+    // 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.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.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.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 R = false;
+    let C = tracking;
+    tracking = true;
     try {
-        if (!false && e.T & CONFIG_SYNC) {
-            c = e.Se(c);
-            if (e.o !== null) e.o.Ee = null;
-            e.Ie = false;
+        if (!false && e.l & CONFIG_SYNC) {
+            S = e.X(S);
+            if (e.T !== null) e.T.Ee = null;
+            e.ce = false;
         } else {
-            // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
-            // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
-            // with a setter callback). In that case, the outer `handleAsync` call below would
-            // clobber the fresh subscription, so we skip it and let the internally-registered
-            // iteration drive updates.
-            const t = e.o?.Ee;
-            const n = e.Se(c);
-            const i = typeof n === "object" && n !== null;
-            const u = e.o?.Ee !== t;
-            c = u || !i ? n : handleAsync(e, n);
-            if (!u && !i) {
-                if (e.o !== null) e.o.Ee = null;
+            // 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.T?.Ee;
+            const n = e.X(S);
+            const o = typeof n === "object" && n !== null;
+            const E = e.T?.Ee !== t;
+            S = E || !o ? n : handleAsync(e, n);
+            if (!E && !o) {
+                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 (inFlightChanged — projections) clears when
-                // its internal handleAsync lands.
-                                e.Ie = false;
+                // self-registered flight clears when its own handleAsync lands.
+                                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.S !== 0 || e.o !== null) clearStatus(e, t);
-        // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
-        // is their sticky presence mark).
-                if (e.T & CONFIG_HAS_LANE && e.o?.Be) GlobalQueue.ze(e);
+                if (e.m !== 0 || e.T !== null) clearStatus(e, t);
     } catch (t) {
         const n = t instanceof NotReadyError;
-        if (n && e.Ie) {
+        // 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
             // _pendingSources + _blocked alone) but take NO read-visible pending
-            // status, no downstream propagation, no transition, no lane
-            // registration — the committed loading value keeps serving. If the
+            // status and no downstream propagation — the committed loading value
+            // keeps serving. If the
             // node is currently errored the error stays the answer until this
             // retry can actually run.
             parkLoadingWindow(e, t);
         } else {
-            // Track pending async in the lane (not the lane's source — it creates the lane
-            // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-            if (n && currentOptimisticLane) GlobalQueue.$e(e);
-            let i = false;
-            if (n) {
-                ext(e).ue = true;
-                if (GlobalQueue.Je !== null) i = GlobalQueue.Je(e, s);
+            // 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).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 && I && !e.T?.Ee) settlePendingSource(e);
             }
-            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Be : undefined);
-            if (i) GlobalQueue.p(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
+            // dependents that reached it only through here, and its landing walk
+            // 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). A staged error
+            // answered what the pass carried: the same.
+                        if ((n || N) && u) for (const t of u) if (t !== e && !e.T?.se?.has(t)) settlePendingSource(e, t);
         }
     } finally {
-        tracking = E;
-        latestReadActive = N;
-        if (T) stale = d;
+        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.
-                f = (e.ie & REACTIVE_MISSED_WAKE) !== 0;
-        e.ie = REACTIVE_NONE | (t ? e.ie & REACTIVE_SNAPSHOT_STALE : 0);
-        context = r;
-    }
-    if (!e.o?._) {
-        trimStaleDeps(e);
-        const s = u ? unwrapOverride(e.o?.De) : e.Pe === NOT_PENDING ? e.be : e.Pe;
-        let r = false;
-        try {
-            r = !n && l || !e.Ue || !e.Ue(s, c);
-        } 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);
-        }
+                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), 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. 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
+        // reentrantly. Dropped, the node read as live — `refresh()` re-ran it
+        // and `isDisposed()` lied. REACTIVE_FRAME_READ (A15 stale reader) is
+        // 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 = 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 = 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,
+    // removed it from the heap and ran its cleanups; what remains is what the
+    // body did AFTER the `dispose()` call: reads that re-linked the dead node
+    // to its sources (unlinked here — the leak that kept it re-running in a
+    // torn-down tree), a flight it may have started (retired: the landing
+    // checks `_inFlight` identity), and the value it returned. That value is
+    // NOT published: a dead node freezes at its last committed value (#3024),
+    // so nothing is staged, committed, or propagated to subscribers, and an
+    // effect's run is not enqueued (runEffect would refuse it anyway). The
+    // attribution frame opened at the top is still closed.
+        if (e.R & REACTIVE_DISPOSED) {
+        clearDeps(e);
+        if (e.T !== null) e.T.Ee = null;
+        if (laneStageHook) setPassLane(E);
+        return;
+    }
+    // The lane this pass is work of, if any: its seat (the node's, its
+    // creator's, or the one a lane read moved it into). A pass in a lane's
+    // 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 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 || 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.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).
+        // 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`
         // 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) {
-            e.Xe = !e.o?._;
+                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.ge, S)) && 
+        // A re-staging pass owes no run: the commit replays the effect (#3802).
+        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.
-                        if (!t) e.C.enqueue(n, e.et ??= GlobalQueue.tt.bind(null, e));
+            // 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 || O !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.q.bind(null, e), O);
         }
-        if (e.o?._) ; else if (r) {
-            const l = u ? e.o?.De : undefined;
-            if (t || 
-            // Plain sync flush (no transition on either side) commits effect
-            // values directly — the pending round-trip (queuePendingNode +
-            // commitPendingNodes) exists to sequence transition reveals, and
-            // paying it per effect on the plain path is pure overhead.
-            n && (activeTransition !== e._e || activeTransition === null) || i) {
-                e.be = c;
-                // Lane-propagated correction: upstream data is fresh, correct the
-                // override unconditionally. The direct _value commit is the lane's
-                // own reveal schedule; drop any superseded older hold so its queued
-                // commit can't clobber the fresh value.
-                                if (u && i) {
-                    ext(e).De = c === undefined ? OVERRIDE_UNDEFINED : c;
-                    e.Pe = NOT_PENDING;
-                }
+        // Lanes. A written guess's own pass from the frame: its source
+        // recomputed it — the truth (A18: "the source is whatever recomputes the
+        // node"). It stages under the lane's parent whether or not it changed (a
+        // 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`.)
+        // (The hook first: a build without lanes folds the arm away.)
+                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
+            // has joined a transaction and either the pass read a held node (it
+            // derives from that world — the join merged the node's transaction
+            // into the flush's), or — a verdict lane's mount, mainline — read a
+            // staging of this flush (the same world before the seam parks it; the
+            // mount is not shown ahead of it: #3851), or a pass created it (ruling
+            // A: a held pass's children are the transaction's). Any other mount
+            // that read a staging does not join by being new (2026-10-07): it
+            // publishes and re-derives if the flush parks. A node created outside any pass
+            // that read only the committed world (root setup, a mount, an effect
+            // callback) is nobody's frame and publishes directly, as does a first
+            // 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 (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.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
+                // plain path is pure overhead.
+                // NOTE (stage-3, 2026-08-21): a quiet-world MEMO direct-commit was
+                // attempted here and REVERTED — memo staging is load-bearing beyond
+                // transitions: mid-batch pulls (read-triggered recomputes before
+                // 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 = S;
             } else {
-                e.Pe = c;
-                // A window landing that gets held re-opens the window until the hold
-                // commits — the verdict's held-value branch is window-gated (#2990).
-                                if (a) e.Ie = true;
-                // Transition-held sync recompute is a write path like setSignal/asyncWrite,
-                // so sync derivations of held sources stay visible to isPending()/latest()
-                // (#2831). Both companion writes are transition-scoped (optimistic) and
-                // auto-revert/re-derive at commit. Skipped for plain flushes where the
-                // pending value commits before effects run.
-                                if ((activeTransition || e._e) && GlobalQueue.Oe !== null) GlobalQueue.Oe(e, c);
+                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.
+                                if (t) {
+                    holdNode(e, flushTransaction ?? passTx);
+                    // Born into the future: no committed value until the landing
+                    // (`commitPendingNode` initializes it) — every reader of it
+                    // derives from the future (`read`), an untracked one throws
+                    // (A19 exc. 1).
+                                        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, !i && flushTransaction);
+                }
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.u !== null && (!u || i || e.o?.De !== l)) insertSubs(e, i || u);
-        } else if (u) {
-            // Unchanged value (equals the override) recomputed while the override
-            // is active: _value may still be stale, so hold the authoritative value
-            // for commit on its own transition's schedule — invisibly (A17/A18).
-            if (e.Pe === NOT_PENDING) queuePendingNode(e);
-            e.Pe = c;
-            if (a) e.Ie = true;
- // see the held branch above (#2990)
-                } else if (e.Le != _) {
-            for (let t = e.u; t !== null; t = t.fe) {
-                insertIntoHeapHeight(t.ae, queueFor(t.ae));
+                        if (e.o !== null) {
+                insertSubs(e);
+                // Lane work re-staged: the lane's members re-derive as its work.
+                                if (O !== null) laneDirty(e, O);
             }
+        } 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
         // 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 (o !== undefined && !r && !e.o?._) settleErroredDependents(e, o);
-    }
-    currentOptimisticLane = I;
-    const S = e.Pe !== NOT_PENDING || e.o !== null && (e.o.qe !== null || e.o.We !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
-    // Override-covered holds (hasOverride) always queue: their commit belongs
-    // to their own transition's schedule (A18 re-rule) and is unobservable
-    // under the override (A17). Revert no longer commits anything, so an
-    // unqueued covered hold would leak (INV-7) once the revert clears
-    // _transition.
-        S && (!t || e.S & STATUS_PENDING) && (!e._e || u) && queuePendingNode(e);
-    e._e && n && activeTransition !== e._e && runInTransition(e._e, () => recompute(e));
+                if (!E && !e.T?.U) {
+            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 (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 (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 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 && O === null && R && e.m & STATUS_PENDING) {
+        const t = flushTransaction ?? passTx;
+        if (t && !t.P && 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
+    // value still derives from reaches this node until the commit. A pass that
+    // published directly, or changed nothing, trims now. An errored pass (a
+    // throw, NotReady included, or a comparator throw above) keeps its full
+    // list as before — `_depsTail` marks where it stopped — and the commit
+    // skips it by the same `_error`. An effect's frame is the run its value is
+    // applied by, not the value slot (#3438): a pass that still owes a run
+    // (`_modified`) has not replaced what the last run published, so its tail
+    // waits for `runEffect` to trim once the run applies. A pass that changed
+    // nothing replaced nothing either (#3469): it cannot know at its tail
+    // whether the flush that ran it will park with its inputs held, so the
+    // trim waits on the flush's verdict (`heldTrim`: trimmed at the commit,
+    // 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.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
+    // 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.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 (O === null) queuePendingNode(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 (f) {
+        if (A) {
         enqueueSub(e);
         schedule();
     }
@@ -352,23 +621,32 @@ function updateIfNecessary(e) {
     // (_depsTail/_depGen) is live, and a nested recompute would corrupt it.
     // A mid-pass mark stays latched for recompute's own tail to reschedule
     // (#3037); readers meanwhile serve the values the pass has so far.
-    if (e.ie & REACTIVE_RECOMPUTING_DEPS) return;
-    if (e.ie & REACTIVE_CHECK) {
-        for (let t = e.nt; t; t = t.it) {
-            const n = t.ut;
-            const i = n.lt || n;
-            if (i.Se) {
-                updateIfNecessary(i);
+    // Never recompute a DISPOSED node either: recompute rewrites _flags and
+    // 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.C; t; t = t.G) {
+            const n = t.S;
+            if (n.X) {
+                updateIfNecessary(n);
             }
-            if (e.ie & REACTIVE_DIRTY) {
+            if (e.R & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?._ && e.Te < clock && !e.o?.Ee) {
+    if (e.R & REACTIVE_DIRTY || e.T?.U && e.ie < clock && !e.T?.Ee) {
         recompute(e);
     }
-    e.ie = e.ie & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    // The guard above refused an already-disposed node; the recompute it just
+    // ran may have disposed it (#3621) — carry the flag, or it comes back alive.
+    // The manual-write mark is state, not scheduling (#3612, A34 rule B): it
+    // says the node's staging is a PROPOSAL, lifted by a pass that re-derives
+    // or by the commit — a pull that recomputed nothing must not. Nor may it
+    // erase the last pass's verdicts for the landing (a stale reader's
+    // REACTIVE_FRAME_READ — a verdict reader pulled by a sibling before the
+    // landing lost its re-derivation; the lane reads likewise).
+        e.R = e.R & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_ZOMBIE | REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE | REACTIVE_FRAME_READ | REACTIVE_STAGED_READ | REACTIVE_LANE_READ | REACTIVE_SCREEN_READ | REACTIVE_PROBE_UNANSWERED);
 }
 
 function computed(e, t) {
@@ -376,124 +654,270 @@ 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 i = t !== null && typeof t === "object" && "loadingValue" in t;
-    const u = {
+        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` 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 the slots.
+        const E = {
         id: inheritId(t, n, context),
-        T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ue: t?.equals != null ? t.equals : isEqual,
-        he: null,
-        C: context?.C ?? globalQueue,
-        we: context?.we ?? defaultContext,
-        Me: 0,
-        Se: e,
-        be: i ? t.loadingValue : undefined,
-        Le: 0,
-        ot: undefined,
-        st: null,
-        nt: null,
-        Ye: null,
-        Ze: 0,
-        u: null,
-        rt: null,
-        ve: context,
-        Ve: null,
-        ct: 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,
-        ie: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        A: context?.A ?? defaultContext,
+        be: 0,
+        X: e,
+        le: o ? t.loadingValue : undefined,
+        he: 0,
+        ve: undefined,
+        We: null,
+        C: null,
+        _: null,
+        de: 0,
+        o: null,
+        Ze: null,
+        _parent: context,
+        Ge: null,
+        we: null,
+        pe: null,
+        R: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
-        S: i ? 0 : STATUS_UNINITIALIZED,
-        Te: clock,
-        Pe: NOT_PENDING,
-        _e: null,
-        _t: -1,
-        Ie: i,
-        // Cold machinery (async/transition/optimistic/verdict slots) lives one
-        // hop away in the lazily-allocated extension — the core literal MUST
+        m: o ? 0 : STATUS_UNINITIALIZED,
+        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
         // stay under V8's in-object boundary (§12: past ~39 fields every
         // allocation spills to a backing store and creation cost ~4x's).
-        o: null
+        T: null
     };
-    if (t?.unobserved) ext(u).ft = t.unobserved;
-    setupComputedNode(u, t);
-    return u;
+    if (t?.unobserved) ext(E).Ye = t.unobserved;
+    setupComputedNode(E, t);
+    return E;
 }
 
 /** Lazily allocate a node's cold extension (ONE shape for signals and
  * 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.o ??= {
-        De: undefined,
-        Et: undefined,
-        Be: undefined,
-        Ge: undefined,
-        ge: undefined,
-        It: undefined,
-        t: 0,
+    return e.T ??= {
         Ee: null,
-        _: undefined,
-        ue: undefined,
-        le: undefined,
-        A: undefined,
-        pe: false,
-        l: null,
-        ft: undefined,
-        Qe: undefined,
-        We: null,
-        qe: null,
-        Nt: undefined
+        Se: null,
+        U: undefined,
+        fe: undefined,
+        se: undefined,
+        Ye: undefined,
+        De: undefined,
+        me: null,
+        Le: null,
+        Re: null,
+        Ve: false,
+        je: NOT_PENDING,
+        Be: -1,
+        Ie: 0,
+        P: NOT_PENDING,
+        I: 0,
+        Te: null
     };
 }
 
+/** A tracked read of a held node (the reader derives from its transaction's
+ * world): the reading pass is marked as having read it (born-held decision
+ * in `recompute`), and the flush joins the node's transaction — unless the
+ * reader is a render effect. A render effect is the frame, not a derivation
+ * (rule 3): in that transaction's own flush, or born into it (uninitialized,
+ * A29), it reads the staged value and holds nothing of its own; otherwise it
+ * reads the committed value instead (`frameRead`). A node born into the
+ * future has no committed value: every reader joins it. A first pass is
+ * something not ready under a loading boundary that has not shown content:
+ * 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;
+    // 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));
+}
+
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */ function joinPassAt(e, t) {
+    e.R |= REACTIVE_JOINED;
+    joinPassTx(t, !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
+}
+
+/** A15's stale reader (shared-hole and reveal corollaries): a render effect
+ * reading a node held by a transaction that is not the flush's. It is served
+ * the committed value — a pending one's too — publishes mainline, and is
+ * 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; `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
+ * would tear against the rest of its frame; a lane revealing a derivation
+ * of it would show it anyway, beside inputs still committed elsewhere on
+ * the page. The guess is the one value the user opted into predicting. So
+ * a lane pass reading a transaction's held node — its parent's or any
+ * other's — derives from the committed value and is re-derived at that
+ * landing. The case read-through was built for — a corrected guess whose
+ * downstream async must refetch with the truth at once, while another of
+ * the parent's flights is still up — needs none of this: the correction
+ * dissolves the lane, and the refetching pass is the parent's own, reading
+ * the truth as a member (`joinPass`). */ function frameRead(e, t) {
+    // Frame readers: a render effect, a verdict reader (CONFIG_VERDICT — it
+    // reads the screen like one: `[isPending(x), x()]` never pairs the fresh
+    // value with pending, A10, because the reader never sees the fresh value),
+    // and lane work (a lane sees the screen plus its own guesses). Not a
+    // mount's memo (2026-10-02, considered and reverted): a memo is not a
+    // leaf — the transaction's own later passes read it — so a mainline mount's
+    // derivations carry the future (A29, born held); only its direct bindings
+    // 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).
+    // A boundary's tree and output (CONFIG_FRAME) read as a render effect
+    // does: structure, not a derivation of what it shows (#4283). A mount
+    // under a hold still enters it: the content memo it reads is born held,
+    // with no committed value to serve.
+    // (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 && (
+    // CONFIG_FRAME, spelled as at the effect's creation.
+    !(e.l & EFFECT_RENDER << 23) || t.l & CONFIG_INPUTS_PUBLISHED)) return false;
+    const E = 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 (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;
+}
+
+/** 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.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
+ * (already allocated — nothing new) and the `_disposal` list move to the
+ * extension, keep reacting from the heap, and die when the commit publishes
+ * the frame that replaces them (`commitPendingNode`) or when the owner does. */ function parkChildren(e) {
+    markDisposal(e);
+    const t = ext(e);
+    t.Le = e.ke;
+    t.me = e.pe;
+    e.ke = null;
+    e.pe = null;
+    e.be = 0;
+}
+
 /**
  * Build an Effect node with all effect-specific fields baked into a single object literal,
  * 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, i, u, l) {
-    const o = l?.transparent ?? false;
-    const s = {
-        id: inheritId(l, o, context),
-        T: (o ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ue: false,
-        he: null,
-        C: context?.C ?? globalQueue,
-        we: context?.we ?? defaultContext,
-        Me: 0,
-        Se: e,
-        be: undefined,
-        Le: 0,
-        ot: undefined,
-        st: null,
-        nt: null,
-        Ye: null,
-        Ze: 0,
-        u: null,
-        rt: null,
-        ve: context,
-        Ve: null,
-        ct: null,
+ */ function createEffectNode(e, t, n, o, E) {
+    const s = E?.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 i = {
+        id: inheritId(E, s, context),
+        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?.xe ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ye: false,
         ke: null,
-        ie: REACTIVE_LAZY,
-        S: STATUS_UNINITIALIZED,
-        Te: clock,
-        Pe: NOT_PENDING,
-        _e: null,
-        _t: -1,
-        Ie: false,
-        Xe: false,
-        Tt: undefined,
-        dt: t,
-        St: n,
-        At: undefined,
-        Re: i,
-        o: null
+        A: context?.A ?? defaultContext,
+        be: 0,
+        X: e,
+        le: undefined,
+        he: 0,
+        ve: undefined,
+        We: null,
+        C: null,
+        _: null,
+        de: 0,
+        o: null,
+        Ze: null,
+        _parent: context,
+        Ge: null,
+        we: null,
+        pe: null,
+        R: REACTIVE_LAZY,
+        m: STATUS_UNINITIALIZED,
+        ie: clock,
+        ue: NOT_PENDING,
+        Me: -1,
+        ce: false,
+        Ae: false,
+        ge: undefined,
+        qe: t,
+        Je: n,
+        ze: undefined,
+        i: o,
+        T: null
     };
-    // Boundary effects carry a status channel; most effects never touch _x.
-        if (u !== undefined) ext(s).A = u;
-    if (l?.unobserved) ext(s).ft = l.unobserved;
-    setupComputedNode(s, lazyOptions);
-    return s;
+    // 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 (E?.unobserved) ext(i).Ye = E.unobserved;
+    setupComputedNode(i, lazyOptions);
+    return i;
+}
+
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). CARVE 4: the boundaries' per-node
+ * channel (`_x._notifyStatus`) went with them; effects are the only
+ * display consumers.
+ */ let effectStatusNotify = null;
+
+function setEffectStatusNotify(e) {
+    effectStatusNotify = e;
+}
+
+/** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
+ * 0, and only effect literals carry the field) get the shared notifier.
+ * Presence doubles as the "display consumer" membership test in the status
+ * walks, exactly as the per-node field did when every effect carried one. */ function statusNotifierOf(e) {
+    return e.i ? effectStatusNotify : null;
 }
 
 const lazyOptions = {
@@ -501,79 +925,87 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.st = e;
-    const n = context?.Ct ? context.Ot : context;
-    if (context) {
-        const t = context.ke;
-        if (t === null) {
-            context.ke = e;
-        } else {
-            e.Ve = t;
-            t.ct = e;
-            context.ke = e;
-        }
-    }
-    if (n) e.Le = n.Le + 1;
-    if (GlobalQueue.Rt !== null) GlobalQueue.Rt(e);
+    e.We = e;
+    const n = context?.Qe ? context.Ke : context;
+    if (context) linkChild(context, e);
+    if (n) e.he = n.he + 1;
+    wireExternalSourceHook?.(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
-            ext(e).Qe = e.be === undefined ? NO_SNAPSHOT : e.be;
-            e.T |= CONFIG_HAS_SNAPSHOT;
-            snapshotSources.add(e);
-        }
+        if (!(e.m & STATUS_PENDING) && !(e.l & CONFIG_NO_SNAPSHOT)) takeSnapshot(e, e.le);
     }
 }
 
-function signal(e, t, n = null) {
-    const i = {
-        Ue: t?.equals != null ? t.equals : isEqual,
-        T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0),
-        be: e,
-        u: null,
-        rt: null,
-        Te: clock,
-        lt: n,
-        ce: n?.o?.l || null,
-        Pe: NOT_PENDING,
+function signal(e, t) {
+    // Prod and observe boilerplates — see computed(). The observe literal adds
+    // `_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 = {
+        ye: t?.equals ?? isEqual,
+        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.ae ? CONFIG_NO_SNAPSHOT : 0),
+        le: e,
+        o: null,
+        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-
         // typed error-retry gating); _fn/_statusFlags read falsy-identically as
         // missing properties on the shared paths (undefined masks to 0).
-        _e: null,
-        _t: -1,
-        o: null
+        Me: -1,
+        T: null
     };
-    if (t?.unobserved) ext(i).ft = t.unobserved;
-    if (n) {
-        ext(n).l = i;
-        n.T |= CONFIG_FW_CHILDREN;
-    }
-    if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
-        ext(i).Qe = e === undefined ? NO_SNAPSHOT : e;
-        i.T |= CONFIG_HAS_SNAPSHOT;
-        snapshotSources.add(i);
-    }
-    return i;
+    if (t?.unobserved) ext(n).Ye = t.unobserved;
+    if (snapshotCaptureActive && !(n.l & CONFIG_NO_SNAPSHOT)) takeSnapshot(n, e);
+    return n;
 }
 
-function optimisticSignal(e, t) {
-    const n = signal(e, t);
-    ext(n).De = NOT_PENDING;
-    n.T |= CONFIG_OPTIMISTIC;
-    return n;
+function isEqual(e, t) {
+    return e === t;
 }
 
-function optimisticComputed(e, t) {
-    const n = computed(e, t);
-    ext(n).De = NOT_PENDING;
-    n.T |= CONFIG_OPTIMISTIC;
-    return n;
+/** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
+ * target and key as back-refs in place of closures (`equals` is a method
+ * call, `this` the node; the unobserved sweep dispatches to one shared hook,
+ * graph.ts), the store's wrap cache (`px`/`pxv`: the proxy last served for
+ * this key and the raw it wrapped — one pointer compare replaces a WeakMap
+ * lookup per read) and the accessor verdict (`acc`) pre-shaped. No options
+ * 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
+ * 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 = {
+        ye: t,
+        l: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
+        le: e,
+        o: null,
+        Ze: null,
+        ie: clock,
+        ue: NOT_PENDING,
+        Me: -1,
+        T: null,
+        O: n,
+        Xe: o,
+        acc: E,
+        px: undefined,
+        pxv: undefined
+    };
+    return s;
 }
 
-function isEqual(e, t) {
-    return e === t;
+/**
+ * When set to a component name string, any reactive read that is not inside a nested tracking
+ * scope will log a dev-mode warning. Managed automatically by `untrack(fn, strictReadLabel)`.
+ */
+/** The verdict windows' read (verdict.ts), installed while a `latest` or
+ * `isPending` window is open and null otherwise: `read` dispatches to it
+ * then, and a program that never imports them never has one. */ let verdict = null;
+
+function setVerdict(e) {
+    verdict = e;
 }
 
 /**
@@ -583,6 +1015,16 @@ function isEqual(e, t) {
  * 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.
@@ -596,246 +1038,560 @@ function isEqual(e, t) {
  *     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.Gt === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.Gt !== null) return GlobalQueue.Gt(e);
+        if (externalUntrackHook) return externalUntrackHook(e);
         return e();
     } finally {
         tracking = n;
     }
 }
 
+/**
+ * Set while runtime bookkeeping reads a node inside another node's pass (a
+ * loading boundary priming its tree at creation, from whatever pass is
+ * mounting it). `context` is that node, but the read is nobody's: the value
+ * is probed, never derived from, so nothing the read would normally record
+ * on `context` may be recorded — not the untracked-pending re-run link
+ * (`read`, `!tracking`; #3528: a boundary's `on` key read this way from
+ * `notify` linked the key's source into an unrelated async memo, a cycle that
+ * never converged), and not a transaction entry (`enterStagedRead`; #3540: a
+ * born-held tree would otherwise pull the mounting pass into the hold).
+ */ let spectating = false;
+
 /**
  * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
- * an isPending() probe (`refresh`) additionally pulls the node fully up to
- * date so its status flags reflect the current graph.
+ * `refresh` additionally pulls the node fully up to date so its status flags
+ * reflect the current graph.
  */ function prepareComputed(e, t) {
-    if (e.ie & REACTIVE_LAZY) {
-        e.ie &= ~REACTIVE_LAZY;
+    if (e.R & REACTIVE_LAZY) {
+        e.R &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.ie & REACTIVE_DISPOSED) {
+    } else if (e.R & REACTIVE_DISPOSED) {
         // Two disposal lifecycles share the flag (#3024). Observation-lifecycle
         // nodes (CONFIG_AUTO_DISPOSE) are dormant — torn down by unobserved()
         // when the last subscriber left — and reads reawaken them; that is the
         // 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.T & CONFIG_AUTO_DISPOSE) recompute(e, true);
-    } else if (t) {
-        updateIfNecessary(e);
-    }
+        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.l &= ~CONFIG_AUTO_DISPOSE;
+                    return;
+                }
+                // A zombie never left its chain (the parked frame is drained whole,
+                // and its members skip the splice): relinking would put it on the
+                // live chain too.
+                                if (!(e.R & REACTIVE_ZOMBIE)) linkChild(t, e);
+            }
+            recompute(e, true);
+        }
+    } else ;
 }
 
+// CARVE 3: until()'s authoritative-view wakeup (notifyAuthoritativeObservers /
+// installAuthoritativeRead), the stale-of-foreign clause (heldFromStale,
+// recordStaleReplay, ownsHold) and the transaction entry on a staged read
+// (enterStagedRead, stagedEntry / born held, underFreshLoadingBoundary) went
+// with the transactions.
 /**
- * Sentinel returned by readNodeFast when the plain-signal fast path does not
- * apply and the caller must fall back to the full read().
- */ const READ_SLOW = Symbol("read-slow");
+ * Rule 1 (value selection): does this reader see a STAGED node's COMMITTED
+ * value? One implementation of the rule the fast paths (read's fast block)
+ * carry as their trivial ternary. In order:
+ * - no reader at all (an untracked read) — the committed frame;
+ * - nothing staged;
+ * - a children-forbidden reader (createTrackedEffect / onSettled: the frame,
+ *   never the graph — A32).
+ * False means the reader derives from the staged value.
+ */ function readerSeesCommitted(e, t) {
+    return !t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
+}
 
-/**
- * read()'s plain-signal fast path as a standalone entry for hot callers
- * (store traps). Safe to substitute for read() only because the bail
- * conditions mirror read()'s prelude and fast-path guard exactly: the
- * latestRead and pendingCheck windows run side-effectful hooks before the
- * fast path, `_fn` nodes need prepareComputed, and firewall / override /
- * snapshot / transition / lane / dev-strictRead state all take the full
- * resolution. Anything slow returns READ_SLOW; the caller then calls read().
- */ function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.Se || e.lt || e.o?.De !== undefined || e.o?.Qe !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
-    let t = context;
-    if (t?.Ct) t = t.Ot;
-    if (t && tracking) link(e, t);
-    // Children-forbidden readers (createTrackedEffect / onSettled callbacks) get
-    // committed visibility: like the effect half of createEffect and event
-    // handlers, effect-phase code never observes its own unsettled write — the
-    // write lands in the same flush's continuation (#3006).
-        return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
+/** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
+ * cleared when the next flush begins. The read sites test this one module
+ * boolean instead of `globalQueue._running`: inside a flush it is false and
+ * the A28 arm costs nothing; outside, only a tick with unflushed writes pays
+ * the staged-node check. */ let unflushedStaged = false;
+
+function markUnflushedStaged() {
+    unflushedStaged = true;
+}
+
+/** A28 — a write becomes visible at flush. Outside a flush, a node holding a
+ * staged value was written since the last flush: staging commits at flush
+ * end, so nothing else leaves a node in this state. Inside a flush the rule
+ * does not apply (A28 (4): promoted within the round). The value an
+ * unflushed node serves is its committed value, or NOT_PENDING when nothing
+ * 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.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.
+        if (e.l & CONFIG_HELD) return e.T.Be === clock ? e.T.je : NOT_PENDING;
+    return e.le;
+}
+
+/** 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.T;
+    if (t.Be !== clock) {
+        t.je = e.ue;
+        t.Be = clock;
+        unflushedStaged = true;
+    }
+}
+
+/** Nodes written inside a creation-time recompute (CONFIG_PROMOTED). */ const promotedWrites = [];
+
+/** A derivation served the committed value because of an unflushed write
+ * (A28) must run again in the flush that carries it — the late-linker case
+ * (#3337's reason to defer the walk): it linked after the write walked. */ function markLateLinker(e) {
+    // The pass's own tail re-enqueues on this latch (recompute's finally) —
+    // a direct enqueue here would be wiped by the pass's flag reset.
+    e.R |= REACTIVE_MISSED_WAKE;
+    return true;
+}
+
+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.l &= ~CONFIG_PROMOTED;
+        promotedWrites.length = 0;
+    }
+}
+
+/** 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.he >= dirtyQueue.Fe) {
+        markNode(t);
+        markHeap(dirtyQueue);
+        updateIfNecessary(e);
+    }
+    // Fresh-pull readers (awaitable refresh's waiter) recompute a dirty
+    // source inline even when the height gate defers to the flush: the
+    // waiter must park on the re-ask's window (or serve its sync answer),
+    // 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.l & CONFIG_FRESH_READ) updateIfNecessary(e);
+    const n = e.he;
+    // parent check is shallow, might need to be recursive
+        if (n >= t.he && e._parent !== t) t.he = n + 1;
 }
 
 function read(e) {
-    // Handle latest() mode: read from _latestValueComputed
-    // Checked before isPending so that isPending(() => latest(x)) checks
-    // the _pendingSignal of _latestValueComputed (async in flight) rather
-    // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.Pt(e);
     let t = context;
-    if (t?.Ct) t = t.Ot;
+    if (t?.Qe) t = t.Ke;
     const n = e;
-    const i = e.lt;
-    const u = i || e;
-    // Handle isPending() mode: collect pending state while preserving normal read semantics.
-    // Probe mode is suspended while preparing the node so nested reads during a
-    // recompute don't collect into the probe.
-        if (pendingCheckActive) {
-        GlobalQueue.Dt(e, t, u, i);
-    } else if (typeof n.Se === "function") {
-        prepareComputed(e, false);
-    }
-    if (!n.Se && u === e && e.o?.De === undefined && e.o?.Qe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
-        if (t && tracking) link(e, t);
-        // Committed visibility for children-forbidden readers — see readNodeFast.
-                return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
-    }
-    if (t && tracking) {
-        link(e, t, pendingCheckActive);
-        if (u.Se) {
-            const n = queueFor(e);
-            if (u.Le >= n.xe) {
-                markNode(t);
-                markHeap(n);
-                updateIfNecessary(u);
+    // 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;
+    // The verdict windows (`latest`, `isPending`; verdict.ts): one cold path,
+    // 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 (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) {
+            if (tracking) link(e, t);
+            // L2: a pass that reads something already in the future joins it —
+            // the one mechanism behind "a write that reaches the future joins
+            // it". Tracked or not (`untrack` is about dependencies, not about
+            // which world a pass derives from — posture-store-parity S4/S5): a
+            // derivation of a held write published mainline would tear. Frame
+            // readers (children-forbidden, A32) see committed below and stay
+            // out; a render effect outside a parking flush sees committed and
+            // 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.l & CONFIG_HELD && !(t.l & CONFIG_CHILDREN_FORBIDDEN)) {
+                if (frameRead(t, e)) return e.le;
+                joinPass(t, e);
             }
-            const i = u.Le;
-            // parent check is shallow, might need to be recursive
-                        if (i >= t.Le && e.ve !== t) {
-                t.Le = i + 1;
+        }
+        // Committed visibility for untracked and children-forbidden readers.
+                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.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).
+        let E = false;
+    if (t) {
+        if (tracking) {
+            link(e, 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'.
+                // (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
+        // 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.l & CONFIG_HELD && !(e.l & CONFIG_OVERRIDE) && !(t.l & CONFIG_CHILDREN_FORBIDDEN)) {
+            if (o.m & STATUS_UNINITIALIZED || !frameRead(t, e)) joinPass(t, e); else E = 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.
+    // (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 reader in a snapshot scope (a hydration claim) is served the value the
+    // server rendered with: a client write's recompute still in flight does
+    // not pull the claim off the markup it adopts — the reader replays at the
+    // scope's release. An errored node throws below as for any reader.
+        if (snapshotCaptureActive && t && t.l & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.T?.De;
+        if (n !== undefined && !(o.m & STATUS_ERROR)) {
+            const o = n === NO_SNAPSHOT ? undefined : n;
+            const E = e.ue !== NOT_PENDING ? e.ue : e.le;
+            if (E !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
+            return o;
+        }
     }
-    if (u.S & STATUS_PENDING) {
-        if (t && !(stale && u._e && activeTransition !== u._e)) {
-            // Per-lane suspension lives with the engine (a non-null lane implies it
-            // is installed): under a lane, only same-lane pending async without an
-            // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.ht(u)) {
-                if (!tracking && e !== t) link(e, t);
-                throw u.o?._;
+    // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
+    // the committed value — coherent with the frame, whose inputs are the
+    // committed ones too — and does not go pending on it. So is lane work
+    // reading a flight that is not the lane's own (the parent's, or
+    // mainline's): a lane breaks out of its parent's hold and waits only on
+    // what derives from the guess (A31: "under a lane, a pending node on no
+    // lane serves its committed value").
+    // A verdict reader likewise (CONFIG_VERDICT): a frame reader sees the
+    // screen, and for a flight the screen is the committed value — a render
+    // 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`), or the reader was born into the flight's transaction
+    // (#4010): it has no screen, and waits on the flight with its frame.
+    // (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).
+        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
+        // 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.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 o.T?.U;
             }
-        } else if (t && u.S & STATUS_UNINITIALIZED) {
-            // A stale (render) reader of a node held pending in ANOTHER transition
-            // normally keeps showing the node's committed value instead of
-            // entangling the two transactions — but an uninitialized node has no
-            // committed value to show. Suspend on it (firewall-backed store reads
-            // always took this branch; plain memos now do too): the reader
-            // registers as a reporter of that source, and its pending-node stamp
-            // ties it to the active transaction, so the two transactions merge
-            // when the source settles. Falling through served `undefined` as if
-            // settled and stranded the reader outside both transactions, so it
-            // never re-ran when either landed (#3043 port).
-            if (!tracking && e !== t) link(e, t);
-            throw u.o?._;
-        } else if (!t && u.S & STATUS_UNINITIALIZED) {
-            throw u.o?._;
+        } else if (o.m & STATUS_UNINITIALIZED) {
+            throw o.T?.U;
         }
     }
-    // `owner` is the computed itself, or the firewall behind a store node —
-    // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
-    // an errored derive throws for every late reader instead of silently
-    // serving node values (the seed, or last-good data after a failed refetch).
-        if (u.Se && u.S & STATUS_ERROR) {
+    // An errored derive throws for every late reader instead of silently
+    // serving node values (memo parity, #2897 ruling).
+        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)
-        // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && u.Te < clock) {
-            recompute(u);
+        if (tracking && o.ie < clock) {
+            recompute(o);
             return read(e);
-        } else throw u.o?._;
-    }
-    if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.o?.Qe;
-        if (n !== undefined) {
-            const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e.Pe !== NOT_PENDING ? e.Pe : e.be;
-            if (u !== i) t.ie |= REACTIVE_SNAPSHOT_STALE;
-            return i;
         }
+        // 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;
+    }
+    // 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
+        // next — so consecutive reads could answer differently with no write in
+        // between.
+        // The sweep at flush finalization re-validates and reclaims; schedule()
+        // guarantees that flush happens even if nothing else is queued.
+        dormantNodes.add(e);
+        schedule();
+    }
+    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
+ * `el`. Called by read()'s slow tail; the fast path (read's fast block) keeps
+ * its trivial ternary by design (perf, see the doc). Arms, in order:
+ * - a node born staged has nothing for an untracked reader (A19 exception 1);
+ * - an unflushed write serves committed and re-runs the reader in the
+ *   carrying flush (A28);
+ * - readerSeesCommitted, else the staged value.
+ */ function serve(e, t) {
+    // A node born staged (recompute) has a staged value and no committed one:
+    // 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.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) || 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.ue;
+    return e.ue;
+}
+
+/** A pass read a staging of this flush: it derives from what the flush may
+ * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
+ * the frame commits — one pass, the common case — and a held write if it
+ * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
+ * the committed world and its lane's runs wait that round, so the held
+ * 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 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;
+        // 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);
+    }
+}
+
+/** A10 for a staged node: a verdict reader (the pass entered a window) that
+ * also reads a frame's proposal plainly sees the screen — `[latest(q), q()]`
+ * is `[b, a]` — once the frame has a transaction, and re-derives when it
+ * lands: at this very seam if nothing holds it (the stale run is void,
+ * #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). 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;
+}
+
+/** 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.Y || e.l & CONFIG_PROMOTED) return;
+    e.l |= CONFIG_PROMOTED;
+    promotedWrites.push(e);
+}
+
+/** 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.l & CONFIG_NO_SNAPSHOT || e.X !== undefined || e.T?.De !== undefined) return;
+    takeSnapshot(e, t);
+}
+
+function takeSnapshot(e, t) {
+    ext(e).De = 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;
     }
-    if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) {
-        // A17: the override IS the value for every reader.
-        return unwrapOverride(e.o?.De);
-    }
-    // Entanglement gate: a reader recomputing under an optimistic lane that reads
-    // a pending mid-transition write sees the committed value. Projection-store
-    // manual writes use the firewall's manual-write flag to opt into this path.
-    // Async drivers are not under an optimistic lane and so bypass this, reading
-    // _pendingValue for correct fetching. The sub is recorded for replay at commit
-    // so it re-runs with the new committed view. (Gate details live with the
-    // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ft(e, u, t)) {
-        return e.be;
-    }
-    // In optimistic lane context, return _value for optimistic/lane-assigned signals
-    // and for regular signals in stale mode (render effects). Non-stale readers (user
-    // effects) see _pendingValue so that latest() and direct reads stay consistent.
-    // (The lane-context clause lives with the engine.) Children-forbidden readers
-    // (createTrackedEffect / onSettled callbacks) get committed visibility — see
-    // readNodeFast (#3006).
-        const l = !t || currentOptimisticLane !== null && GlobalQueue.gt(e, u, t) || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e._e && activeTransition !== e._e ? e.be : e.Pe;
-    // Record that this isPending() probe observed the fresh pending value, so
-    // the probe doesn't pair "pending" with the new value (#2831).
-        if (pendingCheckActive) GlobalQueue.Ht(e, l);
-    if (!t && u === e && typeof n.Se === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.u) {
-        unobserved(e);
-    }
-    return l;
 }
 
 function setSignal(e, t) {
-    if (e._e && activeTransition !== e._e) globalQueue.initTransition(e._e);
-    // The optimistic write path lives with the engine: only optimisticSignal /
-    // optimisticComputed callers and optimistic store nodes carry an
-    // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
-    // always-present config instead of a missing-property probe), and every
-    // module that installs one installs the engine first.
-        if (e.T & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.vt(e, t);
-    const n = e.Pe === NOT_PENDING ? e.be : e.Pe;
+    if (writeHook !== null) writeHook(e);
+    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
+    // derivation (its flight) is the lane's staging (lanes.ts).
+        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.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 i = !!(e.S & STATUS_UNINITIALIZED) || !e.Ue || !e.Ue(n, t);
-    if (!i) return t;
-    const u = e.Pe !== NOT_PENDING;
-    if (!u) queuePendingNode(e);
-    e.Pe = t;
-    // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
-    // neither companion present the call is a guaranteed no-op (companions are
-    // only ever created, never removed, and creating one installs the hook and
-    // sets CONFIG_HAS_COMPANIONS — one masked read replaces two optional-field
-    // probes on every write).
-        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Oe !== null && GlobalQueue.Oe(e, 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?.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
+    // minted from onSettled in the pass, a preference read from storage) —
+    // captures the pre-write value now, so the write is held like any other:
+    // in-scope readers keep serving what the server rendered with and replay
+    // at release. Left uncaptured, the write cascades live through a claim
+    // pass whose DOM writes are skipped, and a component rendered later in the
+    // 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.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.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.Se !== undefined) e.Te = 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); lane and reask
-    // contexts change what a walk MEANS, so they always walk.
-        if (u && e._t === notifyEpoch && currentOptimisticLane === null && !reaskArmed) return t;
+    // marked, heap entries flag-guarded, effects queued once).
+        if (E && e.Me === notifyEpoch) return t;
     insertSubs(e);
     schedule();
     return t;
 }
 
 /**
- * Suppresses automatic recomputation of `el` until the scheduler drains. Used
- * when a manual write should win over dependency changes queued in the same
- * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
- * computeds don't commit values, but they still need the same end-of-tick
- * cleanup point.
- */ function suppressComputedRecompute(e) {
-    deleteFromHeap(e, queueFor(e));
-    if (!(e.ie & REACTIVE_MANUAL_WRITE) && e.Pe === NOT_PENDING) {
-        queuePendingNode(e);
-        schedule();
-    }
-    e.ie = e.ie & -4 | REACTIVE_MANUAL_WRITE;
-    e.kt = clock;
-}
-
-/**
- * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
- * `setSignal`, but also cancels any pending recompute of the memo so the
- * manual value wins over a value that would otherwise be produced by an
- * upstream change in the same tick.
+ * User-facing setter for the memo form of `createSignal(fn)`. A write applies
+ * first, then derivations re-run (A34 as amended 2026-10-01, rule B; core
+ * R31): the write stages like any other, and a source change — in this flush
+ * or a later one, under a hold or on mainline — re-derives with the staged
+ * write as `prev`. The write never refuses the re-run (the frame-scoped mask
+ * of #3733/#3740 and #2692's "write wins the tick" before it are gone; call
+ * order inside a flush was never observable) and on its own never causes one.
+ * REACTIVE_MANUAL_WRITE only marks the staging as a user proposal — the A34
+ * (1)/(3) discriminator — until a pass re-derives it or the commit lands it.
  */ function setMemo(e, t) {
-    const n = setSignal(e, t);
-    suppressComputedRecompute(e);
-    return n;
+    // A34 (3), #3612: is `el`'s staging a derivation another transaction holds
+    // — held, not a manual proposal, and the writer not that transaction
+    // (mainline, or a flush joined elsewhere)? A held pass result is nobody's
+    // proposal: a setter reaching it composes on the committed frame it was
+    // written against and becomes `prev` for the hold's re-derivation, instead
+    // 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.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") {
+        const n = t(e.le);
+        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.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.
+        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.ue !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
+    return t;
 }
 
 /**
@@ -858,79 +1614,41 @@ function setSignal(e, t) {
  * ```
  */ function runWithOwner(e, t) {
     const n = context;
-    const i = tracking;
+    const o = tracking;
     context = e;
     tracking = false;
     try {
         return t();
     } finally {
         context = n;
-        tracking = i;
+        tracking = o;
     }
 }
 
 function staleValues(e, t = true) {
-    const n = stale;
-    stale = t;
     try {
         return e();
-    } finally {
-        stale = n;
-    }
+    } finally {}
 }
 
 /**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
- */ function refresh(e) {
-    const t = e?.[$REFRESH];
-    if (!t) {
-        return;
-    }
-    if (typeof t.Se === "function" && !(t.ie & REACTIVE_DISPOSED)) {
-        if (t.ie & REACTIVE_MANUAL_WRITE) {
-            // A manual write in the CURRENT tick wins over the refresh (#2692).
-            // A mask stamped in an earlier tick only survives because a
-            // transaction (action) is holding the pending drain open; there the
-            // refresh is a later, explicit re-ask and lifts the mask — otherwise
-            // any setStore early in an action silently swallows every refresh()
-            // for the rest of the transaction (#3026).
-            if (t.kt === clock) return;
-            t.ie &= ~REACTIVE_MANUAL_WRITE;
-            // No REASK below: the batch carries a manual value change, so the
-            // recompute is not a quiet re-ask of an unchanged question.
-                }
-        // A refresh with no value-change dirt already queued is a re-ask of the
-        // same question: mark it so the recompute classifies any resulting
-        // pending window as quiet (not pending). If the node is already dirty
-        // from a real input change, the question changed — don't mark.
-        // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
-        // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
-        // change followed by refresh() must not be laundered into a quiet re-ask.
-         else if (!(t.ie & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.ie |= REACTIVE_REASK;
-            armReaskClear();
-        }
-        t.ie = t.ie & ~REACTIVE_CHECK | REACTIVE_DIRTY;
-        insertIntoHeap(t, queueFor(t));
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets.
+ */ function markRefresh(e) {
+    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).
+        // The re-ask of an answered question (A19 exc. 2): the next pass, going
+        // pending, classifies its flight quiet for the verdict. Not when an
+        // input already changed this tick — that pass asks a new question.
+        e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY | (e.R & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP) ? 0 : REACTIVE_REASK);
+        insertIntoHeap(e, dirtyQueue);
         schedule();
     }
 }
 
-export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, ext, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, suppressComputedRecompute, tracking, untrack };
+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 };