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

package/dist/prod/core/scheduler.js

@@ -1,8 +1,10 @@
-import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_LANE_DIRTY, CONFIG_INPUTS_PUBLISHED, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, CONFIG_HELD_FRAME, REACTIVE_LANE_DIRTY, CONFIG_STAGED_ERROR, CONFIG_INPUTS_PUBLISHED, STATUS_ERROR, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
-import { resyncUnflushedCompanions, recompute, markUnflushedStaged, ext } from "./core.js";
+import { notifyStatus } from "./async.js";
+
+import { resyncUnflushedCompanions, isSame, recompute, markUnflushedStaged, ext } from "./core.js";
 
 import { DEV } from "./dev.js";
 
@@ -12,29 +14,136 @@ import { runHeap, enqueueSub, deleteFromHeap } from "./heap.js";
 
 import { devCheckQuiescent } from "./invariants.js";
 
+// Optional-module hooks: module bindings, not `GlobalQueue` statics, so a
+// bundle that never imports the installing module never assigns them — its
+// minifier folds every guarded call site (and the branch behind it) away.
+// Each module installs its own set at evaluation (pay-for-use).
+// Lanes (lanes.ts; installed when `createOptimistic` — or verdict.ts — is
+// imported; every call site is behind a bit or a `passLane` nothing else sets).
+let laneReadHook = null;
+
+let laneStageHook = null;
+
+let laneOutcomeHook = null;
+
+let laneWriteHook = null;
+
+let applyGuessesHook = null;
+
+let laneSeamsHook = null;
+
+let laneCorrectionsHook = null;
+
+let endLanesHook = null;
+
+let lanesBlockedHook = null;
+
+function installLaneHooks(e, n, o, l, t, s, u, i, r) {
+    laneReadHook = e;
+    laneStageHook = n;
+    laneOutcomeHook = o;
+    laneWriteHook = l;
+    applyGuessesHook = t;
+    laneSeamsHook = s;
+    laneCorrectionsHook = u;
+    endLanesHook = i;
+    lanesBlockedHook = r;
+}
+
+// Boundaries (boundaries.ts): the display consumers between an observer
+// and the root. `catch` — status from a frame reader, nearest boundary
+// first (true: caught, the root never hears of it; a clear — flags 0 —
+// settles the reader there); `fresh` — a pass that read a hold (true: a
+// first pass a loading boundary that has not shown content caught,
+// `joinPass`; `held`: the flush's hold owns it, nothing catches it);
+// `hidden` — a frame reader behind a fallback (the boundary showing it)
+// is not on screen and holds nothing; `boundarySeam` — the seam's sweep (readers
+// gone or settled without a pass reveal; an `on` re-arm resolves);
+// `heldRun` — a queued run under a fallback-showing boundary waits for
+// the reveal (true: held; the boundary re-queues it by type). The
+// synchronous first render on creation builds the subtree, attached or
+// not; its updates and the user effects wait.
+let catchHook = null;
+
+let freshHook = null;
+
+let hiddenHook = null;
+
+let boundarySeamHook = null;
+
+let heldRunHook = null;
+
+function installBoundaryHooks(e, n, o, l, t) {
+    catchHook = e;
+    freshHook = n;
+    hiddenHook = o;
+    boundarySeamHook = l;
+    heldRunHook = t;
+}
+
+/** Store (store/store.ts): `park` — the flush parked into `t`: the store
+ * materializes and holds the container node of every staging that had none
+ * (a staging needs the node as its home only when something can read the
+ * frame through it; a hold can); `commit` — fold the pending backings whose
+ * container nodes this flush committed (the owned-raw model's one mutation
+ * point). */ let storeParkHook = null;
+
+let storeCommitHook = null;
+
+function installStoreHooks(e, n) {
+    storeParkHook = e;
+    storeCommitHook = n;
+}
+
+/** `affects()` marks (affects.ts): the releases at a landing and at the seam
+ * (ambient marks). */ let releaseMarksHook = null;
+
+let releaseAmbientMarksHook = null;
+
+function installMarkHooks(e, n) {
+    releaseMarksHook = e;
+    releaseAmbientMarksHook = n;
+}
+
+/** Verdicts (verdict.ts). */ let observeFlightHook = null;
+
+function installVerdictHooks(e) {
+    observeFlightHook = e;
+}
+
+/** External-source bridge (wired by enableExternalSource(); undefined while
+ * no config is active — including after _resetExternalSourceConfig()). */ let wireExternalSourceHook = undefined;
+
+let externalUntrackHook = undefined;
+
+function setExternalHooks(e, n) {
+    wireExternalSourceHook = e;
+    externalUntrackHook = n;
+}
+
 /** Live transactions — opened, unmerged, not landed. Scanned at every seam
  * while non-empty; nothing on the plain path. */ const transactions = [];
 
 /** Observe tier: this flush parked its transaction (`holdStart` fired). */ let holding = false;
 
 /** A transaction (listed here) or a lane (lanes.ts lists its own). */ function newTransaction(e, n = null) {
-    const t = {
-        un: [],
-        tn: [ [], [] ],
-        sn: [],
-        dn: null,
+    const o = {
+        tn: [],
+        un: [ [], [] ],
+        En: [],
+        cn: null,
         _parent: n,
-        Z: e,
-        ye: null,
+        v: e,
+        he: null,
         tt: 0,
         nt: false,
-        nn: null,
-        ve: false,
+        en: null,
+        ke: false,
         ln: false,
-        T: null
+        I: null
     };
-    if (!e) transactions.push(t);
-    return t;
+    if (!e) transactions.push(o);
+    return o;
 }
 
 // Lanes (plan sec. 28, 2026-10-02; lanes.ts). A lane is "a new base of a transition":
@@ -78,14 +187,14 @@ function setPassLane(e) {
  * set it. */ let passTx = null;
 
 function joinPassTx(e, n) {
-    if (globalQueue.ee && !n || flushTransaction !== null) return joinFuture(e);
+    if (globalQueue.q && !n || flushTransaction !== null) return joinFuture(e);
     if (passTx === null) passTx = resolveTx(e); else merge(resolveTx(e), passTx);
     schedule();
 }
 
 /** The transaction holding a node (CONFIG_HELD set), resolved through
  * merges; the path is compressed. */ function txOf(e) {
-    return e.m.ke = resolveTx(e.m.ke);
+    return e.T.Re = resolveTx(e.T.Re);
 }
 
 /** `t` resolved through merges while it is still parked or open; null once
@@ -95,7 +204,7 @@ function joinPassTx(e, n) {
 }
 
 function resolveTx(e) {
-    while (e.dn !== null) e = e.dn;
+    while (e.cn !== null) e = e.cn;
     return e;
 }
 
@@ -106,7 +215,7 @@ function resolveTx(e) {
     if (n === null) {
         flushTransaction = e === null ? newTransaction(false) : resolveTx(e);
     } else if (e !== null) merge(resolveTx(e), n);
-    if (!globalQueue.ee) schedule();
+    if (!globalQueue.q) schedule();
 }
 
 /** `t` merges into `f`: the work that touched both entangles them (A15).
@@ -116,15 +225,15 @@ function resolveTx(e) {
     // into the other would close a cycle `resolveTx` never leaves.
     e = resolveTx(e);
     n = resolveTx(n);
-    if (e === n || e.Z || n.Z) return;
-    e.dn = n;
+    if (e === n || e.v || n.v) return;
+    e.cn = n;
     n.tt += e.tt;
     n.nt ||= e.nt;
-    append(n.un, e.un);
-    append(n.tn[0], e.tn[0]);
-    append(n.tn[1], e.tn[1]);
-    append(n.sn, e.sn);
-    if (e.T !== null) append(n.T ??= [], e.T);
+    append(n.tn, e.tn);
+    append(n.un[0], e.un[0]);
+    append(n.un[1], e.un[1]);
+    append(n.En, e.En);
+    if (e.I !== null) append(n.I ??= [], e.I);
     transactions.splice(transactions.indexOf(e), 1);
 }
 
@@ -150,9 +259,9 @@ function resolveTx(e) {
     judge ??= e;
     // An action still running in it holds it open (action.ts). Its lanes
     // (lanes.ts): a lane under `t` blocks it while blocked itself.
-        const t = e.tt !== 0 || blockedBy(e.un, e) || !!GlobalQueue.cn && GlobalQueue.cn(e);
+        const o = e.tt !== 0 || blockedBy(e.tn, e) || !!lanesBlockedHook?.(e);
     judge = n;
-    return t;
+    return o;
 }
 
 let judge = null;
@@ -162,33 +271,33 @@ let judge = null;
  * not (lanes.ts, the body-end corollary). A pending reader counts only if
  * one of the sources it waits on is `t`'s (a render effect marked pending
  * by a lane flight, never re-run, is the lane's wait, not the frame's). */ function ownFlights(e) {
-    return blockedBy(e.un, e, true);
+    return blockedBy(e.tn, e, true);
 }
 
 /** A source the pending node waits on that is `t`'s (held by it, or by no
  * one) — not another transaction's or lane's work. Itself, when it is the
  * source. */ function ownSource(e, n) {
-    const t = e.m?.Se;
-    if (t === undefined) return true;
-    for (const e of t) {
-        const t = e.m?.ke;
-        if (t == null || resolveTx(t) === n) return true;
+    const o = e.T?.fe;
+    if (o === undefined) return true;
+    for (const e of o) {
+        const o = e.T?.Re;
+        if (o == null || resolveTx(o) === n) return true;
     }
     return false;
 }
 
-function blockedBy(e, n, t = false) {
+function blockedBy(e, n, o = false) {
     for (let l = 0; l < e.length; l++) {
-        const o = e[l];
-        if (!(o.G & STATUS_PENDING) || o.R & REACTIVE_DISPOSED || o.u & CONFIG_GUESS || o.m.ke !== null && txOf(o) !== n || t && !ownSource(o, n)) continue;
+        const t = e[l];
+        if (!(t.m & STATUS_PENDING) || t.R & REACTIVE_DISPOSED || t.l & CONFIG_GUESS || t.T.Re !== null && txOf(t) !== n || o && !ownSource(t, n)) continue;
         // The frame's own pending observer (off screen: this one holds nothing;
         // the next listed node may).
-                if (o.i === EFFECT_RENDER) {
-            if (onScreen(o, judge ?? n)) return true;
+                if (t.i === EFFECT_RENDER) {
+            if (onScreen(t, judge ?? n)) return true;
             continue;
         }
-        for (let e = o.t; e !== null; e = e.l) {
-            const t = e.o;
+        for (let e = t.o; e !== null; e = e.t) {
+            const o = e.u;
             // A frame reader: a render effect, or a stale reader of the flight
             // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
             // `frameRead`): served committed instead of going pending, it derives
@@ -200,7 +309,7 @@ function blockedBy(e, n, t = false) {
             // lane-membership ruling, 2026-10-05). An output that never committed
             // shows nothing — a mount the frame has not revealed — and holds
             // nothing.
-                        if ((t.i === EFFECT_RENDER || t.R & REACTIVE_FRAME_READ || t.u & CONFIG_REDERIVE && t.G === STATUS_PENDING) && (e.Ue === t.Ge || t.m?.V != null) && !(t.R & REACTIVE_DISPOSED) && onScreen(t, judge ?? n)) return true;
+                        if ((o.i === EFFECT_RENDER && o.m & STATUS_PENDING || o.R & REACTIVE_FRAME_READ || o.l & CONFIG_REDERIVE && o.m === STATUS_PENDING) && (e.Te === o.Ne || o.T?.F != null) && !(o.R & REACTIVE_DISPOSED) && onScreen(o, judge ?? n)) return true;
         }
     }
     return false;
@@ -214,7 +323,7 @@ function blockedBy(e, n, t = false) {
  * makes its say moot), and not behind a fallback (A33: a boundary showing its fallback is the display of
  * everything under it, so a reader there is not on screen and holds
  * nothing — boundaries.ts). */ function onScreen(e, n) {
-    return !(e.R & REACTIVE_ZOMBIE && removalStagedBy(e, n)) && !(GlobalQueue.se && GlobalQueue.se(e));
+    return !(e.R & REACTIVE_ZOMBIE && removalStagedBy(e, n)) && !hiddenHook?.(e);
 }
 
 /** A15 (#3463): a reader whose removal is staged — a zombie, parked by a
@@ -223,9 +332,9 @@ function blockedBy(e, n, t = false) {
  * (done, and the commit disposes it; not done, and it stays parked). The
  * staging transaction is the one holding the pass that parked the frame:
  * the nearest non-zombie ancestor. */ function removalStagedBy(e, n) {
-    let t = e;
-    while (t !== null && t.R & REACTIVE_ZOMBIE) t = t._parent;
-    return t !== null && (t.u & CONFIG_HELD) !== 0 && t.m?.ke != null && txOf(t) === resolveTx(n);
+    let o = e;
+    while (o?.R & REACTIVE_ZOMBIE) o = o._parent;
+    return o?.l & CONFIG_HELD && o.T?.Re != null && txOf(o) === resolveTx(n);
 }
 
 /** Unchanged passes this flush whose stale dependency tail awaits the
@@ -252,17 +361,17 @@ function deferZombie(e) {
 
 /** Put a staged node in a transaction: flagged, stamped, on its landing
  * list. */ function holdNode(e, n) {
-    e.u |= CONFIG_HELD;
+    e.l |= CONFIG_HELD;
     list(e, n);
 }
 
 /** Put a node on a transaction's list, once: a node's `_transaction` is the
  * transaction whose `_nodes` it is on (every site that sets one does the
  * other), so a re-pass, a re-landing or a re-staging adds nothing. */ function list(e, n) {
-    const t = ext(e);
-    if (t.ke === n) return;
-    t.ke = n;
-    n.un.push(e);
+    const o = ext(e);
+    if (o.Re === n) return;
+    o.Re = n;
+    n.tn.push(e);
 }
 
 /** Hold the (uncommitted) frame under a held pass: every computed in the
@@ -278,18 +387,34 @@ function deferZombie(e) {
  * next read of it trips over (`laneRead` → `txOf`). Its frame is the lane's
  * too (ruling A: a lane pass's children are the lane's), revealed and
  * retired at the lane's seam. */ function holdFrame(e, n) {
-    for (let t = e.ge; t !== null; t = t.me) {
-        if (t.m?.ke?.Z) continue;
-        if (t.re !== undefined && !(t.u & CONFIG_HELD)) holdNode(t, n);
-        holdFrame(t, n);
+    for (let o = e.De; o !== null; o = o.pe) {
+        if (o.T?.Re?.v) continue;
+        if (o.X !== undefined) {
+            if (!(o.l & CONFIG_HELD)) holdNode(o, n);
+            o.l |= CONFIG_HELD_FRAME;
+        }
+        holdFrame(o, n);
+    }
+}
+
+/** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
+ * what an earlier hold staged under a re-armed boundary). */ function heldUnder(e, n, o) {
+    for (let l = e.De; l !== null; l = l.pe) {
+        if ((l.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(l) !== n) o(l);
+        heldUnder(l, n, o);
     }
 }
 
+/** `n` leaves the hold it was staged in: its next pass publishes mainline. */ function unhold(e) {
+    e.T.Re = null;
+    e.l &= ~CONFIG_HELD;
+}
+
 const dirtyQueue = {
-    Ht: new Array(2e3).fill(undefined),
-    C: false,
-    He: 0,
-    At: 0
+    $e: new Array(2e3).fill(undefined),
+    p: false,
+    Ge: 0,
+    et: 0
 };
 
 let clock = 0;
@@ -352,7 +477,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.ee) {
+    if (!syncDepth && !globalQueue.q) {
         queueMicrotask(flush);
     }
 }
@@ -383,9 +508,9 @@ function haltReactivity(e) {
     // nothing an app or its telemetry can act on (#3338 — an uncaught throw
     // during the hydration render). The rethrow may reach the top as well in
     // the non-swallowed cases; a duplicate report beats a silent one.
-        const t = e !== undefined && globalThis.reportError;
-    t || e === undefined ? console.error(n) : console.error(n, e);
-    t && t(e);
+        const o = e !== undefined && globalThis.reportError;
+    o || e === undefined ? console.error(n) : console.error(n, e);
+    o && o(e);
 }
 
 // Logs on the first write after a halt so a frozen interaction is traceable.
@@ -401,11 +526,11 @@ function notifyHalted() {
 }
 
 class GlobalQueue {
-    tn=[ [], [] ];
-    ee=false;
+    un=[ [], [] ];
+    q=false;
     flush() {
-        if (this.ee) return;
-        this.ee = true;
+        if (this.q) return;
+        this.q = true;
         // A28: companions of nodes written since the last flush mirror the
         // flushed world — re-synced inside the running window (the write is
         // "flushed" from here on).
@@ -418,19 +543,19 @@ class GlobalQueue {
             // recomputed; late subscribers (an effect reading a swept memo this
             // flush) revive it, which is the pay-for-use contract.
             sweepDormant();
-            runHeap(dirtyQueue, GlobalQueue.Ce);
+            runHeap(dirtyQueue, GlobalQueue._e);
             this.settle();
             clock++;
             // A write the commit sweep staged with no subscriber to dirty is work
             // too — the next round commits it.
-                        scheduled = dirtyQueue.At >= dirtyQueue.He || pendingNodes.length !== 0;
+                        scheduled = dirtyQueue.et >= dirtyQueue.Ge || pendingNodes.length !== 0;
             this.run(EFFECT_RENDER);
             this.run(EFFECT_USER);
             if (false && holding) ;
             if (false && !scheduled) ;
             if (false) ;
         } finally {
-            this.ee = false;
+            this.q = false;
             passTx = null;
         }
     }
@@ -443,7 +568,7 @@ class GlobalQueue {
         // Lanes: an ended action body judges its guesses now that their passes
         // have run (lanes.ts); a correction's re-derivations run in one more
         // pure round — the parent's flights before the parent is judged below.
-        if (GlobalQueue.an?.()) runHeap(dirtyQueue, GlobalQueue.Ce);
+        if (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue._e);
         const e = flushTransaction;
         flushTransaction = null;
         // The frame's verdict is in: the guesses written since the last seam
@@ -451,21 +576,21 @@ class GlobalQueue {
         // parents a nested lane to it), or are dropped — the frame commits, and
         // there is nothing to be optimistic over. Their passes run next round;
         // a parent landing at this very seam ends the lane before they do.
-                GlobalQueue.fn?.(e);
+                applyGuessesHook?.(e);
         // A lane's own flush (its flight landing, its reveal) parks nothing: the
         // lane's work reached it per pass; the frame's plain writes commit.
         // (Resolved: a guess over another transaction's guess merged them.)
-                const n = e !== null && !e.Z ? resolveTx(e) : null;
+                const n = e !== null && !e.v ? resolveTx(e) : null;
         if (n !== null) {
             // `t._nodes` grows under the walk (holdFrame pushes); the bound is
             // this flush's list, which does not.
             const e = pendingNodes.length;
-            for (let t = 0; t < e; t++) {
-                const e = pendingNodes[t];
+            for (let o = 0; o < e; o++) {
+                const e = pendingNodes[o];
                 // Already held: the pass that re-staged it joined its transaction,
                 // which is `t` (or merged into it). Lane work is the lane's (a
                 // pending mark propagated onto it queued it here too).
-                                if (!(e.u & (CONFIG_HELD | CONFIG_OVERRIDE)) && (e.m === null || e.m.ke === null || !e.m.ke.Z)) {
+                                if (!(e.l & (CONFIG_HELD | CONFIG_OVERRIDE)) && (e.T === null || e.T.Re === null || !e.T.Re.v)) {
                     // A loading source — pending with nothing staged and no committed
                     // value (A16, A19 exc. 1: uninitialized is loading, not pending)
                     // that is not an observer — is nobody's frame: not held. Its
@@ -474,15 +599,19 @@ class GlobalQueue {
                     // stale stamp was the bridge that entangled unrelated updates
                     // with a never-resolving flight). Its observers are held and
                     // wait on its flight (`blocked`).
-                    if (e.Ae === NOT_PENDING && e.G & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
+                    if (e.se === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
                     // A34 (2): a tick whose writes net to the committed value made no
                     // proposal (`setShow(false); setShow(true)` on a committed true) —
                     // not staged, not held, pends nothing; a later write to it is
                     // plain mainline. (A node already held stays held when written
                     // back: A34 (1).)
-                                        if (e.Ae !== NOT_PENDING && !(e.G & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.We && e.We(e.pe, e.Ae) && e.m?.Me == null && e.m?.Be == null) {
-                        e.Ae = NOT_PENDING;
-                        e.u &= ~CONFIG_STAGED;
+                                        if (e.se !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.Ue == null && e.T?.me == null && 
+                    // The comparator last: a pass that created children (an object
+                    // owning a fresh async memo, #4111) must not have it read them.
+                    // A NotReady read there is a change (`isSame`).
+                    isSame(e, e.Ie, e.se)) {
+                        e.se = NOT_PENDING;
+                        e.l &= ~CONFIG_STAGED;
                         continue;
                     }
                     holdNode(e, n);
@@ -490,10 +619,10 @@ class GlobalQueue {
                 // A held pass's frame is held with it (ruling A, O2): the children it
                 // created are the transaction's — they compute, and a pass over them
                 // or a write that reaches them joins; they effect at the landing.
-                                if (e.u & CONFIG_STAGED) holdFrame(e, n);
+                                if (e.l & CONFIG_STAGED) holdFrame(e, n);
             }
             pendingNodes.length = 0;
-            GlobalQueue.Tn?.(n);
+            storeParkHook?.(n);
             // (This flush's runs are stashed with `t` below — after the landings,
             // so a `t` that lands at this very seam runs them first, ahead of
             // the runs it held from earlier flushes.)
@@ -503,8 +632,12 @@ class GlobalQueue {
             // through like the same read outside): it re-runs now, as the
             // holder's verdict lane's work — before the lane seams, which reveal
             // it (nothing commits this seam that could dispose it).
-                        const t = deferredZombies.splice(0).sort((e, n) => e.Le - n.Le);
-            for (let e = 0; e < t.length; e++) if ((t[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && t[e].u & CONFIG_VERDICT) recompute(t[e]);
+            // (Verdict readers exist only with the verdict engine installed.)
+                        const o = deferredZombies.splice(0);
+            if (observeFlightHook) {
+                o.sort((e, n) => e.Fe - n.Fe);
+                for (let e = 0; e < o.length; e++) if ((o[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && o[e].l & CONFIG_VERDICT) recompute(o[e]);
+            }
             // The unchanged passes' tails stay linked (A30, #3469): their inputs
             // are held, and the committed frame still derives from them — no trim.
                 } else {
@@ -516,7 +649,7 @@ class GlobalQueue {
             // `recompute`'s own gates.
                         for (let e = 0; e < heldTrims.length; e++) {
                 const n = heldTrims[e];
-                if (n.m?.V == null && !n.Fe) trimStaleDeps(n);
+                if (n.T?.F == null && !n.Ae) trimStaleDeps(n);
             }
         }
         // The list is the flush's either way. Reset only when there is something
@@ -530,19 +663,21 @@ class GlobalQueue {
         // removes its entry.
         // This flush's own runs, the lanes' reveals, and the landings' held runs
         // are collected apart and ordered below.
-                const t = this.tn;
-        const l = this.tn = [ [], [] ];
+                const o = this.un;
+        const l = this.un = [ [], [] ];
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
-                GlobalQueue.Nn?.(n !== null ? stagedReaders : null);
-        if (stagedReaders.length) stagedReaders.length = 0;
-        this.tn = [ [], [] ];
+                if (laneSeamsHook) {
+            laneSeamsHook(n !== null ? stagedReaders : null);
+            if (stagedReaders.length) stagedReaders.length = 0;
+        }
+        this.un = [ [], [] ];
         for (let e = transactions.length - 1; e >= 0; e--) {
             const n = transactions[e];
             if (blocked(n)) continue;
             transactions.splice(e, 1);
-            GlobalQueue.In?.(n);
+            endLanesHook?.(n);
             land(n);
             // A landing's commits can dispose a zombie a transaction judged above
             // was blocked on (#3463: live "until the commit that disposes it") —
@@ -551,12 +686,13 @@ class GlobalQueue {
         }
         // The store folds the pending backings whose container nodes committed
         // — this flush's, or a landing's (store/store.ts installs it).
-                GlobalQueue._n?.();
+                storeCommitHook?.();
         // Marks declared outside a transaction: the flush that carried them
         // parked (something async below) — the window is the frame's, the marks
         // are its transaction's; else they release at the seam, verdict-only,
         // nothing to show (affects.ts).
-                GlobalQueue.D?.(n !== null && transactions.indexOf(n) !== -1 ? n : null);
+                const t = n && liveTx(n);
+        releaseAmbientMarksHook?.(t);
         // The effect phase: lane work first (displayed ahead of the frame), then
         // this flush's runs, then the runs the landings held from earlier
         // flushes — as one pass would have queued them (#3540: a shell
@@ -564,41 +700,40 @@ class GlobalQueue {
         // write; #3528: a display-ahead swap before the count it is shown
         // beside). A parked frame's runs wait with its transaction instead: the
         // effect phase applies a committed frame.
-                const o = n && liveTx(n);
-        const u = o !== null;
+                const s = t !== null;
         for (let e = 0; e < 2; e++) {
-            if (u) append(o.tn[e], t[e]);
+            if (s) append(t.un[e], o[e]);
             // The plain flush — no reveal, no landing, not parked — has nothing to
             // order around its own runs: they are the queue as they stand (the
             // same array, not a copy; `run` takes it whole). Every other seam
             // builds the ordered queue above.
-                        this.tn[e] = u || l[e].length || this.tn[e].length ? l[e].concat(u ? [] : t[e], this.tn[e]) : t[e];
+                        this.un[e] = s || l[e].length || this.un[e].length ? l[e].concat(s ? [] : o[e], this.un[e]) : o[e];
         }
         if (deferredZombies.length !== 0) {
             // Survivors are the displayed frame of a held pass: they rerun for the
             // live write, parents before children.
-            const e = deferredZombies.splice(0).sort((e, n) => e.Le - n.Le);
+            const e = deferredZombies.splice(0).sort((e, n) => e.Fe - n.Fe);
             for (let n = 0; n < e.length; n++) {
                 if (!(e[n].R & REACTIVE_DISPOSED)) recompute(e[n]);
             }
         }
         // Boundaries: readers that settled, landed or died this flush are
         // dropped; a fallback with none left reveals next round.
-                GlobalQueue.Ee?.();
+                boundarySeamHook?.();
     }
     run(e) {
-        const n = this.tn[e - 1];
+        const n = this.un[e - 1];
         if (n.length) {
-            this.tn[e - 1] = [];
+            this.un[e - 1] = [];
             runQueue(n, e);
         }
     }
-    enqueue(e, n, t = passLane) {
+    enqueue(e, n, o = passLane) {
         // Lane work's runs are the lane's: they run at its reveal, not with
         // the frame (which may park). A lane pass that read the frame's own
         // staging is the frame's (`recompute` passes null): its run waits with
         // the frame.
-        if (e) (t !== null ? t : this).tn[e - 1].push(n);
+        if (e) (o !== null ? o : this).un[e - 1].push(n);
         schedule();
     }
     /** Status reaching the root: pending is absorbed (the root mount defers —
@@ -614,10 +749,10 @@ class GlobalQueue {
      *
      * A boundary between the observer and the root (boundaries.ts) is asked
      * first: a fallback catches what is not ready under it, and the root
-     * never hears of it. */    notify(e, n, t, l) {
-        if (GlobalQueue.fe && GlobalQueue.fe(e, t & n, l)) return true;
+     * never hears of it. */    notify(e, n, o, l) {
+        if (catchHook?.(e, o & n, l)) return true;
         if (n & STATUS_PENDING) {
-            if (t & STATUS_PENDING) {
+            if (o & STATUS_PENDING) {
                 // A pass that went pending holds its frame: the async's own
                 // synchronous frame is not ready (A15 reveal corollary: a reveal
                 // that discovers a flight whose inputs are visible holds and joins
@@ -649,34 +784,41 @@ class GlobalQueue {
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
  * it. */ function reruns(e) {
-    for (let n = 0; n < e.sn.length; n++) {
-        const t = e.sn[n];
-        if (t.R & REACTIVE_DISPOSED) continue;
-        if (t.R & REACTIVE_FRAME_READ) {
-            t.R &= ~REACTIVE_FRAME_READ;
-            t.Fe = false;
+    for (let n = 0; n < e.En.length; n++) {
+        const o = e.En[n];
+        // An errored reader's display is its error (D-39): the landing gives it
+        // nothing to re-derive, and a re-run would be a read that retries the
+        // errored source (#3945).
+                if (o.R & REACTIVE_DISPOSED || o.m & STATUS_ERROR) continue;
+        if (o.R & REACTIVE_FRAME_READ || o.l & CONFIG_VERDICT) {
+            o.R &= ~REACTIVE_FRAME_READ;
+            o.Ae = false;
             // Its frame is replaced by the re-derivation: a run one of its
             // children queued this flush (re-run by the same landing) is for the
             // frame being replaced — void too (#3404).
-                        for (let e = t.ge; e !== null; e = e.me) if (e.i) e.Fe = false;
-            enqueueSub(t);
+                        for (let e = o.De; e !== null; e = e.pe) if (e.i) e.Ae = false;
+            enqueueSub(o);
         }
     }
-    e.sn.length = 0;
+    e.En.length = 0;
 }
 
 /** The landing: the held frame becomes the frame. */ function land(e) {
     reruns(e);
-    if (e.T !== null) GlobalQueue.A(e.T);
+    if (e.I !== null) releaseMarksHook(e.I);
     // Old children die in the commits (cleanups first), then the stashed
     // effects run ahead of this flush's own. A node a lane took over since
     // (a guess written over the staged truth) is the lane's to land.
-        for (let n = 0; n < e.un.length; n++) {
-        const t = e.un[n];
-        if (t.m.ke === null || txOf(t) !== e) continue;
-        t.m.ke = null;
-        commitPendingNode(t);
+        for (let n = 0; n < e.tn.length; n++) {
+        const o = e.tn[n];
+        if (o.T.Re === null || txOf(o) !== e) continue;
+        o.T.Re = null;
+        commitPendingNode(o);
     }
+    // A cleanup those commits ran that wrote a node `u` still held joined
+    // `u`, which has left `transactions`: the write is this landing's, and
+    // the next flush must not park in it (#4089).
+        if (flushTransaction === e) flushTransaction = null;
     releaseQueues(e);
 }
 
@@ -685,13 +827,13 @@ class GlobalQueue {
  * pass would have queued them — a shell re-derived at the landing before a
  * boundary swap held since the write (#3540's log order). */ function releaseQueues(e) {
     for (let n = 0; n < 2; n++) {
-        append(globalQueue.tn[n], e.tn[n]);
-        e.tn[n] = [];
+        append(globalQueue.un[n], e.un[n]);
+        e.un[n] = [];
     }
 }
 
 /** `a.push(...b)` without the argument-count limit. */ function append(e, n) {
-    for (let t = 0; t < n.length; t++) e.push(n[t]);
+    for (let o = 0; o < n.length; o++) e.push(n[o]);
 }
 
 /** Nodes staged this flush (`_pendingValue` set), committed at its end. */ const pendingNodes = [];
@@ -706,13 +848,13 @@ class GlobalQueue {
  * after `t`'s landing (`_reruns`). Once per pass. */ function staleReader(e, n) {
     if (!(e.R & REACTIVE_FRAME_READ)) {
         e.R |= REACTIVE_FRAME_READ;
-        n.sn.push(e);
+        n.En.push(e);
     }
 }
 
 function queuePendingNode(e) {
     pendingNodes.push(e);
-    if (!globalQueue.ee) markUnflushedStaged();
+    if (!globalQueue.q) markUnflushedStaged();
  // A28
 }
 
@@ -728,14 +870,14 @@ function bumpNotifyEpoch() {
 function insertSubs(e) {
     // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
     // the next walk for this node while the epoch holds (marking is idempotent).
-    e.ze = notifyEpoch;
+    e.Me = notifyEpoch;
     // Presence bits gate the optional-slot probes (see constants.ts): one
     // masked read of the always-present _config instead of missing-property
     // lookups in the hottest notify loop.
-        const n = e.u;
-    const t = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.m?.xe !== undefined;
-    for (let n = e.t; n !== null; n = n.l) {
-        const e = n.o;
+        const n = e.l;
+    const o = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.Pe !== undefined;
+    for (let n = e.o; n !== null; n = n.t) {
+        const e = n.u;
         // Missed-wake latch (#3037): this write is landing while the subscriber
         // is mid-recompute (a nested pull committing beneath its reads), and the
         // heap refuses RECOMPUTING nodes. A gen-current link means the pass
@@ -744,8 +886,8 @@ function insertSubs(e) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.R & REACTIVE_RECOMPUTING_DEPS && n.Ue === e.Ge && n !== e.S) e.R |= REACTIVE_MISSED_WAKE;
-        if (t && e.u & CONFIG_IN_SNAPSHOT_SCOPE) {
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && n.Te === e.Ne && n !== e._) e.R |= REACTIVE_MISSED_WAKE;
+        if (o && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
@@ -761,14 +903,14 @@ function insertSubs(e) {
  * is a live write if the effect becomes a zombie later this flush — an
  * on-screen reader whose removal an adopted write stages follows the lane
  * (the lane-membership ruling, 2026-10-05; `_update`). */ function laneDirty(e, n) {
-    for (let t = e.t; t !== null; t = t.l) {
-        const e = t.o.m?.ke;
-        if (e?.Z ? sameLane(e, n) : t.o.i) t.o.R |= REACTIVE_LANE_DIRTY;
+    for (let o = e.o; o !== null; o = o.t) {
+        const e = o.u.T?.Re;
+        if (e?.v ? sameLane(e, n) : o.u.i) o.u.R |= REACTIVE_LANE_DIRTY;
     }
 }
 
 /** One lane, or two of one link group (#3335): one reveal unit. */ function sameLane(e, n) {
-    return e === n || e.nn !== null && e.nn === n.nn;
+    return e === n || e.en !== null && e.en === n.en;
 }
 
 function commitPendingNode(e) {
@@ -778,40 +920,52 @@ function commitPendingNode(e) {
     // staged) stays uncommitted: a re-pass disposes its children on the spot,
     // and the frame it parked stays the frame until a pass of this node
     // commits a value.
-        if (!n.re) {
-        e.u &= -385;
-        if (e.Ae !== NOT_PENDING) {
-            e.pe = e.Ae;
-            e.Ae = NOT_PENDING;
+        if (!n.X) {
+        e.l &= -385;
+        if (e.se !== NOT_PENDING) {
+            e.Ie = e.se;
+            e.se = NOT_PENDING;
         }
         return;
     }
     // Computeds only from here (`_statusFlags` is not a signal field). A
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
-        const t = e.Ae === NOT_PENDING && (n.G & STATUS_PENDING) !== 0;
-    e.u = t ? e.u & ~CONFIG_HELD | CONFIG_INPUTS_PUBLISHED : e.u & -1409;
-    if (e.Ae !== NOT_PENDING) {
-        e.pe = e.Ae;
-        e.Ae = NOT_PENDING;
+        const o = e.se === NOT_PENDING && (n.m & STATUS_PENDING) !== 0;
+    const l = e.l & CONFIG_STAGED_ERROR;
+    // An answer commits: the error it replaces leaves the display (D-41).
+        if (!o && n.T) n.T.de = undefined;
+    e.l = o ? e.l & -1048833 | CONFIG_INPUTS_PUBLISHED : e.l & -3147137;
+    // D-41: the staged answer is an error — published now, when a value would
+    // show, through the ordinary error path (`stageError`). Its readers first
+    // see it in the cycle after this seam: a tracked re-read there is not a
+    // retry (`read`), or a boundary re-derived by it would retry it forever.
+        if (l) {
+        const o = e.se;
+        e.se = NOT_PENDING;
+        e.ie = clock + 1;
+        notifyStatus(n, STATUS_ERROR, o);
+    } else if (e.se !== NOT_PENDING) {
+        e.Ie = e.se;
+        e.se = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
-                n.G &= ~STATUS_UNINITIALIZED;
+                n.m &= ~STATUS_UNINITIALIZED;
         // A quiet re-ask's classification survives its landing and dies with
         // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
         // the reveal. (The sweep of a node still in flight is not a landing.)
         // The A28 stash goes with it.
-                if (n.m != null) n.m.be = false, n.m.$e = NOT_PENDING;
+                if (n.T != null) n.T.Ve = false, n.T.Be = NOT_PENDING;
         // An effect with a staged value was born held (L2): its first run is
         // this commit's, not its creation's (A29) — queue it now.
                 if (e.i && e.i !== EFFECT_TRACKED) {
-            e.Fe = true;
-            globalQueue.enqueue(e.i, e.J ??= GlobalQueue.X.bind(null, n));
+            e.Ae = true;
+            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.K.bind(null, n));
         }
     }
     // The committed value is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
     // store to an always-present computed slot.
-        n._e = false;
+        n.ce = false;
     n.R &= ~REACTIVE_MANUAL_WRITE;
     // The dependencies of the pass that produced the value are the frame's now:
     // the previous frame's tail goes (A30, #3410; `recompute` left it for a
@@ -819,11 +973,11 @@ function commitPendingNode(e) {
     // pass or by the node's own landing (whose pass was clean), so a set
     // `_error` means the last pass threw, kept its full list, and `_depsTail`
     // marks where it stopped.
-        if (n.m?.V == null) trimStaleDeps(n);
-    if (!(n.G & STATUS_PENDING)) n.G &= ~STATUS_UNINITIALIZED;
+        if (n.T?.F == null) trimStaleDeps(n);
+    if (!(n.m & STATUS_PENDING)) n.m &= ~STATUS_UNINITIALIZED;
     // L2: the children this commit publishes are the frame's now — the frame
     // they replace, parked by the pass (`recompute`), goes.
-        if (!t && n.m != null && (n.m.Me !== null || n.m.Be !== null)) GlobalQueue.he(n, false, true);
+        if (!o && n.T != null && (n.T.Ue !== null || n.T.me !== null)) GlobalQueue.Ce(n, false, true);
 }
 
 function commitPendingNodes() {
@@ -832,7 +986,7 @@ function commitPendingNodes() {
         // A node a lane pass re-staged this round is the lane's to reveal; one
         // a transaction holds (born held by a mainline pass, `passTx`) is that
         // transaction's to commit, at its landing.
-                if (!(n.u & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
+                if (!(n.l & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
     }
     pendingNodes.length = 0;
 }
@@ -857,7 +1011,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.ee) {
+    if (globalQueue.q) {
         return;
     }
     if (halted) return;
@@ -867,7 +1021,7 @@ function flush(e) {
 }
 
 function runQueue(e, n) {
-    for (let t = 0; t < e.length; t++) e[t](n);
+    for (let o = 0; o < e.length; o++) e[o](n);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, blocked, bumpNotifyEpoch, clock, commitPendingNode, deferZombie, dirtyQueue, enforceLoadingBoundary, enterAction, exitAction, flush, flushTransaction, globalQueue, haltReactivity, heldTrim, holdNode, insertSubs, joinFuture, joinPassTx, laneDirty, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, ownFlights, passLane, passTx, question, queuePendingNode, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setPassLane, setQuestion, stagedReaders, staleReader, txOf };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };