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

package/dist/observe/core/lanes.js

@@ -0,0 +1,972 @@
+import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DIRTY, REACTIVE_CHECK, REACTIVE_IN_HEAP, STATUS_PENDING, CONFIG_SLOT_NODE, REACTIVE_STAGED_READ, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, REACTIVE_LANE_DIRTY, CONFIG_HELD, REACTIVE_LANE_READ, STATUS_UNINITIALIZED, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTHORITATIVE, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, EFFECT_RENDER, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, CONFIG_INPUTS_PUBLISHED, CONFIG_STAGED, REACTIVE_JOINED } from "./constants.js";
+
+import { attrHooks } from "./attribution-hooks.js";
+
+import { ext, bornInto, tracking, creatorReads, stagedRead } from "./core.js";
+
+import { NotReadyError } from "./error.js";
+
+import { removePendingSource, releaseFlightTeardown, handleAsync, notifyStatus, isThenable } from "./async.js";
+
+import { laneValueOf } from "./truth.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { schedule, question, nextQuestion, armGuessing, installLaneHooks, GlobalQueue, resolveTx, newTransaction, list, staleReader, txOf, commitPendingNode, ownFlights, stagedReaders, blocked, clock, insertSubs, laneDirty, flushTransaction, queuePendingNode, passLane, setPassLane, sameLane, releaseQueues, holdNode, reruns, merge } from "./scheduler.js";
+
+// Lanes (plan sec. 28 replay, 2026-10-02; maintainer rulings 2026-10-01/02). A lane
+// is "a new base of a transition": the sub-frame an optimistic write opens
+// in the transition of the frame it is made in. It sees the screen plus its
+// own guesses (plan sec. 19), breaks out of the parent's hold — its effects run now —
+// and holds itself if its own derivations hit async (and, blocked, holds its
+// parent). It ends when the parent lands: a guess reverts to the truth it
+// covered, or lands as the truth that superseded it. A frame that does not
+// park has nothing to be optimistic over: the write is void.
+// Three places per node, each meaning one thing always: `_value` is the
+// committed truth, `_pendingValue` a transaction's staging (the future), and
+// `_x._lane` the lane's value — a written guess or a lane pass's derivation.
+// The lane carries the state machine: `_shown` once it has revealed. The
+// screen shows a lane's value once the lane has shown (`display`); a direct
+// read sees it throughout (A17); an authoritative reader (`until`) sees the
+// truth beneath it (Q3, 2026-10-02: "optimistic overrides are intentionally
+// not part of authoritative truth").
+// The seat of a pass is its node's (core.ts `recompute`): a node carrying a
+// lane's derived value runs as the lane's whoever dirtied it; a derivation's
+// tracked read of a lane's value moves its pass into the lane (`enterLane`);
+// a leaf's never does — it reads the screen, a stale reader of a lane that
+// has not shown (#3460). Lane work's values go to the lane slot (or, once
+// the lane has shown, to its staging for the next reveal), its runs to the
+// lane's queues.
+// This module is the lane engine, installed on `GlobalQueue` when something
+// imports it (`createOptimistic`, or verdict.ts for its verdict lanes). The
+// core keeps only bit tests and `passLane`: a program with no optimism
+// carries none of this.
+/** Live lanes (parented). Scanned at every seam while non-empty. */
+const lanes = [];
+
+/** A pass left a shown slot the equality gate can no longer see (#3892). */ const LEFT_SHOWN = 1 << 20;
+
+function newLane(e) {
+    const n = newTransaction(true, e);
+    lanes.push(n);
+    return n;
+}
+
+/** What the screen shows for a lane's node: the lane's value once the lane
+ * has revealed, the committed truth before — NOT_PENDING when there is none
+ * (uninitialized, as `laneValueOf`): its read throws NotReady. */ function display(e) {
+    const n = e.T.V;
+    return e.T.Je.Nt && n !== NOT_PENDING ? n : e.m & STATUS_UNINITIALIZED ? NOT_PENDING : e.le;
+}
+
+/** Guesses written since the last seam (`[node, value, question, …]`).
+ * Applied at the seam, once the frame's verdict is known — the parent is
+ * the frame's transaction, and there is none to be optimistic over when the
+ * frame commits (the write is as if it never happened: nothing was
+ * applied). The lane's passes run in the next round of the same flush, so
+ * the guess is visible at flush like any write (A28). */ const pendingGuesses = [];
+
+/** What the writer sees of a node: an unflushed guess to it, else the
+ * lane's value or the committed one — what an optimistic updater composes
+ * on (a store setter's draft too, store/optimistic.ts). */ function guessedValueOf(e) {
+    let n = pendingGuessOf(e);
+    return n !== NOT_PENDING || e.l & CONFIG_OVERRIDE && (n = laneValueOf(e)) !== NOT_PENDING ? n : e.le;
+}
+
+/** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
+    for (let n = pendingGuesses.length - 3; n >= 0; n -= 3) if (pendingGuesses[n] === e) return pendingGuesses[n + 1];
+    return NOT_PENDING;
+}
+
+/** This module's copy of scheduler.ts `guessing`: its readers here stay
+ * foldable when a bundler splits lanes.ts from scheduler.ts into separate
+ * chunks (a cross-chunk binding is not folded; the compiled live page). */ let guessed = false;
+
+/** Guesses another action's lane took over (#4336): the node, its guess,
+ * the guess's lane, its question, the lane that took it. */ const kept = [];
+
+/** Lanes a revert dissolved: the guesses they took come back at their
+ * parent's landing (`endLanes`). */ const reverted = /* @__PURE__ */ new WeakSet;
+
+/** Lane `l` takes `n`'s guess (another action's), kept to come back if `l`
+ * reverts. Its readers saw the guess: they re-derive at the lane's reveal
+ * (and, a flight's, hold the lane while they would show it). `d`: a guess
+ * `l` takes without writing it (a store target's other slots) — the node
+ * shows its truth in `l`'s world until the guess comes back. */ function take(e, n, s) {
+    const t = e.T;
+    kept.push(e, t.V, t.Je, t.Ie, n);
+    rerun(e, n);
+    e.l &= s ? -10241 : ~CONFIG_GUESS;
+    if (s) t.Je = null, t.V = NOT_PENDING; else list(e, n);
+}
+
+/** `n`'s readers are stale readers of `t` (re-derived at its landing). */ function rerun(e, n) {
+    for (let s = e.o; s !== null; s = s.t) staleReader(s.u, n);
+}
+
+function optimisticWrite(e, n) {
+    // What the user sees: an unflushed guess to the same node, else the lane's
+    // value or the committed one. The updater composes on it; guessing it
+    // again is no guess (the node's comparator, as for any write) — unless
+    // the node already carries one: the user re-asked, and the re-ask renews
+    // the guess's question and entangles its frame (#3347) without notifying.
+    const s = guessedValueOf(e);
+    if (typeof n === "function") n = n(s);
+    if (e.je && e.je(s, n) && !(e.l & CONFIG_GUESS)) return n;
+    pendingGuesses.push(e, n, question || nextQuestion());
+    armGuessing();
+    guessed = true;
+    schedule();
+    return n;
+}
+
+/** The seam: each guess becomes its node's lane value, in a lane — the
+ * node's own if it carries one (a later write into the same lane), else a
+ * new one under `parent` (the frame's transaction), under the hold already
+ * on the node (a guess over that transition's world — the truth it holds
+ * stays staged beneath, for the lane's end to commit), or under a
+ * transaction opened for the node's own in-flight refetch (the guess is
+ * that flight's observer — A17, "visible until its own fetch settles"). No
+ * parent: the guess is dropped. The truth is untouched; readers are
+ * dirtied for the next round. */
+/** A guess's own truth is in flight: the node's own refetch — or, a store
+ * leaf's, its family's derive (the slot's flight; store/optimistic.ts
+ * installs the resolver). A17: the guess stands in for the flight. */ function inFlight(e) {
+    return e.m & STATUS_PENDING || e.l & CONFIG_SLOT_NODE && GlobalQueue.k?.(e);
+}
+
+function applyGuesses(e) {
+    let n = null;
+    for (let s = 0; s < pendingGuesses.length; s += 3) {
+        const t = pendingGuesses[s];
+        const l = pendingGuesses[s + 1];
+        let r = true;
+        // The frame already holding the slot: a guess over it is a second
+        // suggestion for the slot, and two cannot finish apart (A34 (1)) — the
+        // frames entangle.
+                let u = null;
+        if (t.l & CONFIG_OVERRIDE) {
+            // A lane's node already: a guess re-asked, or a derivation guessed
+            // over (its staging is void — the guess is the value now). The same
+            // value re-asked renews the question; nothing to notify.
+            r = !t.je || !t.je(laneValueOf(t), l);
+            if (!(t.l & CONFIG_GUESS)) {
+                t.ue = NOT_PENDING;
+                t.l |= CONFIG_GUESS;
+            }
+            t.T.V = l;
+            u = txOf(t)._parent;
+        } else {
+            let s;
+            // A held node: a truth staged there, or what a corrected guess showed.
+            // The guess composes on it, so it ends with that hold — and with its
+            // own frame's (F-11): it lands only when both have (the board's rapid
+            // adds — a later add's row reverted with an earlier add's landing).
+                        if (t.l & CONFIG_HELD) s = newLane(u = txOf(t)); else {
+                if (e === null && inFlight(t)) e = newTransaction(false);
+                if (e === null) continue;
+                s = n ??= newLane(e);
+            }
+            // (A guess equal to a truth staged beneath it is confirmed at birth —
+            // A24 — and still re-derives its readers as the lane's: the truth's
+            // derivations are the transaction's world, the lane's are the
+            // screen's plus the guess (plan sec. 19) — a derivation reading a held write
+            // beside the guess must not show it. Two flights for one input, when
+            // the worlds coincide, is the price.)
+                        ext(t).V = l;
+            t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(t, s);
+        }
+        if (e !== null && u !== null) merge(e, u);
+        ext(t).Ie = pendingGuesses[s + 2];
+        if (r) {
+            // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
+            // blocked lane's re-guess does not re-run its render effects as stale
+            // readers republishing the committed view (#3460).
+            insertSubs(t);
+            laneDirty(t, txOf(t));
+        }
+    }
+    pendingGuesses.length = 0;
+}
+
+/** The running pass read lane `l`'s work as a derivation: it is `l`'s — or,
+ * already another lane's, the frame it computes derives from both guesses
+ * and cannot show one without the other (#3335, A15 for lanes): the two
+ * lanes are linked — one reveal unit, each blocked while any is — while
+ * their lifetimes stay their own (#2912: a guess reverts with its own
+ * action, not with the one it shares a reader with). A nested lane reading
+ * through an ancestor's guess stays its own (the screen plus its own
+ * guesses). */ function enterLane(e, n) {
+    const s = n.R |= REACTIVE_LANE_READ, t = passLane;
+    if (t === null) {
+        const t = e._parent.it === e;
+        // A verdict lane's value (a memo of `latest` / `isPending`, F-6) read by
+        // a derivation that already read the frame's staging or joined its
+        // hold, or by any pass a pass that did is creating: the verdict read
+        // does not break it out — it stays the frame's, as the same read inline
+        // does (verdict.ts `markVerdictReader`, `route`; D-25, D-26). An
+        // effect's own reads do not count (its `_type`, 1–3, carries neither bit).
+                if (!(t && creatorReads(n, n.i || s))) {
+            setPassLane(e);
+            // The pass read a held write before its first lane read (it joined the
+            // frame's future as mainline would): lane work sees the screen — the
+            // seam re-derives it on the committed world next round (`stagedReaders`,
+            // the park's repair), as it does a lane pass that read a staging. Not a
+            // pass whose held reads were all of nodes born held (no staged read,
+            // `stagedRead`): it has no committed world to re-derive on (#3969).
+            // (A pass not joined: a held write beside a guess, #4336; a leaf of a
+            // verdict lane — its plain reads are the screen's, D-26 `[s(), L()]`.)
+                        if (s & REACTIVE_STAGED_READ && (guessed || t || s & REACTIVE_JOINED)) stagedRead(n);
+        }
+    } else if (sameLane(t, e)) setPassLane(e); else if (!under(t, e)) {
+        if (!under(e, t)) linkLanes(t, e);
+        setPassLane(e);
+    }
+}
+
+/** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
+    for (let s = e._parent; s !== null && s.V; s = s._parent) if (s === n) return true;
+    return false;
+}
+
+/** One link group (a shared array) for both lanes' groups. */ function linkLanes(e, n) {
+    const s = e.nn ?? (e.nn = [ e ]);
+    const t = n.nn;
+    if (t === s) return;
+    if (t === null) {
+        s.push(n);
+        n.nn = s;
+    } else for (let e = 0; e < t.length; e++) {
+        s.push(t[e]);
+        t[e].nn = s;
+    }
+}
+
+/** A linked lane blocked on its own account blocks the group — `blocked(k)`
+ * without the group recursion. (A guess in `k` whose own truth is in flight
+ * blocks `k`'s parent, not `k` — nor, through the link, `l`: the guess
+ * shows, A17.) */ function linkBlocked(e) {
+    const n = e.nn;
+    if (n !== null) for (let s = 0; s < n.length; s++) {
+        const t = n[s];
+        if (t !== e && (t.tt !== 0 || ownFlights(t) || nestedBlocked(t))) return true;
+    }
+    return false;
+}
+
+function unlink(e) {
+    const n = e.nn;
+    if (n === null) return;
+    const s = n.indexOf(e);
+    if (s !== -1) n.splice(s, 1);
+    e.nn = null;
+}
+
+/** Verdicts (maintainer, 2026-10-01): `isPending` and `latest` are
+ * optimistic state the system supplies — a verdict is a guess ("pending,
+ * until this lands"; "the proposal is the value") decided at the seam like
+ * a user's, and its readers break out of the hold the same way: work of a
+ * lane under the holder, shown now, re-derived at the landing, ending with
+ * it. Judged at the seam like any lane: blocked while a verdict reader's
+ * own derivation is in flight (lane rule 3), shown otherwise. */ function verdictLane(e) {
+    return e.it ??= newLane(e);
+}
+
+/** A lane pass's node (core.ts `recompute`, before its staging; a pending
+ * propagation under a lane pass, async.ts): listed, carrying the lane's
+ * value from now (a derivation of a guess — its readers become lane work).
+ * Entering the lane supersedes a frame staging the node carried: this
+ * pass's answer replaces it, and the frame's hold on it is over. An
+ * effect's value slot is private (no lane value). A pass in a lane's seat
+ * that read none of the lane's world has left it (false): its result is the
+ * frame's — a derivation whose branch no longer reaches the guess — and no
+ * hold the lane took over from a transaction stays on it (#3698: lane work
+ * never makes its node transaction work; a born-held effect's hold went to
+ * the lane). A pass interrupted before it got there (pending, errored) did
+ * not leave (A30: it never got there). A first pass under a lane is the
+ * lane's (ruling A); a guess is written, not derived — it never leaves this
+ * way. `errored`: the pass has no answer — or, a lane pass's pending
+ * propagation (async.ts `propagateStatus`), the node gone pending. */ function laneStage(e, n, s, t) {
+    if (!(s || t || e.R & REACTIVE_LANE_READ || e.l & CONFIG_GUESS)) {
+        const n = e.T;
+        if (n !== null) {
+            const s = n.Je;
+            if (s?.V) {
+                // Cleared before equality, so a return to the committed value
+                // notifies nobody. The seam wakes it (#3892) — always for a pass
+                // outside any transaction's flush: its value is the screen's now
+                // (#4367). While a transaction's flush runs the pass and the lane's
+                // frame is still held, what the screen shows stays the screen until
+                // the landing, and `_value` takes it (as `dissolveLane` keeps a shown
+                // lane's), so this pass's answer — the frame's — is a change against
+                // what is seen and reaches the screen with the frame's commit. (Only
+                // a lane is ever `_shown`.)
+                if (s.Nt) if (!flushTransaction || !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN; else e.le = display(e);
+                n.Je = null;
+            }
+            n.V = NOT_PENDING;
+        }
+        e.l &= -1050881;
+        return false;
+    }
+    if (!e.i) {
+        if (!(e.l & CONFIG_OVERRIDE)) {
+            e.ue = NOT_PENDING;
+            e.l = e.l & -1048833 | CONFIG_OVERRIDE;
+            ext(e);
+        }
+        // A written guess whose own pass is the lane's work — its source is a
+        // derivation of another guess (a guess over `config().courier` under a
+        // country guess) — is confirmed or corrected by the lane: a derivation
+        // of the lane from here (its value the lane's, its fate the lane's), no
+        // longer a written guess. A pass with no answer (pending, errored)
+        // leaves the guess.
+        // Nor a pass of another action's guess: the re-ask is this lane's new
+        // question, which the guess (over the old one) does not answer — the
+        // lane waits for its own answer (F-1, F-6, #4336). (A guess of the
+        // lane's own action, D-33's entangled slot, still stands in.)
+        // (Read behind `guessed`: a bundle without optimism drops the reads.)
+                if (guessed && e.l & CONFIG_GUESS && e.T.Je?.V && resolveTx(e.T.Je._parent) !== resolveTx(n._parent)) take(e, n); else if (!t) e.l &= ~CONFIG_GUESS;
+    }
+    // A leaf has no lane value to seat it (`recompute`): one left waiting on
+    // the lane's flight runs its next pass as the lane's — the landing that
+    // wakes it is the lane's re-staging (A31), and the lane holds its render
+    // effects until its derivations land (A17; #3766, F5). Not a leaf whose
+    // seat is its frame's, reached by a propagation from a node the screen has
+    // a value of: one a transaction holds (born held — its frame waits on it,
+    // A29), or one whose own mainline pass is running (it pulled the node;
+    // `laneRead` decides — its frame holds). Its pending is the frame's: queued
+    // for the commit sweep as mainline's (async.ts). A node born in the lane
+    // has nothing on screen: its leaf waits as the lane's.
+     else if (t) {
+        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Je?.V) {
+            queuePendingNode(e);
+            return false;
+        }
+        e.R |= REACTIVE_LANE_DIRTY;
+    }
+    list(e, n);
+    return true;
+}
+
+/** The truth arrived for a written guess (A18): a correction dissolves the
+ * lane — the guess and everything derived from it is void, the truth is
+ * the parent's held write and the graph re-derives from it there, one frame
+ * at the parent's landing — while the display keeps what it shows until
+ * then. A confirmation is silent (A17): the truth stays staged beneath the
+ * guess for the parent's commit, the guess stays the value; only a reader
+ * of the truth (CONFIG_AUTHORITATIVE) is told its view changed. Either way
+ * the parent takes this node, not the tick that carried the truth (D-33):
+ * one landing answering two actions' guesses (a store re-ask over two
+ * rows) must not tie them together; a pass that derives from the held
+ * truth joins the parent on its own (`joinPass`). */
+/** The correction round is replacing a guess with the value it covered (no
+ * landing beneath it): observe's "reverted"; the lane gives back the
+ * guesses it took (#4336, `endLanes`). */ let reverting = false;
+
+function supersede(e, n, s) {
+    const t = txOf(e);
+    // Resolved: the parent may have merged into another transaction since the
+    // lane opened (two actions guessing one slot entangle, A34 (1)) — the
+    // truth is held by the transaction that lands, not the merged-away one.
+        const l = resolveTx(t._parent ?? t);
+    // A store row answered by a new object the store would reconcile into
+    // the guessed one unchanged is an echo, not a correction (#3898): the
+    // server's object never matches the guess by reference.
+        if (s && e.l & CONFIG_SLOT_NODE && GlobalQueue.sn?.(e.T.V, n)) s = false;
+    if (s) {
+        // Observe: a displayed guess is being replaced by a differing truth — a
+        // landing's (superseded), or the value it covered (reverted: the body
+        // ended with nothing coming true).
+        if (t.Nt && attrHooks !== null) attrHooks.optimisticReverted(e, e.T.V, n, reverting ? "reverted" : "superseded");
+        dissolveLane(t, l, e);
+        if (guessed && reverting) reverted.add(t);
+        // What the screen showed stays the screen until the parent lands (A18
+        // (c): display and untracked reads keep the override until the commit).
+                if (t.Nt) e.le = e.T.V;
+        e.l &= -10241;
+        e.T.V = NOT_PENDING;
+        holdNode(e, l);
+        if (e.o !== null) insertSubs(e);
+    } else {
+        e.l |= CONFIG_HELD;
+        // A confirmation is silent (A17); only truth readers are told.
+                GlobalQueue.tn?.(t);
+    }
+    e.ue = n;
+}
+
+/** A lane's end, two ways. `into === null`: the parent landed — the lane's
+ * values are the truth now: a guess lands the truth staged beneath it or
+ * reverts to the one it covered (`_value`, untouched by the guess); a
+ * derivation's latest value commits (its frame with it); what the screen
+ * showed and changes notifies. Otherwise the lane dissolves into `into`
+ * (the parent, on a correction): its values are void — what it showed stays
+ * the screen (`_value` takes it, so the parent's re-derivation compares
+ * against what is seen), a truth staged beneath a guess is the parent's to
+ * land, and the runs it held (showing the void guess) are dropped: the
+ * parent's re-derivation makes the runs that show. */ function dissolveLane(e, n, s) {
+    const t = lanes.indexOf(e);
+    if (t !== -1) lanes.splice(t, 1);
+    unlink(e);
+    // Its verdicts end with it (a correction's dissolution reaches here before
+    // `endLanes` would): the readers re-derive from the truth's notification.
+        const l = e.it;
+    if (l !== null) {
+        e.it = null;
+        if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
+    }
+    // First loads this dissolution leaves loading (below).
+        const r = [];
+    for (let t = 0; t < e.Ye.length; t++) {
+        const l = e.Ye[t];
+        const u = l.T;
+        if (l === s || u.Je !== e) continue;
+        const i = l.i;
+        const o = l.l & CONFIG_GUESS;
+        const E = u.V;
+        // What the screen shows of it (NOT_PENDING: nothing — a lane pass that
+        // errored or pends staged no value), and the lane's latest.
+                const a = e.Nt && !i ? E : l.le;
+        const f = laneValueOf(l);
+        u.V = NOT_PENDING;
+        l.l &= -10241;
+        if (n === null) {
+            // The parent landed: a guess lands the truth beneath it or reverts to
+            // the one it covered; a derivation's latest commits (its frame with
+            // it); what the screen showed and changes notifies. Observe: a
+            // displayed guess that lifts to something else — the truth staged
+            // beneath it (superseded by a landing held there) or the value it
+            // covered (reverted: nothing came true).
+            if (o && e.Nt && attrHooks !== null) {
+                const e = l.ue !== NOT_PENDING ? l.ue : l.le;
+                if (e !== E) attrHooks.optimisticReverted(l, E, e, l.ue !== NOT_PENDING ? "superseded" : "reverted");
+            }
+            // A derivation the revert re-derives (dirtied by the guess's
+            // notification — listed before it), or one still in flight, shows the
+            // lane's answer beside inputs that are the truth now: a fresh reader
+            // of its flight observes it (#3648, #3651; #3305's commit beneath a
+            // flight).
+            // Not a first load the lane produced nothing for whose own flight is
+            // up, nor one pending on such a load kept here (an identity memo of
+            // it, a derived store's derive): committing its empty `_value` would
+            // initialize it as `undefined`, which `latest()` would serve and
+            // `isPending()` call pending. It stays loading until its flight
+            // answers (D-22, A19 exc. 1; async-gen 3289 #929, 91501 #504, #156).
+                        u.Je = null;
+            if (!i && !o) E === NOT_PENDING && (l.m & (STATUS_UNINITIALIZED | STATUS_PENDING)) === (STATUS_UNINITIALIZED | STATUS_PENDING) && (u.Ee || r.some(e => u.se?.has(e))) ? r.push(l) : l.ue = f;
+            commitPendingNode(l);
+            if (!i) {
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.m & STATUS_PENDING) l.l |= CONFIG_INPUTS_PUBLISHED;
+                if (a !== NOT_PENDING && (!l.je || !l.je(a, l.le))) insertSubs(l);
+            }
+            // A stale reader's own error — its pass (a memo's or a render
+            // effect's) threw over the committed value of what the parent held
+            // (A10), served as the screen — is no answer of the world landing now:
+            // it re-derives on it (A15; D-39, the landing is the new answer). The
+            // landing's `reruns` skips an errored reader: its error is an errored
+            // source's (#3945).
+                        if (l.R & REACTIVE_FRAME_READ && l.m & STATUS_ERROR && u.U.source === l) enqueueSub(l);
+        } else if (o) {
+            // A guess of a dissolving lane: its truth — a landing held beneath it,
+            // else the value it covered — is the parent's to land, and its readers
+            // re-derive from it there. What the screen showed stays the screen
+            // until then (A18 (c)).
+            if (l.ue === NOT_PENDING) l.ue = covered(l);
+            if (e.Nt) l.le = E;
+            holdNode(l, n);
+            insertSubs(l);
+        } else {
+            // A correction: the lane's derivations are void. Shown, what the
+            // screen showed stays the screen (committed, inputs published — every
+            // one re-derives); never shown, nothing of it reached the screen (a
+            // node born in the lane stays uninitialized; its frame goes). One in
+            // flight is asking the void world's question: its landing is nobody's
+            // answer — it re-asks from the truth (whose notification may not reach
+            // it: an input's truth equal to its committed value is silent).
+            u.Je = null;
+            if (!i) {
+                if (a !== NOT_PENDING && e.Nt) l.ue = a;
+                if (l.m & STATUS_PENDING) {
+                    u.Ee = null;
+                    enqueueSub(l);
+                }
+            }
+            if (e.Nt) {
+                commitPendingNode(l);
+                if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
+            } else {
+                if (u.ft !== null || u.Tt !== null) GlobalQueue.et(l, false, true);
+                l.l &= -1048961;
+            }
+        }
+    }
+    // The parent landed: the runs the lane held (blocked on its own judgment
+    // alone — a zombie it could not dispose) are the landing's. A correction
+    // of a SHOWN lane keeps its runs too: "what it showed stays the screen"
+    // means the runs this round's lane passes queued (the body-end seam judges
+    // before the lane seam would have released them) must reach the screen —
+    // their derivations' values are the committed ones now, and a
+    // re-derivation that lands on the same value notifies nobody (a mapArray
+    // whose rows the lane pass already built). A never-shown lane's runs are
+    // void: nothing of it reached the screen. So are the runs a blocked lane
+    // parked: they show a re-guess the seam never revealed, beside derivations
+    // that keep what the screen showed.
+        if (n === null || e.Nt && !e.ln) releaseQueues(e); else e.rn[0].length = e.rn[1].length = 0;
+}
+
+/** Lanes. A lane's node is read by its reader's kind: an authoritative
+ * reader (`until`) sees the truth — staged beneath a guess, else committed
+ * — and is no lane's; an untracked read sees the lane's latest value (A17:
+ * "direct read shows optimistic"; A28); a children-forbidden reader sees
+ * the frame (A32). A render effect in the frame's seat reading a lane the
+ * seam found blocked, or a member whose own flight is up (held or not — the
+ * lane-membership ruling, 2026-10-05), sees the screen, re-derived at the
+ * reveal (#3460's stale reader) — or, the node a
+ * flight that has never shown (nothing to show), waits on it: its own frame
+ * holds (A15, #3334), not the lane's parent. Any other tracked reader is
+ * the lane's work from this read — a derivation; a leaf reading a lane that
+ * has shown, or one the seam has not judged yet (its run waits on the
+ * verdict: released if the lane shows, held if it blocks) — and sees the
+ * lane's latest. NOT_PENDING falls through: lane work's read of a pending
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */ function laneRead(e, n) {
+    const s = n.l & CONFIG_GUESS;
+    const t = txOf(n);
+    // A lane a correction folded under (D-34): store/optimistic.ts reads it.
+    // Before the authoritative arm: an `until` outside the lane reads the
+    // same truth there, and joins the hold it folded into — its posture over
+    // a foreign hold (D-31), which the truth read alone would not take.
+        const l = e !== null && t.folded;
+    if (l) {
+        const s = l(e, n);
+        if (s !== NOT_PENDING) return s;
+    }
+    if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.un(n);
+    const r = n.m;
+    // An errored member's lane value predates its error; the error is the answer (#4106).
+        if (!s && r & STATUS_ERROR) return NOT_PENDING;
+    if (e === null) return laneValueOf(n);
+    const u = !s && r & STATUS_PENDING;
+    if (!tracking || e.l & CONFIG_CHILDREN_FORBIDDEN) {
+        // An untracked read inside lane work derives from the lane like a
+        // tracked one, minus the subscription — `untrack` is about
+        // dependencies, not about which world a pass derives from (a mapper's
+        // row reads under its root, store/map): the pass enters the lane (two
+        // lanes read by one pass link, as for tracked reads). Outside lane
+        // work, the screen.
+        if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
+    } else if (e.i === EFFECT_RENDER) {
+        // A flight whose value has never shown: nothing to show — the leaf
+        // waits on it, and its own frame holds (A15, #3334), not the lane's
+        // parent. The landing lands the frame: its own pass (the flush joined
+        // its transaction) reads the answer it waited on — the lane's staging,
+        // revealed at this seam.
+        const l = u && n.T.V === NOT_PENDING;
+        // D-28: a leaf a verdict read moved into the lane still throws on such
+        // a flight — the pass leaves the lane, and its frame holds as if the
+        // read had come first (S-39, #4275). Nor does a verdict lane's seat carry
+        // the leaf into another lane (no link): it reads that lane as from the
+        // frame's seat (#4284).
+                if ((l || passLane !== t) && passLane?._parent.it === passLane) setPassLane(null);
+        if (passLane === null || !sameLane(passLane, t)) {
+            // (A lane that has never shown: the screen is the committed value.)
+            if (l && t.Nt) return NOT_PENDING;
+            if (!s && n.ue !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ue;
+            if (t.ln || u) {
+                // Re-derived at the reveal; once per pass (the pass may also be a stale
+                // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
+                // Before the throw below: a leaf that waits on a lane that has never
+                // shown has no flight to settle it — only the reveal re-derives it,
+                // and its pending holds its frame until then (#4338).
+                if (!(e.R & REACTIVE_SCREEN_READ)) {
+                    e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
+                    t.En.push(e);
+                }
+                // Nothing on screen yet (uninitialized: `display` is NOT_PENDING).
+                                const s = display(n);
+                if (s === NOT_PENDING) throw new NotReadyError(null);
+                return s;
+            }
+            // A verdict reader reads ahead of the seam's verdict: re-derived on the
+            // screen if the lane holds (#4284).
+                        if (e.l & CONFIG_VERDICT && t._parent.it !== t) entered.push(e);
+        }
+    }
+    enterLane(t, e);
+    return u ? NOT_PENDING : laneValueOf(n);
+}
+
+/** The value a guess covered: the node's committed value — a store slot's
+ * asked of the store (a chained link follows the inner store's commits). */ function covered(e) {
+    return e.l & CONFIG_SLOT_NODE && GlobalQueue.an !== undefined ? GlobalQueue.an(e) : e.le;
+}
+
+/** A guess in `l` whose own truth is in flight (its refetch — authoritative:
+ * the landing supersedes, not the body's end). */ function guessFlights(e) {
+    for (let n = 0; n < e.Ye.length; n++) {
+        const s = e.Ye[n];
+        if (s.l & CONFIG_GUESS && s.T.Je === e && inFlight(s)) return true;
+    }
+    return false;
+}
+
+/** The seam's verdict on a lane. Blocked — its own flight is up — nothing
+ * moves: the screen keeps what it shows, the lane's runs wait. Unblocked,
+ * the lane shows: its values are the screen from now (`_shown`), the
+ * staging its passes made since the last reveal is promoted, their frames
+ * (children) apply, the stale readers re-derive (#3460), its runs go. */
+/** A18 body-end corollary (#3427), at the seam before the park decision
+ * (the guesses' own passes have run; a correction's re-derivations run in
+ * one more pure round and are the parent's flights before it is judged —
+ * #3409: the indicators clear together): the action body having returned,
+ * a guess whose own truth is not in flight has no answer coming — the truth
+ * beneath it is its truth, and the correction starts now rather than at the
+ * lane's flight. (A guess whose own refetch is up is superseded by its
+ * landing.) True when a lane was judged. */ function laneCorrections() {
+    let e = false;
+    const n = lanes.slice();
+    for (let s = 0; s < n.length; s++) {
+        const t = n[s];
+        if (lanes.indexOf(t) === -1) continue;
+        const l = resolveTx(t._parent);
+        if (!l.nt || l.tt !== 0 || l.V || ownFlights(l) || guessFlights(t)) continue;
+        e = true;
+        // Each guess's truth: the one beneath it (a landing held there), else
+        // the one it covered. (A correction dissolves the lane — the others are
+        // re-homed with theirs, `dissolveLane`.)
+                for (let e = 0; e < t.Ye.length && lanes.indexOf(t) !== -1; e++) {
+            const n = t.Ye[e];
+            if (n.l & CONFIG_GUESS && n.T.Je === t) {
+                const e = n.ue !== NOT_PENDING ? n.ue : covered(n);
+                reverting = n.ue === NOT_PENDING;
+                supersede(n, e, !n.je || !n.je(n.T.V, e));
+                reverting = false;
+            }
+        }
+    }
+    return e;
+}
+
+function laneSeam(e, n) {
+    // Blocked — or one of its passes read a write the frame holds this seam:
+    // its runs wait, the pass re-derives on the screen next round.
+    if (n || blocked(e)) {
+        e.ln = true;
+        return;
+    }
+    e.ln = false;
+    e.Nt = true;
+    if (reruns(e)) revealing.push(resolveTx(e._parent));
+    for (let n = 0; n < e.Ye.length; n++) {
+        const s = e.Ye[n];
+        if (s.R & LEFT_SHOWN) {
+            s.R ^= LEFT_SHOWN;
+            insertSubs(s);
+        }
+        const t = s.T;
+        if (t.Je !== e) continue;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
+            t.V = s.ue;
+            s.ue = NOT_PENDING;
+        }
+        // The frame this pass built is the screen's now; the one it replaced
+        // goes (as `commitPendingNode` retires a committed pass's).
+                if (t.ft !== null || t.Tt !== null) GlobalQueue.et(s, false, true);
+        s.l &= ~CONFIG_STAGED;
+    }
+    releaseQueues(e);
+}
+
+/** The parent landed: its lanes end, nested first. (None is blocked: a
+ * blocked lane blocks its parent.) */ function endLanes(e) {
+    // A revert landing (#4336): the guesses its lane took from another action
+    // that is still out come back in this frame, over the truth it lands —
+    // its readers re-derive with the landing (one frame, no bare truth
+    // between). Taken by a later lane since, a node stays that lane's.
+    if (guessed) for (let n = kept.length - 5; n >= 0; n -= 5) if (resolveTx(kept[n + 4]._parent) === e) {
+        let [s, t, l, r, u] = kept.splice(n, 5);
+        // (A store slot's node now: the one taken, or a read's since.)
+                if (reverted.has(u) && lanes.includes(l) && (!(s.l & CONFIG_SLOT_NODE) || (s = GlobalQueue.fn(s, true)))) {
+            const n = ext(s);
+            if (n.Je === null || txOf(s) === e) {
+                commitPendingNode(s);
+                n.V = t;
+                n.Ie = r;
+                s.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
+                list(s, l);
+                rerun(s, e);
+            }
+        }
+    }
+    for (let n = lanes.length - 1; n >= 0; n--) {
+        const s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        endLanes(s);
+        dissolveLane(s, null);
+    }
+}
+
+/** A blocked lane blocks its parent (maintainer, 2026-10-01): the lane's
+ * pending work derives from the frame's write through the guess, so the
+ * frame is not complete without it (A15) — landing it would commit the write
+ * beside a derivation still showing the old one. A guess whose own flight is
+ * up likewise: the question was asked in this frame. */ function lanesBlocked(e) {
+    return e.V && linkBlocked(e) || nestedBlocked(e);
+}
+
+/** Parents whose lane revealed this seam with readers to re-derive there
+ * (`laneSeam`): the lane shows ahead of its parent (F-6), so the parent lands
+ * a round later — after those readers have shown the lane's answer — even
+ * when nothing else holds it (#4393). */ const revealing = [];
+
+/** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
+    if (revealing.indexOf(e) !== -1) return true;
+    for (let n = 0; n < lanes.length; n++) {
+        const s = lanes[n];
+        if (resolveTx(s._parent) !== e) continue;
+        if (blocked(s) || guessFlights(s)) return true;
+    }
+    return false;
+}
+
+/** A write landing on a lane's node (core.ts `setSignal`: a user's write, an
+ * async landing). On a guess it is its truth (A18 — an async guess's own
+ * landing), judged against the guess. On a derivation it is the lane's
+ * latest: its staging once the lane has shown (promoted at the next
+ * reveal), its slot before; the lane's members re-derive as its work. */ function laneWrite(e, n) {
+    // (A store slot's guess its derive's re-ask in another action's lane
+    // writes is that lane's derivation from here — store `_slotTake`, #4336.)
+    if (e.l & CONFIG_GUESS && !(guessed && GlobalQueue.fn?.(e))) {
+        // Provenance (A18, #3331; Q-D, plan sec. 39): a write asking an OLDER
+        // question than the guess's — another action's landing beneath it —
+        // is not its answer: held beneath (the truth for the commit; the
+        // guess's own question judges), and nothing moves. The writer's
+        // question is the one being asked (`question`: a slice's, a derive's
+        // continuation's — the flight's); unstamped writes and mainline are
+        // current.
+        // A store re-bases a keyed arrangement guess over an older truth, and
+        // folds a current one beneath it (D-34): true.
+        const s = stale(e, question);
+        if (GlobalQueue.Nn?.(e, n, s) || s) {
+            e.ue = n;
+            e.l |= CONFIG_HELD;
+            schedule();
+            return n;
+        }
+        supersede(e, n, !e.je || !e.je(e.T.V, n));
+    } else {
+        const s = txOf(e);
+        if (e.je && e.je(laneValueOf(e), n)) return n;
+        if (s.Nt) e.ue = n; else e.T.V = n;
+        if (e.X !== undefined) e.ie = clock;
+        insertSubs(e);
+        laneDirty(e, s);
+    }
+    schedule();
+    return n;
+}
+
+/** A written guess's own pass finished: its source recomputed it — the
+ * truth (A18: "the source is whatever recomputes the node"), authoritative
+ * or the lane's own derivation (a guess over `config().courier` under a
+ * country guess: the lane's config landing confirms or corrects it). An
+ * errored pass stages nothing. Provenance (A18, #3331): "the source" is the
+ * guess's own question or a newer one; an older action's answer landing
+ * over a newer guess (the two entangled when the newer guess was written)
+ * is stale — a slow source leaking back in over the user's latest intent.
+ * It is staged beneath the guess, for the commit like any landing, and
+ * nothing moves: no downstream re-ask, no pending flip on the guess's
+ * readers (`isPending` of the guess itself says the held truth differs,
+ * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, s) {
+    if (s) return true;
+    if (stale(e, answered(e))) {
+        e.ue = n;
+        e.l |= CONFIG_HELD;
+        return true;
+    }
+    supersede(e, n, !e.je || !e.je(e.T.V, n));
+    return true;
+}
+
+/** THE provenance test, for a derivation's pass and a write alike: an
+ * answer to question `q` landing on a guess is stale when `q` is older
+ * than the guess's own; unstamped (0) and mainline are current. */ function stale(e, n) {
+    return n !== 0 && n < e.T.Ie;
+}
+
+/** The question a derivation's pass answered: the newest among the stamped
+ * sources that changed this round (a flight's landing carries the question
+ * that started it); 0 when none is stamped. */ function answered(e) {
+    let n = 0;
+    for (let s = e.C; s !== null; s = s.G) {
+        const e = s.S;
+        if (e.T !== null && e.T.Ie > n && e.ie === clock) n = e.T.Ie;
+    }
+    return n;
+}
+
+/** The lanes alive before this seam's guesses opened theirs (a prefix of
+ * `lanes`; nothing dissolves one between here and the seam loop): a lane
+ * born at the seam has no work to judge yet (its passes run next round) —
+ * it is neither shown nor blocked until it has. */ let judged = 0;
+
+const applyGuessesAt = e => {
+    judged = lanes.length;
+    if (pendingGuesses.length !== 0) applyGuesses(e);
+};
+
+/** `t` is parked by `r`'s pass alone: each node keeping it — `t`'s own, or
+ * a lane's under it — is `r` itself (its flight, in the verdict lane) or a
+ * render effect pending on `r` only: the frame observing the lane work that
+ * read its staging. Anything else (an open action, a guess's flight,
+ * another flight) holds it on its own. */ function heldBy(e, n) {
+    if (e.tt !== 0 || e.V && linkBlocked(e)) return false;
+    for (let s = -1, t = e; t; t = lanes[++s]) if (t === e || resolveTx(t._parent) === e) {
+        if (t !== e && guessFlights(t)) return false;
+        for (let e = 0; e < t.Ye.length; e++) {
+            const s = t.Ye[e];
+            if (s === n || !(s.m & STATUS_PENDING) || s.T.Je !== null && txOf(s) !== t) continue;
+            const l = s.T.se;
+            if (s.i !== EFFECT_RENDER || l?.size !== 1 || !l.has(n)) return false;
+        }
+    }
+    return true;
+}
+
+const laneSeams = e => {
+    // Passes that read a write the parked frame holds as the screen
+    // (`stagedReaders`: lane work, a verdict reader before the verdict): they
+    // re-derive on the committed world next round (and register as stale
+    // readers of the transaction there); a lane's runs wait that round — a
+    // lane sees the screen plus its own guesses.
+    if (revealing.length) revealing.length = 0;
+    const n = [];
+    if (e !== null) for (let s = 0; s < stagedReaders.length; s++) {
+        const t = stagedReaders[s], 
+        // A pass no transaction holds that read the frame's staging (an
+        // effect, a `[s(), latest(s)]` reader watched before the frame had
+        // a transaction): judged by the frame's — it re-derives only if the
+        // frame stays parked; landing here, what it read is the screen (one
+        // run, D-22).
+        l = t.T?.Je || (t.R & REACTIVE_STAGED_READ ? e : null);
+        // A verdict reader a later read of the same pass routed into a verdict
+        // lane answered for itself: it re-derives at the holder's landing, not
+        // now (one run — #3322, #3540). Other verdict-lane work re-derives only
+        // if the frame stays parked: a transaction landing at this seam makes
+        // what it read the screen (one run). The frame is the transaction that
+        // holds what it read (`t`, this flush's — not always the lane's parent:
+        // a landing that reached a frame held elsewhere joined that one). Nor
+        // when only this pass keeps it parked (`heldBy`): the frame lands with
+        // the pass's answer, so what the pass read is the screen when anything
+        // shows it — re-derived on the committed world, it would ask a question
+        // already asked, over inputs the landing replaces. A reader a
+        // transaction holds that read none of its stagings (a verdict reader
+        // that probed only a flight, held as the frame's pending observer or
+        // its staged derivation) has nothing to re-derive: its re-run
+        // re-enters that transaction and parks it again, every round — it
+        // runs at the landing (#4349). One that read a staging re-derives only
+        // if its frame stays parked: landing at this seam, what it read is the
+        // screen (one run, D-22). Not one born into that frame (a held pass's
+        // child, ruling A): it has no screen, its reads are the transaction's
+        // either way — it runs again at the landing, not now.
+                if (t.R & REACTIVE_DISPOSED || (l?.V ? l._parent?.it === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(e) || heldBy(e, t)) : l && !(t.R & REACTIVE_PROBE_UNANSWERED || t.R & REACTIVE_STAGED_READ && blocked(l) && !bornInto(t, l)))) continue;
+        // A leaked effect re-derives seated in its lane from its first read: it
+        // carries no lane value (`laneStage`), so without this its pass starts
+        // as mainline, joins the parked frame on its first held read and reads
+        // the staging, then re-enters the lane at its guess read and leaks
+        // again — every round (#4014). A computed is already seated by its
+        // override, and a written guess's own pass stays the frame's.
+                if (l?.V && t.i) t.R |= REACTIVE_LANE_DIRTY;
+        // R5 for an async reader: its frame pass asked the frame's question
+        // (F-6's lane gets its own pass now). That flight is the frame's
+        // answer: the landing adopts it rather than asking it again (F-9: a
+        // re-ask of the same question is no new question; `reruns`). A frame
+        // landing at this seam has nothing to re-derive: the pass was the
+        // landing's, its flight the screen's answer. Sync or async, the
+        // reader's lane pass is still to come: the verdict lane it joins does
+        // not reveal this seam (F-6: the lane's readers show its answer
+        // together, D-23: atomic with the value) — revealed now, it showed a
+        // verdict beside the frame pass's value, before the pass that answers
+        // for the lane, and a reader of the re-derived memo read it outside
+        // the shown lane and waited for the frame (#4393).
+         else if (!l?.V && t.R & REACTIVE_PROBE_UNANSWERED) {
+            if (isThenable(t.T?.Ee)) {
+                if (!blocked(e)) continue;
+                t.T.rt = t.T.Ee;
+            } else if (blocked(e)) 
+            // A sync reader's lane pass re-derives the async memos over it (a
+            // memo over a verdict memo is a verdict reader, D-25 #4050; D-22:
+            // `latest()` extracted into a memo reads as inline). The flight
+            // each asked over its frame staging, up and held by `t`, is the
+            // frame's answer too: the landing adopts it (F-9).
+            for (let n = t.o, s; n; n = n.t) if (isThenable((s = n.u).T?.Ee) && s.T.se?.has(s) && s.l & CONFIG_HELD && txOf(s) === e) s.T.rt = s.T.Ee;
+            if (e?.it && n.indexOf(e.it) === -1) n.push(e.it);
+        }
+        enqueueSub(t);
+        if (l?.V && n.indexOf(l) === -1) n.push(l);
+    }
+    // A verdict lane born at this seam is judged with it: it exists only once
+    // a pass routed into it — the park seam's zombie verdict readers re-run
+    // as its work so that this seam reveals them (#3444).
+        for (let e = lanes.length - 1; e >= 0; e--) if (e < judged || lanes[e]._parent?.it === lanes[e]) laneSeam(lanes[e], n.indexOf(lanes[e]) !== -1);
+    // A verdict reader that entered a lane this seam held: its run waits with
+    // the lane, and the verdict beside it would freeze — it re-derives next
+    // round from the frame's seat, a stale reader of the lane (#4284).
+        for (let e; e = entered.pop(); ) if (e.T.Je?.ln) {
+        e.R &= ~REACTIVE_LANE_DIRTY;
+        enqueueSub(e);
+    }
+};
+
+/** The landing's re-derive of a reader whose frame flight the seam parked
+ * (R5): the flight asked the question the landing would — adopted, it is
+ * asked once (F-9). Not over a pass already queued: that one asks anew.
+ * Registered as if this pass had returned it — the node pending on it, its
+ * landing the answer — through a promise of its own: the frame pass's
+ * registration still listens to the flight, and must not land it a second
+ * time. */ const adoptParked = e => {
+    const n = e.T?.rt;
+    if (!n || e.R & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP)) return false;
+    e.T.rt = undefined;
+    releaseFlightTeardown(e);
+    try {
+        handleAsync(e, n.then());
+    } catch {}
+    e.T.fe = true;
+    notifyStatus(e, STATUS_PENDING, new NotReadyError(e));
+    return true;
+};
+
+/** A15: lane work or a verdict reader was served `el`'s committed value
+ * (core.ts `frameRead`), so its pass does not wait on `el`'s flight: what
+ * `el`'s pending propagated onto it before the pass (its origins, `el`
+ * included) is not this pass's — the landing re-derives it (`reruns`).
+ * Kept, a pass that went pending on another source never woke when that
+ * source settled (#4397). Only a reader something made pending has anything
+ * to drop. */ const laneServed = (e, n) => {
+    const s = n.T?.se;
+    if (s && e.T?.se) for (const n of s) removePendingSource(e, n);
+};
+
+/** Render effects that read a verdict and entered a lane before its seam (#4284). */ const entered = [];
+
+installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked, adoptParked, laneServed);
+
+GlobalQueue.xe = e => {
+    const n = [];
+    for (let s = 0; s < lanes.length; s++) {
+        const t = lanes[s];
+        if (resolveTx(t._parent) !== e) continue;
+        for (let e = 0; e < t.Ye.length; e++) if (t.Ye[e].l & CONFIG_GUESS && t.Ye[e].T.Je === t) n.push(t.Ye[e]);
+    }
+    return n;
+};
+
+GlobalQueue.J = verdictLane;
+
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, take, verdictLane };