@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.15

package/dist/prod/core/lanes.js

@@ -1,205 +1,736 @@
-import { CONFIG_DERIVED_OVERRIDE, CONFIG_HAS_LANE, REACTIVE_DISPOSED } from "./constants.js";
+import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, REACTIVE_LANE_DIRTY, CONFIG_AUTHORITATIVE, CONFIG_CHILDREN_FORBIDDEN, STATUS_PENDING, EFFECT_RENDER, CONFIG_HELD, STATUS_UNINITIALIZED, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_RECOMPUTING_DEPS, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ, CONFIG_SLOT_NODE, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_INPUTS_PUBLISHED } from "./constants.js";
 
-import { hasActiveOverride, ext, ownsHold, currentOptimisticLane } from "./core.js";
+import { tracking, ext, stagedRead } from "./core.js";
+
+import { NotReadyError } from "./error.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { currentTransition, activeTransition, waitingTransition } from "./scheduler.js";
-
-// Map from optimistic signal to its lane (reused for multiple writes to same signal)
-const signalLanes = new WeakMap;
-
-// All active lanes (for cleanup on transition completion)
-const activeLanes = new Set;
-
-/**
- * Get an existing lane for a signal or create a new one.
- * Reuses lane for multiple writes to the same signal.
- */ function getOrCreateLane(n) {
-    let e = signalLanes.get(n);
-    if (e) {
-        return findLane(e);
-    }
-    // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
-    // The child lane should not merge with the parent lane.
-        const i = n.o?.kn;
-    const t = i?.o?.me;
-    const r = t ? findLane(t) : null;
-    e = {
-        ni: n,
-        Qe: new Set,
-        dn: [ [], [] ],
-        ei: null,
-        we: activeTransition,
-        ii: r
-    };
-    signalLanes.set(n, e);
-    activeLanes.add(e);
-    // A companion may have written before the owner's first optimistic write
-    // (affects() as an action's first statement pokes the verdict companion of a
-    // still lane-less node, #2887), leaving its lane parentless. Adopt it now:
-    // parent-child is a property of the nodes, not of write order — otherwise
-    // the owner's write merges the companion's subscribers into this lane and
-    // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.o?.Ze, e);
-    adoptCompanionLane(n.o?.He, e);
-    return e;
+import { schedule, question, nextQuestion, GlobalQueue, blocked, txOf, passLane, sameLane, flushTransaction, resolveTx, queuePendingNode, list, clock, insertSubs, laneDirty, merge, newTransaction, reruns, releaseQueues, ownFlights, setPassLane, holdNode, joinFuture, commitPendingNode } 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;
+}
+
+/** A lane node's current value: its guess, or the latest it derived — the
+ * staging a shown lane holds for its next reveal, else its slot; the
+ * committed value while it has none (its first lane pass in flight). */ function laneValueOf(e) {
+    if (!(e.i & CONFIG_GUESS) && e.Oe !== NOT_PENDING) return e.Oe;
+    const n = e.m.B;
+    return n !== NOT_PENDING ? n : e.Ae;
 }
 
-function adoptCompanionLane(n, e) {
-    if (!n) return;
-    const i = signalLanes.get(n);
-    if (!i) return;
-    const t = findLane(i);
-    // Only the companion's own unmerged root is safely re-parentable: a root
-    // that absorbed other lanes carries work that is not a child of this owner.
-        if (t !== e && t.ni === n && !t.ii) t.ii = e;
+/** What the screen shows for a lane's node: the lane's value once the lane
+ * has revealed, the committed truth before. */ function display(e) {
+    const n = e.m.B;
+    return e.m.He.Ze && n !== NOT_PENDING ? n : e.Ae;
 }
 
-/**
- * Union-find: find the root lane.
- */ function findLane(n) {
-    while (n.ei) n = n.ei;
+/** 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) {
+    const n = pendingGuessOf(e);
+    if (n !== NOT_PENDING) return n;
+    return e.i & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ae;
+}
+
+/** 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;
+}
+
+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 t = guessedValueOf(e);
+    if (typeof n === "function") n = n(t);
+    if (e.ye && e.ye(t, n) && !(e.i & CONFIG_GUESS)) return n;
+    pendingGuesses.push(e, n, question || nextQuestion());
+    schedule();
     return n;
 }
 
-/**
- * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); a transaction's reporter map records the async a render effect
- * OBSERVED pending with no boundary taking it (INV-3, the one registration
- * site). A hold needs both — the same rule the transaction itself uses, so a
- * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
- * a frame and holds nothing (#3289). An orphan lane has no observation record
- * and never holds.
- *
- * The observation is looked up per NODE, in whichever live transaction
- * recorded it — not in this lane's transaction. Lanes merge across
- * transactions (#2912: ownership never travels through lanes), so after a
- * merge the root's transaction holds the observations of only one member;
- * the async the other member's transaction observed must hold the merged
- * reveal just the same (A15 for lanes, #3335).
- */ function laneHeld(n) {
-    if (!n.we) return false;
-    for (const e of n.Qe) if (waitingTransition(e) !== null) return true;
+/** 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.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(e) === true;
+}
+
+function applyGuesses(e) {
+    let n = null;
+    for (let t = 0; t < pendingGuesses.length; t += 3) {
+        const u = pendingGuesses[t];
+        const l = pendingGuesses[t + 1];
+        let s = true;
+        if (u.i & 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). Two
+            // suggestions for one slot cannot finish apart (A34 (1)): the frames
+            // entangle. The same value re-asked renews the question; nothing to
+            // notify.
+            s = !u.ye || !u.ye(laneValueOf(u), l);
+            if (!(u.i & CONFIG_GUESS)) {
+                u.Oe = NOT_PENDING;
+                u.i |= CONFIG_GUESS;
+            }
+            u.m.B = l;
+            const n = txOf(u)._parent;
+            if (e !== null && n !== null) merge(e, n);
+        } else {
+            let t;
+            if (u.i & CONFIG_HELD) t = newLane(txOf(u)); else {
+                if (e === null && inFlight(u)) e = newTransaction(false);
+                if (e === null) continue;
+                t = 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(u).B = l;
+            u.i |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(u, t);
+        }
+        ext(u)._e = pendingGuesses[t + 2];
+        if (s) {
+            // 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(u);
+            laneDirty(u, txOf(u));
+        }
+    }
+    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) {
+    n.R |= REACTIVE_LANE_READ;
+    const t = passLane;
+    if (t === null) {
+        setPassLane(e);
+        // The pass read a held write before its first lane read (it joined the
+        // frame's future as mainline would): lane work sees the screen — the
+        // seam re-derives it on the committed world next round (`stagedReaders`,
+        // the park's repair), as it does a lane pass that read a staging. Not a
+        // pass whose held reads were all of nodes born held (no staged read,
+        // `stagedRead`): it has no committed world to re-derive on (#3969).
+                if (n.R & REACTIVE_JOINED && n.R & REACTIVE_STAGED_READ) stagedRead(n);
+        return;
+    }
+    if (sameLane(t, e)) return setPassLane(e);
+    if (under(t, e)) return;
+    if (under(e, t)) return setPassLane(e);
+    linkLanes(t, e);
+    setPassLane(e);
+}
+
+/** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
+    for (let t = e._parent; t !== null && t.B; t = t._parent) if (t === n) return true;
     return false;
 }
 
-/**
- * Lanes mirror transitions (#3460): a render effect OFF a HELD lane that reads
- * a value the lane is revealing — an override, a `latest()` shadow — sees the
- * committed value, exactly as a stale reader of a held transaction does
- * (A15 reveal corollary): it publishes now, with the frame that is on screen
- * (the lane defers its own readers' runs, so the committed value is what is
- * visible), entangles nothing — a sync write is never held by a lane — and
- * re-derives at the release. The release re-run rides the lane's own render
- * queue, which runs when the lane reveals (runLaneEffects) or its transaction
- * commits (cleanupCompletedLanes). A reader ON the lane computes the lane's
- * reveal and takes the value as before.
- *
- * OFF the lane is provenance, not membership — the transaction mirror
- * exactly: a stale reader of a transaction is a pass that runs outside it. A
- * pass under the lane's own transaction is the lane's work — its write (lane
- * posture), or the landing of its async, which re-enters the transaction
- * (#3334) and runs a member with no ambient lane. Read as an outsider, that
- * pass published the committed view and queued a replay that revealed the
- * override beside its unready derivation at the release (`1:0` for an
- * optimistic frame that never became ready; #3479 review). Membership is the
- * wrong test the other way: a member re-run by a sibling's sync write is a
- * mainline pass and shows the committed view.
- */ function readsHeldCommitted(n, e) {
-    const i = resolveLane(n);
-    if (!i || !laneHeld(i)) return false;
-    if (ownsLane(i, n)) return false;
-    i.dn[0].push(() => e.oe & REACTIVE_DISPOSED || enqueueSub(e));
-    return true;
+/** One link group (a shared array) for both lanes' groups. */ function linkLanes(e, n) {
+    const t = e.nn ?? (e.nn = [ e ]);
+    const u = n.nn;
+    if (u === t) return;
+    if (u === null) {
+        t.push(n);
+        n.nn = t;
+    } else for (let e = 0; e < u.length; e++) {
+        t.push(u[e]);
+        u[e].nn = t;
+    }
 }
 
-/** The ownership relation for a lane hold (core `ownsHold`, §6 ruling 2): the
- * running pass owns `lane`'s hold if it runs under the transition that owns
- * the lane (the node's, resolved through override ownership and merges) or
- * inside the lane itself. */ function ownsLane(n, e) {
-    if (activeTransition !== null) {
-        const n = resolveTransition(e);
-        if (n && ownsHold(n)) return true;
-    }
-    return currentOptimisticLane !== null && findLane(currentOptimisticLane) === n;
-}
-
-/**
- * Merge two lanes when their dependency graphs overlap.
- */ function mergeLanes(n, e) {
-    n = findLane(n);
-    e = findLane(e);
-    if (n === e) return n;
-    e.ei = n;
-    // Move (not copy) the merged lane's work: after the merge all routing goes
-    // through findLane() to the root, so anything left behind here is dead —
-    // and anything *added* here later is a routing bug (INV-5).
-        for (const i of e.Qe) n.Qe.add(i);
-    e.Qe.clear();
-    n.dn[0].push(...e.dn[0]);
-    n.dn[1].push(...e.dn[1]);
-    e.dn[0].length = 0;
-    e.dn[1].length = 0;
-    return n;
+/** 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 t = 0; t < n.length; t++) {
+        const u = n[t];
+        if (u !== e && (u.tt !== 0 || ownFlights(u) || nestedBlocked(u))) return true;
+    }
+    return false;
+}
+
+function unlink(e) {
+    const n = e.nn;
+    if (n === null) return;
+    const t = n.indexOf(e);
+    if (t !== -1) n.splice(t, 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.xe ??= 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, t, u) {
+    if (!(t || u || e.R & REACTIVE_LANE_READ || e.i & CONFIG_GUESS)) {
+        const n = e.m;
+        if (n !== null) {
+            const t = n.He;
+            // Cleared before equality, so a return to the committed value notifies
+            // nobody. The seam wakes it unless the frame is still held (#3892).
+                        if (t?.Ze && !blocked(resolveTx(t._parent))) e.R |= LEFT_SHOWN;
+            if (t?.B) n.He = null;
+            n.B = NOT_PENDING;
+        }
+        e.i &= -1050881;
+        return false;
+    }
+    if (!e.u) {
+        if (!(e.i & CONFIG_OVERRIDE)) {
+            e.Oe = NOT_PENDING;
+            e.i = e.i & -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.
+                if (!u) e.i &= ~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 (u) {
+        if (u !== true && !(u.S & STATUS_UNINITIALIZED) && (e.i & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?.He?.B) {
+            queuePendingNode(e);
+            return false;
+        }
+        e.R |= REACTIVE_LANE_DIRTY;
+    }
+    list(e, n);
+    return true;
 }
 
-/**
- * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
- */ function resolveLane(n) {
-    const e = n.o?.me;
-    if (!e) return undefined;
-    const i = findLane(e);
-    if (activeLanes.has(i)) return i;
-    if (n.o !== null) n.o.me = undefined;
-    return undefined;
-}
-
-function resolveTransition(n) {
-    // An active override answers with its owner, not its lane: lanes are
-    // scheduling affinity and a shared subscriber merges them across
-    // transactions (#2912) — the merged root's _transition would hand this
-    // node's override to whichever action wrote last through the shared
-    // reader. Chase merge chains; a dead owner settled through another path.
-    if (hasActiveOverride(n) && n.o?.Ln) {
-        const e = ext(n).Ln = currentTransition(n.o?.Ln);
-        if (e.Rn !== true) return e;
-        if (n.o !== null) n.o.Ln = null;
-    }
-    return resolveLane(n)?.we ?? n.we;
-}
-
-/**
- * Assign or merge a lane onto a node. At convergence points (node already has
- * a different active lane), merge unless the node has an active override.
- */ function assignOrMergeLane(n, e) {
-    const i = findLane(e);
-    const t = n.o?.me;
+function supersede(e, n, t) {
+    const u = 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(u._parent ?? u);
+    // 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 (t && e.i & CONFIG_SLOT_NODE && GlobalQueue.tn?.(e.m.B, n)) t = false;
     if (t) {
-        // A merged lane is followed to its root like any other: the root is where
-        // the subscriber's affinity lives now. Replacing it with the source lane
-        // outright (as this once did) skipped the parent/child check below — an
-        // isPending reader of two async siblings had their two companion lanes
-        // merge, and the next parent-lane notification then moved it onto the
-        // held parent, where its verdict waited on the async it reports (#3409).
-        const r = findLane(t);
-        if (activeLanes.has(r)) {
-            // A WRITTEN override is its own lane's source and merges nothing
-            // through it; a derived one (lanes stage, #3479) is a plain member —
-            // the shared reader that merges two writers' lanes carries one.
-            if (r !== i && (!hasActiveOverride(n) || n.C & CONFIG_DERIVED_OVERRIDE)) {
-                // Parent-child lanes stay independent so isPending resolves without
-                // waiting for the parent's async. The child keeps ownership.
-                if (i.ii && findLane(i.ii) === r) {
-                    ext(n).me = e;
-                    n.C |= CONFIG_HAS_LANE;
-                } else if (r.ii && findLane(r.ii) === i) ; else mergeLanes(i, r);
+        dissolveLane(u, l, e);
+        // What the screen showed stays the screen until the parent lands (A18
+        // (c): display and untracked reads keep the override until the commit).
+                if (u.Ze) e.Ae = e.m.B;
+        e.i &= -10241;
+        e.m.B = NOT_PENDING;
+        holdNode(e, l);
+        if (e.t !== null) insertSubs(e);
+    } else {
+        e.i |= CONFIG_HELD;
+        // A confirmation is silent (A17); only truth readers are told.
+                GlobalQueue.un?.(u);
+    }
+    e.Oe = n;
+    joinFuture(l);
+}
+
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */ function truthRead(e) {
+    return truth(e) ? laneValueOf(e) : e.i & CONFIG_GUESS && e.Oe !== NOT_PENDING ? e.Oe : e.Ae;
+}
+
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */ function truthConfirmed(e) {
+    for (let n = 0; n < e.ln.length; n++) for (let t = e.ln[n].t; t !== null; t = t.o) if (t.l.i & CONFIG_AUTHORITATIVE) enqueueSub(t.l);
+}
+
+/** A lane node's value is the truth when every guess beneath it is
+ * confirmed — its source staged a value equal to the guess — and nothing
+ * beneath it is held in the parent: same inputs, same value. */ function truth(e) {
+    if (e.i & CONFIG_GUESS) return e.Oe !== NOT_PENDING && e.ye && e.ye(e.m.B, e.Oe);
+    if (e.Oe !== NOT_PENDING) return;
+    if (e.i & CONFIG_OVERRIDE) for (let n = e.p; n; n = n._) if (!truth(n.I)) return;
+    return 1;
+}
+
+/** 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, t) {
+    const u = lanes.indexOf(e);
+    if (u !== -1) lanes.splice(u, 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.xe;
+    if (l !== null) {
+        e.xe = null;
+        if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
+    }
+    for (let u = 0; u < e.ln.length; u++) {
+        const l = e.ln[u];
+        const s = l.m;
+        if (l === t || s.He !== e) continue;
+        const r = l.u;
+        const i = l.i & CONFIG_GUESS;
+        const o = s.B;
+        // What the screen shows of it (NOT_PENDING: nothing — a lane pass that
+        // errored or pends staged no value), and the lane's latest.
+                const E = e.Ze && !r ? o : l.Ae;
+        const f = laneValueOf(l);
+        s.B = NOT_PENDING;
+        l.i &= -10241;
+        if (n === null) {
+            // 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).
+            s.He = null;
+            if (!r && !i) l.Oe = f;
+            commitPendingNode(l);
+            if (!r) {
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.S & STATUS_PENDING) l.i |= CONFIG_INPUTS_PUBLISHED;
+                if (E !== NOT_PENDING && (!l.ye || !l.ye(E, l.Ae))) insertSubs(l);
+            }
+        } else if (i) {
+            // 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.Oe === NOT_PENDING) l.Oe = covered(l);
+            if (e.Ze) l.Ae = o;
+            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).
+            s.He = null;
+            if (!r) {
+                if (E !== NOT_PENDING && e.Ze) l.Oe = E;
+                if (l.S & STATUS_PENDING) {
+                    s.Te = null;
+                    enqueueSub(l);
+                }
+            }
+            if (e.Ze) {
+                commitPendingNode(l);
+                if (!r) l.i |= CONFIG_INPUTS_PUBLISHED;
+            } else {
+                if (s.Qe !== null || s.ve !== null) GlobalQueue.Fe(l, false, true);
+                l.i &= -1048961;
             }
-            return;
         }
     }
-    ext(n).me = e;
-    n.C |= CONFIG_HAS_LANE;
+    // 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.Ze && !e.sn) releaseQueues(e); else e.rn[0].length = e.rn[1].length = 0;
 }
 
-export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, ownsLane, readsHeldCommitted, resolveLane, resolveTransition, signalLanes };
+/** 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. */ function laneRead(e, n) {
+    const t = n.i & CONFIG_GUESS;
+    if (e !== null && e.i & CONFIG_AUTHORITATIVE) return GlobalQueue.En(n);
+    if (e === null) return laneValueOf(n);
+    const u = txOf(n);
+    const l = n.S;
+    if (!tracking || e.i & 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.i & CONFIG_CHILDREN_FORBIDDEN) return display(n);
+        enterLane(u, e);
+        if (!t && l & STATUS_PENDING) return NOT_PENDING;
+        return laneValueOf(n);
+    }
+    if (e.u === EFFECT_RENDER && (passLane === null || !sameLane(passLane, u))) {
+        if (!t) {
+            // 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.
+            if (l & STATUS_PENDING && n.m.B === NOT_PENDING) return NOT_PENDING;
+            if (n.Oe !== NOT_PENDING && e.i & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.Oe;
+        }
+        if (u.sn || !t && l & STATUS_PENDING) {
+            if (!t && !u.Ze && l & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+            // Re-derived at the reveal; once per pass (the pass may also be a stale
+            // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
+                        if (!(e.R & REACTIVE_SCREEN_READ)) {
+                e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
+                u.fn.push(e);
+            }
+            return display(n);
+        }
+    }
+    enterLane(u, e);
+    if (!t && l & STATUS_PENDING) return NOT_PENDING;
+    return 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.i & CONFIG_SLOT_NODE && GlobalQueue.Nn !== undefined ? GlobalQueue.Nn(e) : e.Ae;
+}
+
+/** 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.ln.length; n++) {
+        const t = e.ln[n];
+        if (t.i & CONFIG_GUESS && t.m.He === e && inFlight(t)) 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 t = 0; t < n.length; t++) {
+        const u = n[t];
+        if (lanes.indexOf(u) === -1) continue;
+        const l = resolveTx(u._parent);
+        if (!l.nt || l.tt !== 0 || l.B || ownFlights(l) || guessFlights(u)) 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 < u.ln.length && lanes.indexOf(u) !== -1; e++) {
+            const n = u.ln[e];
+            if (n.i & CONFIG_GUESS && n.m.He === u) {
+                const e = n.Oe !== NOT_PENDING ? n.Oe : covered(n);
+                supersede(n, e, !n.ye || !n.ye(n.m.B, e));
+            }
+        }
+    }
+    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.sn = true;
+        return;
+    }
+    e.sn = false;
+    e.Ze = true;
+    reruns(e);
+    for (let n = 0; n < e.ln.length; n++) {
+        const t = e.ln[n];
+        if (t.R & LEFT_SHOWN) {
+            t.R ^= LEFT_SHOWN;
+            insertSubs(t);
+        }
+        const u = t.m;
+        if (u.He !== e) continue;
+        if (!(t.i & CONFIG_GUESS) && !t.u && t.Oe !== NOT_PENDING) {
+            u.B = t.Oe;
+            t.Oe = 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 (u.Qe !== null || u.ve !== null) GlobalQueue.Fe(t, false, true);
+        t.i &= ~CONFIG_STAGED;
+    }
+    releaseQueues(e);
+}
+
+/** The parent landed: its lanes end, nested first. (None is blocked: a
+ * blocked lane blocks its parent.) */ function endLanes(e) {
+    for (let n = lanes.length - 1; n >= 0; n--) {
+        const t = lanes[n];
+        if (resolveTx(t._parent) !== e) continue;
+        endLanes(t);
+        dissolveLane(t, 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.B && linkBlocked(e) || nestedBlocked(e);
+}
+
+/** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
+    for (let n = 0; n < lanes.length; n++) {
+        const t = lanes[n];
+        if (resolveTx(t._parent) !== e) continue;
+        if (blocked(t) || guessFlights(t)) 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) {
+    if (e.i & CONFIG_GUESS) {
+        // 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.
+        if (stale(e, question)) {
+            e.Oe = n;
+            e.i |= CONFIG_HELD;
+            GlobalQueue.an?.(e, n);
+            schedule();
+            return n;
+        }
+        supersede(e, n, !e.ye || !e.ye(e.m.B, n));
+    } else {
+        const t = txOf(e);
+        if (e.ye && e.ye(laneValueOf(e), n)) return n;
+        if (t.Ze) e.Oe = n; else e.m.B = n;
+        if (e.ee !== undefined) e.Ie = clock;
+        insertSubs(e);
+        laneDirty(e, t);
+    }
+    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, t) {
+    if (t) return true;
+    if (stale(e, answered(e))) {
+        e.Oe = n;
+        e.i |= CONFIG_HELD;
+        return true;
+    }
+    supersede(e, n, !e.ye || !e.ye(e.m.B, 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.m._e;
+}
+
+/** 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 t = e.p; t !== null; t = t._) {
+        const e = t.I;
+        if (e.m !== null && e.m._e > n && e.Ie === clock) n = e.m._e;
+    }
+    return n;
+}
+
+GlobalQueue.rt = laneRead;
+
+GlobalQueue.W = laneStage;
+
+GlobalQueue.We = laneOutcome;
+
+GlobalQueue.Nt = laneWrite;
+
+/** 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;
+
+GlobalQueue.In = e => {
+    judged = lanes.length;
+    if (pendingGuesses.length !== 0) applyGuesses(e);
+};
+
+GlobalQueue._n = 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.
+    const n = [];
+    if (e !== null) for (let t = 0; t < e.length; t++) {
+        const u = e[t];
+        const l = u.m?.He;
+        // A verdict reader a later read of the same pass routed into a verdict
+        // lane answered for itself: it re-derives at the holder's landing, not
+        // now (one run — #3322, #3540). Other verdict-lane work re-derives only
+        // if the frame stays parked: a transaction landing at this seam makes
+        // what it read the screen (one run).
+                if (u.R & REACTIVE_DISPOSED || l != null && l._parent?.xe === l && (u.i & CONFIG_VERDICT ? !(u.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+        // A leaked effect re-derives seated in its lane from its first read: it
+        // carries no lane value (`laneStage`), so without this its pass starts
+        // as mainline, joins the parked frame on its first held read and reads
+        // the staging, then re-enters the lane at its guess read and leaks
+        // again — every round (#4014). A computed is already seated by its
+        // override, and a written guess's own pass stays the frame's.
+                if (l != null && l.B && u.u) u.R |= REACTIVE_LANE_DIRTY;
+        enqueueSub(u);
+        if (l != null && l.B && n.indexOf(l) === -1) n.push(l);
+    }
+    for (let e = Math.min(judged, lanes.length) - 1; e >= 0; e--) laneSeam(lanes[e], n.indexOf(lanes[e]) !== -1);
+};
+
+GlobalQueue.cn = () => lanes.length !== 0 && laneCorrections();
+
+GlobalQueue.Gn = endLanes;
+
+GlobalQueue.On = lanesBlocked;
+
+GlobalQueue.$ = verdictLane;
+
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, truthConfirmed, truthRead, verdictLane };