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

package/dist/observe/core/lanes.js

@@ -1,205 +1,728 @@
-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, 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, REACTIVE_LANE_DIRTY, CONFIG_STAGED, REACTIVE_JOINED, 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 { attrHooks } from "./attribution-hooks.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?.$n;
-    const t = i?.o?.Ce;
-    const r = t ? findLane(t) : null;
-    e = {
-        xn: n,
-        ke: new Set,
-        It: [ [], [] ],
-        Mn: null,
-        me: activeTransition,
-        qn: 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?.xe, e);
-    adoptCompanionLane(n.o?.Me, e);
-    return e;
+import { schedule, question, nextQuestion, GlobalQueue, blocked, resolveTx, txOf, passLane, sameLane, flushTransaction, 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 = [];
+
+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.u & CONFIG_GUESS) && e.Ae !== NOT_PENDING) return e.Ae;
+    const n = e.m.Z;
+    return n !== NOT_PENDING ? n : e.pe;
 }
 
-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.xn === n && !t.qn) t.qn = 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.Z;
+    return e.m._t.Tt && n !== NOT_PENDING ? n : e.pe;
 }
 
-/**
- * Union-find: find the root lane.
- */ function findLane(n) {
-    while (n.Mn) n = n.Mn;
+/** 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.u & CONFIG_OVERRIDE ? laneValueOf(e) : e.pe;
+}
+
+/** 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.tn && e.tn(t, n) && !(e.u & 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.me) return false;
-    for (const e of n.ke) 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.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
+}
+
+function applyGuesses(e) {
+    let n = null;
+    for (let t = 0; t < pendingGuesses.length; t += 3) {
+        const s = pendingGuesses[t];
+        const l = pendingGuesses[t + 1];
+        let u = true;
+        if (s.u & 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.
+            u = !s.tn || !s.tn(laneValueOf(s), l);
+            if (!(s.u & CONFIG_GUESS)) {
+                s.Ae = NOT_PENDING;
+                s.u |= CONFIG_GUESS;
+            }
+            s.m.Z = l;
+            const n = txOf(s)._parent;
+            if (e !== null && n !== null) merge(e, n);
+        } else {
+            let t;
+            if (s.u & CONFIG_HELD) t = newLane(txOf(s)); else {
+                if (e === null && inFlight(s)) 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(s).Z = l;
+            s.u |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(s, t);
+        }
+        ext(s).Oe = pendingGuesses[t + 2];
+        if (u) {
+            // 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(s);
+            laneDirty(s, txOf(s));
+        }
+    }
+    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.
+                if (n.R & REACTIVE_JOINED) 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.Z; 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.It[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.un ?? (e.un = [ e ]);
+    const s = n.un;
+    if (s === t) return;
+    if (s === null) {
+        t.push(n);
+        n.un = t;
+    } else for (let e = 0; e < s.length; e++) {
+        t.push(s[e]);
+        s[e].un = 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.Mn = 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.ke) n.ke.add(i);
-    e.ke.clear();
-    n.It[0].push(...e.It[0]);
-    n.It[1].push(...e.It[1]);
-    e.It[0].length = 0;
-    e.It[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.un;
+    if (n !== null) for (let t = 0; t < n.length; t++) {
+        const s = n[t];
+        if (s !== e && (s.tt !== 0 || ownFlights(s) || nestedBlocked(s))) return true;
+    }
+    return false;
+}
+
+function unlink(e) {
+    const n = e.un;
+    if (n === null) return;
+    const t = n.indexOf(e);
+    if (t !== -1) n.splice(t, 1);
+    e.un = 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.rt ??= 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, s) {
+    if (!(t || s || e.R & REACTIVE_LANE_READ || e.u & CONFIG_GUESS)) {
+        if (e.m !== null) {
+            if (e.m._t?.Z) e.m._t = null;
+            e.m.Z = NOT_PENDING;
+        }
+        e.u &= -2305;
+        return false;
+    }
+    if (!e.i) {
+        if (!(e.u & CONFIG_OVERRIDE)) {
+            e.Ae = NOT_PENDING;
+            e.u = e.u & ~CONFIG_HELD | 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 (!s) e.u &= ~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 (s) {
+        if (s !== true && !(s.G & STATUS_UNINITIALIZED) && (e.u & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.m?._t?.Z) {
+            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?.Ce;
-    if (!e) return undefined;
-    const i = findLane(e);
-    if (activeLanes.has(i)) return i;
-    if (n.o !== null) n.o.Ce = 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?.Vt) {
-        const e = ext(n).Vt = currentTransition(n.o?.Vt);
-        if (e.Dt !== true) return e;
-        if (n.o !== null) n.o.Vt = null;
-    }
-    return resolveLane(n)?.me ?? n.me;
-}
-
-/**
- * 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?.Ce;
+/** 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. */
+/** Observe: the correction round is replacing a guess with the value it
+ * covered (no landing beneath it) — `optimisticReverted`'s "reverted". */ let reverting = false;
+
+function supersede(e, n, t) {
+    const s = 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(s._parent ?? s);
     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.qn && findLane(i.qn) === r) {
-                    ext(n).Ce = e;
-                    n.C |= CONFIG_HAS_LANE;
-                } else if (r.qn && findLane(r.qn) === i) ; else mergeLanes(i, r);
+        // 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 (s.Tt && attrHooks !== null) attrHooks.optimisticReverted(e, e.m.Z, n, reverting ? "reverted" : "superseded");
+        dissolveLane(s, 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 (s.Tt) e.pe = e.m.Z;
+        e.u &= -10241;
+        e.m.Z = NOT_PENDING;
+        e.Ae = n;
+        holdNode(e, l);
+        joinFuture(l);
+        if (e.t !== null) insertSubs(e);
+    } else {
+        e.Ae = n;
+        e.u |= CONFIG_HELD;
+        joinFuture(l);
+        for (let n = e.t; n !== null; n = n.l) if (n.o.u & CONFIG_AUTHORITATIVE) enqueueSub(n.o);
+    }
+}
+
+/** 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 s = lanes.indexOf(e);
+    if (s !== -1) lanes.splice(s, 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.rt;
+    if (l !== null) {
+        e.rt = null;
+        if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
+    }
+    for (let s = 0; s < e.nn.length; s++) {
+        const l = e.nn[s];
+        const u = l.m;
+        if (l === t || u._t !== e) continue;
+        const r = l.i;
+        const i = l.u & CONFIG_GUESS;
+        const o = u.Z;
+        // 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 f = e.Tt && !r ? o : l.pe;
+        const E = laneValueOf(l);
+        u.Z = NOT_PENDING;
+        l.u &= -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 (i && e.Tt && attrHooks !== null) {
+                const e = l.Ae !== NOT_PENDING ? l.Ae : l.pe;
+                if (e !== o) attrHooks.optimisticReverted(l, o, e, l.Ae !== 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).
+                        u._t = null;
+            if (!r && !i) l.Ae = E;
+            commitPendingNode(l);
+            if (!r) {
+                if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.G & STATUS_PENDING) l.u |= CONFIG_INPUTS_PUBLISHED;
+                if (f !== NOT_PENDING && (!l.tn || !l.tn(f, l.pe))) 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.Ae === NOT_PENDING) l.Ae = covered(l);
+            if (e.Tt) l.pe = 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).
+            u._t = null;
+            if (!r) {
+                if (f !== NOT_PENDING && e.Tt) l.Ae = f;
+                if (l.G & STATUS_PENDING) {
+                    u.De = null;
+                    enqueueSub(l);
+                }
+            }
+            if (e.Tt) {
+                commitPendingNode(l);
+                if (!r) l.u |= CONFIG_INPUTS_PUBLISHED;
+            } else {
+                if (u.St !== null || u.ct !== null) GlobalQueue.st(l, false, true);
+                l.u &= -385;
+            }
+        }
+    }
+    // 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.Tt && !e.fn) releaseQueues(e); else e.En[0].length = e.En[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. */ function laneRead(e, n) {
+    const t = n.u & CONFIG_GUESS;
+    if (e !== null && e.u & CONFIG_AUTHORITATIVE) return t && n.Ae !== NOT_PENDING ? n.Ae : n.pe;
+    if (e === null) return laneValueOf(n);
+    const s = txOf(n);
+    const l = n.G;
+    if (!tracking || e.u & 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.u & CONFIG_CHILDREN_FORBIDDEN) return display(n);
+        enterLane(s, e);
+        if (!t && l & STATUS_PENDING) return NOT_PENDING;
+        return laneValueOf(n);
+    }
+    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, s))) {
+        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.Z === NOT_PENDING) return NOT_PENDING;
+            if (n.Ae !== NOT_PENDING && e.u & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.Ae;
+        }
+        if (s.fn || !t && l & STATUS_PENDING) {
+            if (!t && !s.Tt && 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;
+                s.an.push(e);
             }
-            return;
+            return display(n);
         }
     }
-    ext(n).Ce = e;
-    n.C |= CONFIG_HAS_LANE;
+    enterLane(s, 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.u & CONFIG_SLOT_NODE && GlobalQueue.Nn !== undefined ? GlobalQueue.Nn(e) : e.pe;
+}
+
+/** 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.nn.length; n++) {
+        const t = e.nn[n];
+        if (t.u & CONFIG_GUESS && t.m._t === e && inFlight(t)) return true;
+    }
+    return false;
 }
 
-export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, ownsLane, readsHeldCommitted, resolveLane, resolveTransition, signalLanes };
+/** 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 s = n[t];
+        if (lanes.indexOf(s) === -1) continue;
+        const l = resolveTx(s._parent);
+        if (!l.nt || l.tt !== 0 || l.Z || ownFlights(l) || guessFlights(s)) 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 < s.nn.length && lanes.indexOf(s) !== -1; e++) {
+            const n = s.nn[e];
+            if (n.u & CONFIG_GUESS && n.m._t === s) {
+                const e = n.Ae !== NOT_PENDING ? n.Ae : covered(n);
+                reverting = n.Ae === NOT_PENDING;
+                supersede(n, e, !n.tn || !n.tn(n.m.Z, 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.fn = true;
+        return;
+    }
+    e.fn = false;
+    e.Tt = true;
+    reruns(e);
+    for (let n = 0; n < e.nn.length; n++) {
+        const t = e.nn[n];
+        const s = t.m;
+        if (s._t !== e) continue;
+        if (!(t.u & CONFIG_GUESS) && !t.i && t.Ae !== NOT_PENDING) {
+            s.Z = t.Ae;
+            t.Ae = 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 (s.St !== null || s.ct !== null) GlobalQueue.st(t, false, true);
+        t.u &= ~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.Z && 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.u & 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.Ae = n;
+            e.u |= CONFIG_HELD;
+            GlobalQueue.In?.(e, n);
+            schedule();
+            return n;
+        }
+        supersede(e, n, !e.tn || !e.tn(e.m.Z, n));
+    } else {
+        const t = txOf(e);
+        if (e.tn && e.tn(laneValueOf(e), n)) return n;
+        if (t.Tt) e.Ae = n; else e.m.Z = n;
+        if (e.re !== undefined) e.Ne = 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.Ae = n;
+        e.u |= CONFIG_HELD;
+        return true;
+    }
+    supersede(e, n, !e.tn || !e.tn(e.m.Z, 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.Oe;
+}
+
+/** 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._; t !== null; t = t.p) {
+        const e = t.I;
+        if (e.m !== null && e.m.Oe > n && e.Ne === clock) n = e.m.Oe;
+    }
+    return n;
+}
+
+GlobalQueue.Zt = laneRead;
+
+GlobalQueue.M = laneStage;
+
+GlobalQueue.ft = laneOutcome;
+
+GlobalQueue.Qt = 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.cn = 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 s = e[t];
+        const l = s.m?._t;
+        // 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 (s.R & REACTIVE_DISPOSED || l != null && l._parent?.rt === l && (s.u & CONFIG_VERDICT ? !(s.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+        enqueueSub(s);
+        if (l != null && l.Z && 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.Gn = () => lanes.length !== 0 && laneCorrections();
+
+GlobalQueue.On = endLanes;
+
+GlobalQueue.Je = e => {
+    const n = [];
+    for (let t = 0; t < lanes.length; t++) {
+        const s = lanes[t];
+        if (resolveTx(s._parent) !== e) continue;
+        for (let e = 0; e < s.nn.length; e++) if (s.nn[e].u & CONFIG_GUESS && s.nn[e].m._t === s) n.push(s.nn[e]);
+    }
+    return n;
+};
+
+GlobalQueue.Tn = lanesBlocked;
+
+GlobalQueue.ne = verdictLane;
+
+export { display, enterLane, guessedValueOf, laneRead, laneStage, laneValueOf, optimisticWrite, pendingGuessOf, supersede, verdictLane };