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

package/dist/observe/core/scheduler.js

@@ -14,6 +14,8 @@ import { runHeap, enqueueSub, deleteFromHeap } from "./heap.js";
 
 import { devCheckQuiescent } from "./invariants.js";
 
+import { rethrowCleanupError } from "./owner.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.
@@ -38,16 +40,16 @@ let endLanesHook = null;
 
 let lanesBlockedHook = null;
 
-function installLaneHooks(e, n, o, t, l, s, u, i, r) {
+function installLaneHooks(e, o, n, t, l, s, u, r, i) {
     laneReadHook = e;
-    laneStageHook = n;
-    laneOutcomeHook = o;
+    laneStageHook = o;
+    laneOutcomeHook = n;
     laneWriteHook = t;
     applyGuessesHook = l;
     laneSeamsHook = s;
     laneCorrectionsHook = u;
-    endLanesHook = i;
-    lanesBlockedHook = r;
+    endLanesHook = r;
+    lanesBlockedHook = i;
 }
 
 // Boundaries (boundaries.ts): the display consumers between an observer
@@ -73,10 +75,10 @@ let boundarySeamHook = null;
 
 let heldRunHook = null;
 
-function installBoundaryHooks(e, n, o, t, l) {
+function installBoundaryHooks(e, o, n, t, l) {
     catchHook = e;
-    freshHook = n;
-    hiddenHook = o;
+    freshHook = o;
+    hiddenHook = n;
     boundarySeamHook = t;
     heldRunHook = l;
 }
@@ -90,9 +92,9 @@ function installBoundaryHooks(e, n, o, t, l) {
 
 let storeCommitHook = null;
 
-function installStoreHooks(e, n) {
+function installStoreHooks(e, o) {
     storeParkHook = e;
-    storeCommitHook = n;
+    storeCommitHook = o;
 }
 
 /** `affects()` marks (affects.ts): the releases at a landing and at the seam
@@ -100,9 +102,9 @@ function installStoreHooks(e, n) {
 
 let releaseAmbientMarksHook = null;
 
-function installMarkHooks(e, n) {
+function installMarkHooks(e, o) {
     releaseMarksHook = e;
-    releaseAmbientMarksHook = n;
+    releaseAmbientMarksHook = o;
 }
 
 /** Verdicts (verdict.ts). */ let observeFlightHook = null;
@@ -116,9 +118,9 @@ function installVerdictHooks(e) {
 
 let externalUntrackHook = undefined;
 
-function setExternalHooks(e, n) {
+function setExternalHooks(e, o) {
     wireExternalSourceHook = e;
-    externalUntrackHook = n;
+    externalUntrackHook = o;
 }
 
 /** Live transactions — opened, unmerged, not landed. Scanned at every seam
@@ -126,13 +128,13 @@ function setExternalHooks(e, n) {
 
 /** 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 o = {
+/** A transaction (listed here) or a lane (lanes.ts lists its own). */ function newTransaction(e, o = null) {
+    const n = {
         je: [],
         un: [ [], [] ],
         En: [],
-        cn: null,
-        _parent: n,
+        eo: null,
+        _parent: o,
         V: e,
         it: null,
         tt: 0,
@@ -142,8 +144,8 @@ function setExternalHooks(e, n) {
         ln: false,
         I: null
     };
-    if (!e) transactions.push(o);
-    return o;
+    if (!e) transactions.push(n);
+    return n;
 }
 
 // Lanes (plan sec. 28, 2026-10-02; lanes.ts). A lane is "a new base of a transition":
@@ -186,8 +188,8 @@ function setPassLane(e) {
  * Cleared by the flush the join schedules, and at the end of a flush that
  * set it. */ let passTx = null;
 
-function joinPassTx(e, n) {
-    if (globalQueue.q && !n || flushTransaction !== null) return joinFuture(e);
+function joinPassTx(e, o) {
+    if (globalQueue.q && !o || flushTransaction !== null) return joinFuture(e);
     if (passTx === null) passTx = resolveTx(e); else merge(resolveTx(e), passTx);
     schedule();
 }
@@ -204,37 +206,37 @@ function joinPassTx(e, n) {
 }
 
 function resolveTx(e) {
-    while (e.cn !== null) e = e.cn;
+    while (e.eo !== null) e = e.eo;
     return e;
 }
 
 /** The flush joins transaction `t` — or needs one of its own (`null`: a pass
  * went pending with nothing held). Joining a second one merges it into the
  * flush's: the work that touched both entangles them (A15). */ function joinFuture(e) {
-    const n = flushTransaction;
-    if (n === null) {
+    const o = flushTransaction;
+    if (o === null) {
         flushTransaction = e === null ? newTransaction(false) : resolveTx(e);
-    } else if (e !== null) merge(resolveTx(e), n);
+    } else if (e !== null) merge(resolveTx(e), o);
     if (!globalQueue.q) schedule();
 }
 
 /** `t` merges into `f`: the work that touched both entangles them (A15).
  * A lane never merges: it is a sub-frame, not a peer — its work is routed
- * per pass (`passLane`). */ function merge(e, n) {
+ * per pass (`passLane`). */ function merge(e, o) {
     // Both ends resolved: a stale pointer to a transaction already merged
     // into the other would close a cycle `resolveTx` never leaves.
     e = resolveTx(e);
-    n = resolveTx(n);
-    if (e === n || e.V || n.V) return;
-    if (attrHooks !== null) attrHooks.transitionMerged(n, e);
-    e.cn = n;
-    n.tt += e.tt;
-    n.nt ||= e.nt;
-    append(n.je, e.je);
-    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);
+    o = resolveTx(o);
+    if (e === o || e.V || o.V) return;
+    if (attrHooks !== null) attrHooks.transitionMerged(o, e);
+    e.eo = o;
+    o.tt += e.tt;
+    o.nt ||= e.nt;
+    append(o.je, e.je);
+    append(o.un[0], e.un[0]);
+    append(o.un[1], e.un[1]);
+    append(o.En, e.En);
+    if (e.I !== null) append(o.I ??= [], e.I);
     transactions.splice(transactions.indexOf(e), 1);
 }
 
@@ -256,13 +258,13 @@ function resolveTx(e) {
  * in for the flight (A17: "visible until its own fetch settles"). */ function blocked(e) {
     // The transaction being judged (a lane consulted on its behalf judges for
     // it): a zombie whose removal it stages is moot for it alone (`onScreen`).
-    const n = judge;
+    const o = judge;
     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 o = e.tt !== 0 || blockedBy(e.je, e) || !!lanesBlockedHook?.(e);
-    judge = n;
-    return o;
+        const n = e.tt !== 0 || blockedBy(e.je, e) || !!lanesBlockedHook?.(e);
+    judge = o;
+    return n;
 }
 
 let judge = null;
@@ -270,12 +272,12 @@ let judge = null;
 /** Observe tier: the flights `t` waits on — its pending held sources a
  * frame reader observes (`blockedBy`'s predicate, collected; the readers
  * themselves are not sources). */ function blockersOf(e) {
-    const n = [];
-    for (let o = 0; o < e.je.length; o++) {
-        const t = e.je[o];
-        if (!t.i && t.m & STATUS_PENDING && !(t.R & REACTIVE_DISPOSED) && (t.T.Je === null || txOf(t) === e) && blockedBy([ t ], e)) n.push(t);
+    const o = [];
+    for (let n = 0; n < e.je.length; n++) {
+        const t = e.je[n];
+        if (!t.i && t.m & STATUS_PENDING && !(t.R & REACTIVE_DISPOSED) && (t.T.Je === null || txOf(t) === e) && blockedBy([ t ], e)) o.push(t);
     }
-    return n;
+    return o;
 }
 
 /** `t`'s own flights only — not its lanes': a flight the frame asked for
@@ -288,28 +290,28 @@ let judge = null;
 
 /** 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 o = e.T?.fe;
-    if (o === undefined) return true;
-    for (const e of o) {
-        const o = e.T?.Je;
-        if (o == null || resolveTx(o) === n) return true;
+ * source. */ function ownSource(e, o) {
+    const n = e.T?.se;
+    if (n === undefined) return true;
+    for (const e of n) {
+        const n = e.T?.Je;
+        if (n == null || resolveTx(n) === o) return true;
     }
     return false;
 }
 
-function blockedBy(e, n, o = false) {
+function blockedBy(e, o, n = false) {
     for (let t = 0; t < e.length; t++) {
         const l = e[t];
-        if (!(l.m & STATUS_PENDING) || l.R & REACTIVE_DISPOSED || l.l & CONFIG_GUESS || l.T.Je !== null && txOf(l) !== n || o && !ownSource(l, n)) continue;
+        if (!(l.m & STATUS_PENDING) || l.R & REACTIVE_DISPOSED || l.l & CONFIG_GUESS || l.T.Je !== null && txOf(l) !== o || n && !ownSource(l, o)) continue;
         // The frame's own pending observer (off screen: this one holds nothing;
         // the next listed node may).
                 if (l.i === EFFECT_RENDER) {
-            if (onScreen(l, judge ?? n)) return true;
+            if (onScreen(l, judge ?? o)) return true;
             continue;
         }
         for (let e = l.o; e !== null; e = e.t) {
-            const o = e.u;
+            const n = 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
@@ -321,7 +323,7 @@ function blockedBy(e, n, o = 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 ((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;
+                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.Te === n.Ne || n.T?.F != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
         }
     }
     return false;
@@ -334,8 +336,8 @@ function blockedBy(e, n, o = false) {
  * is visible, a lane's reveal included: only the commit that disposes it
  * 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)) && !hiddenHook?.(e);
+ * nothing — boundaries.ts). */ function onScreen(e, o) {
+    return !(e.R & REACTIVE_ZOMBIE && removalStagedBy(e, o)) && !hiddenHook?.(e);
 }
 
 /** A15 (#3463): a reader whose removal is staged — a zombie, parked by a
@@ -343,10 +345,10 @@ function blockedBy(e, n, o = false) {
  * except the transaction staging its removal: for that one its say is moot
  * (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 o = e;
-    while (o?.R & REACTIVE_ZOMBIE) o = o._parent;
-    return o?.l & CONFIG_HELD && o.T?.Je != null && txOf(o) === resolveTx(n);
+ * the nearest non-zombie ancestor. */ function removalStagedBy(e, o) {
+    let n = e;
+    while (n?.R & REACTIVE_ZOMBIE) n = n._parent;
+    return n?.l & CONFIG_HELD && n.T?.Je != null && txOf(n) === resolveTx(o);
 }
 
 /** Unchanged passes this flush whose stale dependency tail awaits the
@@ -372,18 +374,18 @@ function deferZombie(e) {
 }
 
 /** Put a staged node in a transaction: flagged, stamped, on its landing
- * list. */ function holdNode(e, n) {
+ * list. */ function holdNode(e, o) {
     e.l |= CONFIG_HELD;
-    list(e, n);
+    list(e, o);
 }
 
 /** 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 o = ext(e);
-    if (o.Je === n) return;
-    o.Je = n;
-    n.je.push(e);
+ * other), so a re-pass, a re-landing or a re-staging adds nothing. */ function list(e, o) {
+    const n = ext(e);
+    if (n.Je === o) return;
+    n.Je = o;
+    o.je.push(e);
 }
 
 /** Hold the (uncommitted) frame under a held pass: every computed in the
@@ -398,22 +400,22 @@ function deferZombie(e) {
  * and `dissolveLane` no longer finds it — a lane node with no lane, which the
  * 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 o = e.ze; o !== null; o = o.Xe) {
-        if (o.T?.Je?.V) continue;
-        if (o.X !== undefined) {
-            if (!(o.l & CONFIG_HELD)) holdNode(o, n);
-            o.l |= CONFIG_HELD_FRAME;
+ * retired at the lane's seam. */ function holdFrame(e, o) {
+    for (let n = e.ze; n !== null; n = n.Xe) {
+        if (n.T?.Je?.V) continue;
+        if (n.X !== undefined) {
+            if (!(n.l & CONFIG_HELD)) holdNode(n, o);
+            n.l |= CONFIG_HELD_FRAME;
         }
-        holdFrame(o, n);
+        holdFrame(n, o);
     }
 }
 
 /** 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) {
+ * what an earlier hold staged under a re-armed boundary). */ function heldUnder(e, o, n) {
     for (let t = e.ze; t !== null; t = t.Xe) {
-        if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(t) !== n) o(t);
-        heldUnder(t, n, o);
+        if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(t) !== o) n(t);
+        heldUnder(t, o, n);
     }
 }
 
@@ -510,7 +512,9 @@ function schedule() {
 function haltReactivity(e) {
     if (halted) return;
     halted = true;
-    let n = "[REACTIVITY_HALTED]";
+    // A cleanup error collected before the halt is dropped (owner.ts).
+        rethrowCleanupError(true);
+    let o = "[REACTIVITY_HALTED]";
     // Surface the cause here too: callers rethrow it, but a creation-time throw
     // unwinds through ancestor recomputes that convert it to status instead of
     // surfacing it (#2884), so the rethrow alone cannot guarantee visibility.
@@ -520,9 +524,18 @@ 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 o = e !== undefined && globalThis.reportError;
-    o || e === undefined ? console.error(n) : console.error(n, e);
-    o && o(e);
+        const n = e !== undefined && globalThis.reportError;
+    n || e === undefined ? console.error(o) : console.error(o, e);
+    n && n(e);
+}
+
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */ function haltReactivityAt(e, o) {
+    haltReactivity(e);
 }
 
 // Logs on the first write after a halt so a frozen interaction is traceable.
@@ -595,13 +608,13 @@ class GlobalQueue {
         // 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.V ? resolveTx(e) : null;
-        if (n !== null) {
+                const o = e !== null && !e.V ? resolveTx(e) : null;
+        if (o !== 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 o = 0; o < e; o++) {
-                const e = pendingNodes[o];
+            for (let n = 0; n < e; n++) {
+                const e = pendingNodes[n];
                 // 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).
@@ -629,15 +642,15 @@ class GlobalQueue {
                         e.l &= ~CONFIG_STAGED;
                         continue;
                     }
-                    holdNode(e, n);
+                    holdNode(e, o);
                 }
                 // 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.l & CONFIG_STAGED) holdFrame(e, n);
+                                if (e.l & CONFIG_STAGED) holdFrame(e, o);
             }
             pendingNodes.length = 0;
-            storeParkHook?.(n);
+            storeParkHook?.(o);
             // (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.)
@@ -648,10 +661,10 @@ class GlobalQueue {
             // holder's verdict lane's work — before the lane seams, which reveal
             // it (nothing commits this seam that could dispose it).
             // (Verdict readers exist only with the verdict engine installed.)
-                        const o = deferredZombies.splice(0);
+                        const n = deferredZombies.splice(0);
             if (observeFlightHook) {
-                o.sort((e, n) => e.Et - n.Et);
-                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]);
+                n.sort((e, o) => e.Et - o.Et);
+                for (let e = 0; e < n.length; e++) if ((n[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && n[e].l & CONFIG_VERDICT) recompute(n[e]);
             }
             // The unchanged passes' tails stay linked (A30, #3469): their inputs
             // are held, and the committed frame still derives from them — no trim.
@@ -663,8 +676,8 @@ class GlobalQueue {
             // left an effect owing a run (`runEffect` trims when the run applies):
             // `recompute`'s own gates.
                         for (let e = 0; e < heldTrims.length; e++) {
-                const n = heldTrims[e];
-                if (n.T?.F == null && !n.Qe) trimStaleDeps(n);
+                const o = heldTrims[e];
+                if (o.T?.F == null && !o.Qe) trimStaleDeps(o);
             }
         }
         // The list is the flush's either way. Reset only when there is something
@@ -678,22 +691,22 @@ 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 o = this.un;
+                const n = this.un;
         const t = 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).
                 if (laneSeamsHook) {
-            laneSeamsHook(n !== null ? stagedReaders : null);
+            laneSeamsHook(o !== 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;
+            const o = transactions[e];
+            if (blocked(o)) continue;
             transactions.splice(e, 1);
-            endLanesHook?.(n);
-            land(n);
+            endLanesHook?.(o);
+            land(o);
             // A landing's commits can dispose a zombie a transaction judged above
             // was blocked on (#3463: live "until the commit that disposes it") —
             // judge them again.
@@ -706,7 +719,7 @@ class GlobalQueue {
         // 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).
-                const l = n && liveTx(n);
+                const l = o && liveTx(o);
         releaseAmbientMarksHook?.(l);
         // The effect phase: lane work first (displayed ahead of the frame), then
         // this flush's runs, then the runs the landings held from earlier
@@ -725,19 +738,19 @@ class GlobalQueue {
             holding = true;
         }
         for (let e = 0; e < 2; e++) {
-            if (s) append(l.un[e], o[e]);
+            if (s) append(l.un[e], n[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.un[e] = s || t[e].length || this.un[e].length ? t[e].concat(s ? [] : o[e], this.un[e]) : o[e];
+                        this.un[e] = s || t[e].length || this.un[e].length ? t[e].concat(s ? [] : n[e], this.un[e]) : n[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.Et - n.Et);
-            for (let n = 0; n < e.length; n++) {
-                if (!(e[n].R & REACTIVE_DISPOSED)) recompute(e[n]);
+            const e = deferredZombies.splice(0).sort((e, o) => e.Et - o.Et);
+            for (let o = 0; o < e.length; o++) {
+                if (!(e[o].R & REACTIVE_DISPOSED)) recompute(e[o]);
             }
         }
         // Boundaries: readers that settled, landed or died this flush are
@@ -745,18 +758,18 @@ class GlobalQueue {
                 boundarySeamHook?.();
     }
     run(e) {
-        const n = this.un[e - 1];
-        if (n.length) {
+        const o = this.un[e - 1];
+        if (o.length) {
             this.un[e - 1] = [];
-            runQueue(n, e);
+            runQueue(o, e);
         }
     }
-    enqueue(e, n, o = passLane) {
+    enqueue(e, o, n = 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) (o !== null ? o : this).un[e - 1].push(n);
+        if (e) (n !== null ? n : this).un[e - 1].push(o);
         schedule();
     }
     /** Status reaching the root: pending is absorbed (the root mount defers —
@@ -772,10 +785,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, o, t) {
-        if (catchHook?.(e, o & n, t)) return true;
-        if (n & STATUS_PENDING) {
-            if (o & STATUS_PENDING) {
+     * never hears of it. */    notify(e, o, n, t) {
+        if (catchHook?.(e, n & o, t)) return true;
+        if (o & STATUS_PENDING) {
+            if (n & 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
@@ -806,60 +819,71 @@ class GlobalQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * 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) {
+ * it. Truthy when an effect re-derives (`land`). */ function reruns(e) {
+    let o;
     for (let n = 0; n < e.En.length; n++) {
-        const o = e.En[n];
+        const t = 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.Qe = false;
+                if (t.R & REACTIVE_DISPOSED || t.m & STATUS_ERROR) continue;
+        if (t.R & REACTIVE_FRAME_READ || t.l & CONFIG_VERDICT) {
+            o ||= t.i;
+            t.R &= ~REACTIVE_FRAME_READ;
+            t.Qe = 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 = o.ze; e !== null; e = e.Xe) if (e.i) e.Qe = false;
-            enqueueSub(o);
+                        for (let e = t.ze; e !== null; e = e.Xe) if (e.i) e.Qe = false;
+            enqueueSub(t);
         }
     }
     e.En.length = 0;
+    return o;
 }
 
 /** The landing: the held frame becomes the frame. */ function land(e) {
     // Attribution hook: judged complete — its held writes commit next
     // (`_nodes` still lists them).
     if (attrHooks !== null) attrHooks.transitionSettled(e);
-    reruns(e);
+    const o = reruns(e);
     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.je.length; n++) {
-        const o = e.je[n];
-        if (o.T.Je === null || txOf(o) !== e) continue;
-        o.T.Je = null;
-        commitPendingNode(o);
+        for (let o = 0; o < e.je.length; o++) {
+        const n = e.je[o];
+        if (n.T.Je === null || txOf(n) !== e) continue;
+        n.T.Je = null;
+        commitPendingNode(n);
     }
     // 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);
+    // An effect re-derives next round (`reruns`): the held runs wait for it
+    // (D-9, the A15 reveal corollary, #4071). Its re-derivation can discover a
+    // flight — a stale reader whose mainline pass stopped reading it, now
+    // reading the landed world — and a landing that showed its runs first
+    // would reveal the held write beside a frame that can only show its old
+    // value. Queued last in this effect phase, the release hands them to the
+    // next round's own runs, ahead of the re-derivation's: they show with it,
+    // or park with it in the hold its pending opens. The commits stand.
+        if (o) globalQueue.un[1].push(() => releaseQueues(e)); else releaseQueues(e);
 }
 
 /** The held runs join this flush's effect phase after its own runs (the
  * landing's re-passes, in height order): the frame's effects run as one
  * 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.un[n], e.un[n]);
-        e.un[n] = [];
+    for (let o = 0; o < 2; o++) {
+        append(globalQueue.un[o], e.un[o]);
+        e.un[o] = [];
     }
 }
 
-/** `a.push(...b)` without the argument-count limit. */ function append(e, n) {
-    for (let o = 0; o < n.length; o++) e.push(n[o]);
+/** `a.push(...b)` without the argument-count limit. */ function append(e, o) {
+    for (let n = 0; n < o.length; n++) e.push(o[n]);
 }
 
 /** Nodes staged this flush (`_pendingValue` set), committed at its end. */ const pendingNodes = [];
@@ -871,10 +895,10 @@ class GlobalQueue {
 
 /** A15's stale reader: `c` was served the committed value of a node `t`
  * holds (a render effect, a verdict reader, lane work) and is re-derived
- * after `t`'s landing (`_reruns`). Once per pass. */ function staleReader(e, n) {
+ * after `t`'s landing (`_reruns`). Once per pass. */ function staleReader(e, o) {
     if (!(e.R & REACTIVE_FRAME_READ)) {
         e.R |= REACTIVE_FRAME_READ;
-        n.En.push(e);
+        o.En.push(e);
     }
 }
 
@@ -900,13 +924,13 @@ function insertSubs(e) {
     // 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.l;
-    const o = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.lt !== undefined;
+        const o = e.l;
+    const n = (o & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.lt !== undefined;
     // Observe-tier fan-out: this walk visits every subscriber edge anyway, so
     // the graph-size count is one local increment here and no field anywhere.
         let t = 0;
-    for (let n = e.o; n !== null; n = n.t) {
-        const e = n.u;
+    for (let o = e.o; o !== null; o = o.t) {
+        const e = o.u;
         t++;
         // Missed-wake latch (#3037): this write is landing while the subscriber
         // is mid-recompute (a nested pull committing beneath its reads), and the
@@ -916,8 +940,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.Te === e.Ne && n !== e._) e.R |= REACTIVE_MISSED_WAKE;
-        if (o && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.Te === e.Ne && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
+        if (n && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
@@ -933,25 +957,25 @@ function insertSubs(e) {
  * inert for its pass (`recompute` seats a lane only from its own `_x`), it
  * 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 o = e.o; o !== null; o = o.t) {
-        const e = o.u.T?.Je;
-        if (e?.V ? sameLane(e, n) : o.u.i) o.u.R |= REACTIVE_LANE_DIRTY;
+ * (the lane-membership ruling, 2026-10-05; `_update`). */ function laneDirty(e, o) {
+    for (let n = e.o; n !== null; n = n.t) {
+        const e = n.u.T?.Je;
+        if (e?.V ? sameLane(e, o) : n.u.i) n.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;
+/** One lane, or two of one link group (#3335): one reveal unit. */ function sameLane(e, o) {
+    return e === o || e.nn !== null && e.nn === o.nn;
 }
 
 function commitPendingNode(e) {
-    const n = e;
+    const o = e;
     // L2: the commit is where a pass, held or not, stops being uncommitted —
     // unless it has no answer yet. A pass still in flight (pending, nothing
     // 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.X) {
+        if (!o.X) {
         e.l &= -385;
         if (e.ue !== NOT_PENDING) {
             e.Ie = e.ue;
@@ -962,62 +986,62 @@ function commitPendingNode(e) {
     // 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 o = e.ue === NOT_PENDING && (n.m & STATUS_PENDING) !== 0;
+        const n = e.ue === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
     const t = 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;
+        if (!n && o.T) o.T.de = undefined;
+    e.l = n ? 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 (t) {
-        const o = e.ue;
+        const n = e.ue;
         e.ue = NOT_PENDING;
         e.ie = clock + 1;
-        notifyStatus(n, STATUS_ERROR, o);
+        notifyStatus(o, STATUS_ERROR, n);
     } else if (e.ue !== NOT_PENDING) {
         e.Ie = e.ue;
         e.ue = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
-                n.m &= ~STATUS_UNINITIALIZED;
+                o.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.T != null) n.T.ut = false, n.T.Gt = NOT_PENDING;
+                if (o.T != null) o.T.ut = false, o.T.Gt = 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.Qe = true;
-            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.K.bind(null, n));
+            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.K.bind(null, o));
         }
     }
     // 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.ce = false;
-    n.R &= ~REACTIVE_MANUAL_WRITE;
+        o.ce = false;
+    o.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
     // staged pass). Only after a clean pass: `_error` is cleared by a clean
     // 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.T?.F == null) trimStaleDeps(n);
-    if (!(n.m & STATUS_PENDING)) n.m &= ~STATUS_UNINITIALIZED;
+        if (o.T?.F == null) trimStaleDeps(o);
+    if (!(o.m & STATUS_PENDING)) o.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 (!o && n.T != null && (n.T.Nt !== null || n.T.ft !== null)) GlobalQueue.et(n, false, true);
+        if (!n && o.T != null && (o.T.Nt !== null || o.T.ft !== null)) GlobalQueue.et(o, false, true);
 }
 
 function commitPendingNodes() {
     for (let e = 0; e < pendingNodes.length; e++) {
-        const n = pendingNodes[e];
+        const o = pendingNodes[e];
         // 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.l & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
+                if (!(o.l & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(o);
     }
     pendingNodes.length = 0;
 }
@@ -1049,24 +1073,27 @@ function flush(e) {
     // Attribution: whether this call drained anything, so `flushEnd` fires once
     // per real drain and never for a no-op call. The declaration is dead in
     // prod (its only write is behind true) and rollup drops it.
-        let n = false;
+        let o = false;
     // The drain's opening instant, under the loop's own condition so it fires
     // exactly when `flushEnd` below will. Outside every try (see the rule in
     // attribution-hooks.ts).
         if (attrHooks !== null && scheduled) attrHooks.flushStart();
     while (scheduled) {
         globalQueue.flush();
-        n = true;
+        o = true;
     }
     // Outside every try in this function (see the rule in attribution-hooks.ts):
     // the drain loop above is the one place all scheduled work funnels through,
     // so this is the "committed and effects ran" instant for everything the
     // loop processed.
-        if (n && attrHooks !== null) attrHooks.flushEnd();
+        if (o && attrHooks !== null) attrHooks.flushEnd();
+    // A cleanup that threw during the drain, now that the drain is complete
+    // (owner.ts).
+        rethrowCleanupError();
 }
 
-function runQueue(e, n) {
-    for (let o = 0; o < e.length; o++) e[o](n);
+function runQueue(e, o) {
+    for (let n = 0; n < e.length; n++) e[n](o);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, blockersOf, 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 };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, blockersOf, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, 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 };