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

package/dist/prod/core/scheduler.js

@@ -1,87 +1,458 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } 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, CONFIG_FRAME } from "./constants.js";
 
-import { currentOptimisticLane } from "./core.js";
+import { attrHooks } from "./attribution-hooks.js";
+
+import { notifyStatus } from "./async.js";
+
+import { resyncUnflushedCompanions, isSame, recompute, markUnflushedStaged, ext } from "./core.js";
 
 import { DEV } from "./dev.js";
 
-import { NotReadyError } from "./error.js";
+import { sweepDormant, trimStaleDeps } from "./graph.js";
 
-import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
+import { runHeap, enqueueSub, deleteFromHeap } from "./heap.js";
 
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
+import { devCheckQuiescent } from "./invariants.js";
 
-export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
+import { rethrowCleanupError } from "./owner.js";
 
-import { devCheckFlushStart, devCheckActiveOverrides, devCensusCompanions, 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;
 
-const transitions = new Set;
+let laneStageHook = null;
 
-const dirtyQueue = {
-    eE: new Array(2e3).fill(undefined),
-    tE: false,
-    xe: 0,
-    EE: 0
-};
+let laneOutcomeHook = null;
 
-const zombieQueue = {
-    eE: new Array(2e3).fill(undefined),
-    tE: false,
-    xe: 0,
-    EE: 0
-};
+let laneWriteHook = null;
 
-/** runHeap callback that discards a queued zombie recompute instead of running
- * it: unlink pure recompute entries; strip just the recompute bit from dirtied
- * height-adjust entries so their height work still happens. */ function cancelZombieRecompute(e) {
-    if (e.ie & REACTIVE_IN_HEAP_HEIGHT) e.ie &= -12; else {
-        deleteFromHeap(e, zombieQueue);
-        e.ie &= -4;
-    }
+let applyGuessesHook = null;
+
+let laneSeamsHook = null;
+
+let laneCorrectionsHook = null;
+
+let endLanesHook = null;
+
+let lanesBlockedHook = null;
+
+/** R5 (lanes.ts `laneSeams` parks a frame flight): the landing's re-derive
+ * of a reader adopts the flight instead (true: adopted, nothing to queue). */ let laneAdoptHook = null;
+
+/** core.ts `frameRead` served lane work or a verdict reader a held node's
+ * committed value (lanes.ts `laneServed`). */ let laneServedHook = null;
+
+/** A guess was written (lanes.ts `optimisticWrite`): the arms only a guess
+ * reaches (CONFIG_GUESS) — a build without `createOptimistic` or
+ * `createOptimisticStore` never sets it, and its bundler folds them. */ let guessing = false;
+
+function armGuessing() {
+    guessing = true;
 }
 
-let clock = 0;
+function installLaneHooks(e, o, n, l, t, s, u, i, r, a, f) {
+    laneReadHook = e;
+    laneStageHook = o;
+    laneOutcomeHook = n;
+    laneWriteHook = l;
+    applyGuessesHook = t;
+    laneSeamsHook = s;
+    laneCorrectionsHook = u;
+    endLanesHook = i;
+    lanesBlockedHook = r;
+    laneAdoptHook = a;
+    laneServedHook = f;
+}
 
-let activeTransition = null;
+// 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 scheduled = false;
+let freshHook = null;
 
-let halted = false;
+let hiddenHook = null;
 
-let haltNotified = false;
+let boundarySeamHook = null;
 
-let syncDepth = 0;
+let heldRunHook = null;
+
+function installBoundaryHooks(e, o, n, l, t) {
+    catchHook = e;
+    freshHook = o;
+    hiddenHook = n;
+    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, o) {
+    storeParkHook = e;
+    storeCommitHook = o;
+}
+
+/** `affects()` marks (affects.ts): the releases at a landing and at the seam
+ * (ambient marks). */ let releaseMarksHook = null;
+
+let releaseAmbientMarksHook = null;
+
+function installMarkHooks(e, o) {
+    releaseMarksHook = e;
+    releaseAmbientMarksHook = o;
+}
+
+/** Verdicts (verdict.ts). */ let observeFlightHook = null;
+
+/** D-25's hold work (verdict.ts `holdWork`): on `source` going pending,
+ * whether verdict reader `n` waits on it instead of re-deriving. */ let holdWorkHook = null;
+
+function installVerdictHooks(e, o) {
+    observeFlightHook = e;
+    holdWorkHook = o;
+}
+
+/** External-source bridge (wired by enableExternalSource(); undefined while
+ * no config is active — including after _resetExternalSourceConfig()). */ let wireExternalSourceHook = undefined;
+
+let externalUntrackHook = undefined;
+
+function setExternalHooks(e, o) {
+    wireExternalSourceHook = e;
+    externalUntrackHook = o;
+}
+
+/** 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, o = null) {
+    const n = {
+        tn: [],
+        un: [ [], [] ],
+        En: [],
+        eo: null,
+        _parent: o,
+        P: e,
+        Pe: null,
+        tt: 0,
+        nt: false,
+        en: null,
+        Ue: false,
+        ln: false,
+        I: null
+    };
+    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":
+// 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. 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.
+
+// The seat of a pass is its node's: a node carrying a lane's 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; a leaf's never does (it reads the
+// screen). Lane work's values go to the lane slot, its runs to the lane's
+// queues; the rest of the frame is the flush's.
+/** The lane the running pass is work of; set at `recompute`'s head from the
+ * node, moved by a derivation's lane read, saved and restored around the
+ * pass. */ let passLane = null;
+
+function setPassLane(e) {
+    passLane = e;
+}
+
+/** The transaction this flush parks into: set by the first join, merged
+ * with every further one. Consumed at the seam. A join outside a flush (a
+ * mount's pending observer, a write to a held node, an action opening)
+ * schedules the seam that consumes it: membership is the tick's — the same
+ * synchronous frame — and the next tick's writes are not this one's. */ let flushTransaction = null;
+
+/** The flush's transaction while only a `latest()` read of a staging opened
+ * it (verdict.ts `provisionalVerdict`): it holds nothing, and a verdict
+ * reader's plain read of a staging in it is the frame's read (D-22). */ let latestOpened = null;
+
+/** The transaction the passes running OUTSIDE a flush this tick derive from
+ * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
+ * time form — "the entry is the pass's alone"): their results are staged
+ * into it, and nothing else in the tick is — a write made after the mount
+ * is a mainline write, a render effect mounted beside it a stale reader.
+ * Inside a flush, or in a tick that already has its transaction (an
+ * action's body), the frame joins instead (`flushTransaction`) — except a
+ * first pass a loading boundary that has not shown content catches (`own`,
+ * A29's boundary exemption, #3540): it is the boundary's, not the tick's,
+ * and a flush that has joined nothing keeps it pass-scoped as outside one.
+ * Cleared by the flush the join schedules, and at the end of a flush that
+ * set it. */ let passTx = null;
+
+function joinPassTx(e, o) {
+    if (globalQueue.Y && !o || 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.T.Re = resolveTx(e.T.Re);
+}
+
+/** `t` resolved through merges while it is still parked or open; null once
+ * it has landed. */ function liveTx(e) {
+    e = resolveTx(e);
+    return transactions.indexOf(e) !== -1 ? e : null;
+}
+
+function resolveTx(e) {
+    while (e.eo !== null) e = e.eo;
+    return e;
+}
 
-let projectionWriteActive = false;
+/** 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 o = flushTransaction;
+    if (o === null) {
+        flushTransaction = e === null ? newTransaction(false) : resolveTx(e);
+    } else if (e !== null) merge(resolveTx(e), o);
+    if (!globalQueue.Y) 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, 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);
+    o = resolveTx(o);
+    if (e === o || e.P || o.P) return;
+    e.eo = o;
+    o.tt += e.tt;
+    o.nt ||= e.nt;
+    append(o.tn, e.tn);
+    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);
+}
+
+/** A15: a hold is a property of the async node — observed pending by a
+ * render reader. A transaction is blocked while a node it holds, in flight,
+ * has one: a pending render effect (the frame itself), or a pending held
+ * node a render effect reads. A stale reader served the committed value
+ * never went pending, but derives from the flight all the same (#3494) and
+ * is still linked to it; a memo between them is pending, and held, too — so
+ * one hop of `_subs` is the chain. Reads of the reader's LAST pass only (the
+ * link's generation is the pass's): a tail kept for A30 — the committed
+ * frame's dependency, awaiting the run that retires it — is not a read of
+ * the flight, and a reader that stopped reading releases it (O3, #3494).
+ * An errored pass (NotReady included) did not stop: it never got there, and
+ * its full list stands (A30) — the reads it did not reach still observe. A
+ * flight nobody renders holds nothing (A29). Only the nodes `t` still owns
+ * count: one a lane took over since is the lane's to wait on. A guess whose
+ * own truth is in flight blocks the lane's parent, not the lane — it stands
+ * 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 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 n = e.tt !== 0 || blockedBy(e.tn, e) || !!lanesBlockedHook?.(e);
+    judge = o;
+    return n;
+}
+
+let judge = null;
 
-// Store property nodes that were created solely to carry a pending write (no
-// subscribers at write time). Swept after each flush that commits pending
-// values — any still without subs get disposed via their `_unobserved` hook,
-// releasing the slot in the parent store's node map.
-const transientStoreNodes = new Set;
+/** `t`'s own flights only — not its lanes': a flight the frame asked for
+ * (a refetch, a plain load) is authoritative; a lane's derivation flight is
+ * 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.tn, e, true);
+}
 
-function canUseSimpleSyncFlush(e) {
-    const t = e.k;
-    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.m.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+/** 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, o) {
+    const n = e.T?.se;
+    if (n === undefined) return true;
+    for (const e of n) {
+        const n = e.T?.Re;
+        if (n == null || resolveTx(n) === o) return true;
+    }
+    return false;
 }
 
-function sweepTransientStoreNodes() {
-    if (transientStoreNodes.size === 0) return;
-    for (const e of transientStoreNodes) {
-        if (e.u !== null) {
-            transientStoreNodes.delete(e);
+function blockedBy(e, o, n = false) {
+    for (let l = 0; l < e.length; l++) {
+        const t = e[l];
+        if (!(t.m & STATUS_PENDING) || t.R & REACTIVE_DISPOSED || t.l & CONFIG_GUESS || t.T.Re !== null && txOf(t) !== o || n && !ownSource(t, o)) continue;
+        // The frame's own pending observer (off screen: this one holds nothing;
+        // the next listed node may).
+                if (t.i === EFFECT_RENDER) {
+            if (onScreen(t, judge ?? o)) return true;
             continue;
         }
-        if (e.Pe !== NOT_PENDING) continue;
-        if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) continue;
-        // A live affects() mark keeps the node addressable: sweeping it would
-        // detach the refcount from the slot (a fresh probe would upsert a new,
-        // unmarked node for the same property).
-                if (e.o?.t) continue;
-        transientStoreNodes.delete(e);
-        e.o?.ft?.();
+        for (let e = t.o; e !== null; e = e.t) {
+            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
+            // from the flight all the same and is re-derived at the landing — the
+            // frame's observation survives its reader becoming a lane's (a guess
+            // over a held window, V5/A17). A probe alone does not hold. A
+            // boundary showing content forwards the pending (its output pending,
+            // CONFIG_REDERIVE): transparent, its readers hold through it (A33; the
+            // lane-membership ruling, 2026-10-05). An output that never committed
+            // shows nothing — a mount the frame has not revealed — and holds
+            // nothing.
+                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.Ne === n.de || n.T?.U != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
+        }
+    }
+    return false;
+}
+
+/** A frame reader whose say counts for `t`'s hold — `t` the transaction
+ * being judged: not a zombie whose removal `t` stages (A15 #3463: a re-ask
+ * in the unmount frame lands its pending on the zombie it unmounts — the
+ * compiled <Show> of #3372; a zombie blocks every other judgment while it
+ * 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, o) {
+    return !(e.R & REACTIVE_ZOMBIE && removalStagedBy(e, o)) && !hiddenHook?.(e);
+}
+
+/** A15 (#3463): a reader whose removal is staged — a zombie, parked by a
+ * pass awaiting its commit — is still on screen and live for every hold,
+ * 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, o) {
+    let n = e;
+    while (n?.R & REACTIVE_ZOMBIE) n = n._parent;
+    return n?.l & CONFIG_HELD && n.T?.Re != null && txOf(n) === resolveTx(o);
+}
+
+/** Unchanged passes this flush whose stale dependency tail awaits the
+ * flush's verdict (A30, #3469): trimmed when the flush commits, kept when
+ * it parks — the committed frame still derives from the previous pass's
+ * dependencies, and a write to one of them must reach the node until a
+ * committing pass replaces it. */ const heldTrims = [];
+
+function heldTrim(e) {
+    heldTrims.push(e);
+}
+
+/** Zombies popped from the dirty heap this flush (`deferZombie`). The seam
+ * decides their fate: a park cancels them (the writes that dirtied them are
+ * held with it); a commit runs the survivors — the ones whose owner is still
+ * awaiting its commit — in height order, after the commits that would have
+ * disposed them (#3546). No second heap: the list is the deferral. */ const deferredZombies = [];
+
+function deferZombie(e) {
+    deleteFromHeap(e, dirtyQueue);
+    e.R &= -4;
+    deferredZombies.push(e);
+}
+
+/** Put a staged node in a transaction: flagged, stamped, on its landing
+ * list. */ function holdNode(e, o) {
+    e.l |= CONFIG_HELD;
+    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, o) {
+    const n = ext(e);
+    if (n.Re === o) return;
+    n.Re = o;
+    o.tn.push(e);
+}
+
+/** Hold the (uncommitted) frame under a held pass: every computed in the
+ * live child chain, recursively. Plain owners are walked through, not held
+ * — nothing reads or re-passes them. Once per park, over the parked frames
+ * only; recomputes pay nothing for it. A lane's node in the frame (listed on
+ * a lane: a verdict reader broken out of this very hold — display-ahead — or
+ * a derivation of a guess, CONFIG_OVERRIDE; a lane pass's effect) is the
+ * lane's, as the seam's own loop has it: "lane work never makes its node
+ * transaction work" (A15, #3698). Re-listed here it would carry the lane's
+ * value on the transaction's list, where the landing nulls its transaction
+ * 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, o) {
+    for (let n = e.pe; n !== null; n = n.Ge) {
+        if (n.T?.Re?.P) continue;
+        if (n.X !== undefined) {
+            if (!(n.l & CONFIG_HELD)) holdNode(n, o);
+            n.l |= CONFIG_HELD_FRAME;
+        }
+        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, o, n) {
+    for (let l = e.pe; l !== null; l = l.Ge) {
+        if ((l.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(l) !== o) n(l);
+        heldUnder(l, o, n);
     }
 }
 
+/** `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 = {
+    et: new Array(2e3).fill(undefined),
+    p: false,
+    Fe: 0,
+    Et: 0
+};
+
+let clock = 0;
+
+let scheduled = false;
+
+let halted = false;
+
+let haltNotified = false;
+
+let syncDepth = 0;
+
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
  * window. Only `render()` calls this — wrapping the initial mount so that a
@@ -91,63 +462,40 @@ function sweepTransientStoreNodes() {
  * @internal
  */ function enforceLoadingBoundary(e) {}
 
-function setProjectionWriteActive(e) {
-    projectionWriteActive = e;
+// Dev-only marker for the effect half of createEffect/createRenderEffect, so
+// flush() can report the no-op instead of failing silently (React parity).
+/** Action bodies on the stack (action.ts): `flush()` is refused inside one —
+ * the body's writes are its transaction's and commit when it settles; a
+ * drain mid-step cannot reveal them, and dev says so. */ let actionDepth = 0;
+
+function enterAction() {
+    actionDepth++;
 }
 
-/**
- * Ambient work IS a transaction: the global queue always carries one
- * current-transaction-shaped batch (`globalQueue._batch`). With no transition
- * active, registrations (pending commits, optimistic nodes, affects marks,
- * optimistic stores) land in a plain ambient batch that the plain flush
- * finalizes; when a transition initializes it adopts the ambient batch's
- * contents and `_batch` becomes the transition itself, so later registrations
- * land there directly — no per-field aliasing.
- */ function createBatch() {
-    return {
-        Te: clock,
-        yt: [],
-        Ne: new Map,
-        Ke: [],
-        m: [],
-        cn: new Set,
-        oe: [],
-        bt: {
-            Lt: [ [], [] ],
-            Qt: []
-        },
-        an: false,
-        ln: new Set
-    };
+function exitAction() {
+    actionDepth--;
 }
 
-function mergeTransitionState(e, t) {
-    t.an = e;
-    e.oe.push(...t.oe);
-    for (const i of activeLanes) if (i._e === t) i._e = e;
-    if (t.Ke.length) {
-        // Move (don't copy): the global queue's batch may still be the outgoing
-        // transition, and the adoption pass in initTransition would re-push its
-        // contents into the target — duplicating every entry.
-        e.Ke.push(...t.Ke);
-        t.Ke.length = 0;
-    }
-    if (t.m.length) {
-        // Move (don't copy): the global queue's batch may still be the outgoing
-        // transition, and the adoption pass in initTransition would re-push its
-        // contents into the target — double-releasing every mark.
-        e.m.push(...t.m);
-        t.m.length = 0;
-    }
-    for (const i of t.cn) e.cn.add(i);
-    for (const [i, n] of t.Ne) {
-        let t = e.Ne.get(i);
-        if (!t) e.Ne.set(i, t = new Set);
-        for (const e of n) t.add(e);
-    }
-    for (const i of t.ln) e.ln.add(i);
+/** Provenance (A18, #3331): the question being asked — an action's
+ * sequence while a slice of its body and the flush that carries it run, 0
+ * otherwise. A guess is stamped with it (lanes.ts; a mainline guess takes a
+ * fresh sequence: the newest intent), a flight with the question that
+ * started it (async.ts; mainline is always the current question). An
+ * answer from an older question than the guess it lands on is stale: held
+ * silently, it does not move the graph. */ let question = 0;
+
+let questions = 0;
+
+function setQuestion(e) {
+    question = e;
 }
 
+function nextQuestion() {
+    return ++questions;
+}
+
+const MAINLINE_QUESTION = 2147483647;
+
 function schedule() {
     if (halted) {
         notifyHalted();
@@ -155,28 +503,60 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.Y) {
+        queueMicrotask(flush);
+    }
 }
 
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
  * entirely rather than limping along with a half-applied update.
- */ function haltReactivity(e) {
+ */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */ const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
+
+const HALTED = "[REACTIVITY_HALTED]";
+
+function haltReactivity(e) {
     if (halted) return;
     halted = true;
-    let t = "[REACTIVITY_HALTED]";
-    // Log the cause here too: callers rethrow it, but a creation-time throw
+    // A cleanup error collected before the halt is dropped (owner.ts).
+        rethrowCleanupError(true);
+    let o = 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.
-        e === undefined ? console.error(t) : console.error(t, e);
+    // Where the platform has one, hand the cause to its uncaught-error channel
+    // (`reportError` → `error` event → window.onerror / error monitoring): a
+    // halt that only reaches console.error leaves a page that LOOKS alive with
+    // 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 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.
 function notifyHalted() {
     if (haltNotified) return;
     haltNotified = true;
-    console.error("[REACTIVITY_HALTED]");
+    console.error(HALTED);
 }
 
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */ function resetErrorHalt() {
@@ -184,348 +564,372 @@ function notifyHalted() {
     haltNotified = false;
 }
 
-// Identifies one child-traversal pass in `Queue.run` so a rescan after the
-// child list shifts can tell "already run this pass" from "still pending".
-let queueRunToken = 0;
-
-class Queue {
-    ve=null;
-    Lt=[ [], [] ];
-    Qt=[];
-    Mt=0;
-    created=clock;
-    addChild(e) {
-        this.Qt.push(e);
-        e.ve = this;
-    }
-    removeChild(e) {
-        const t = this.Qt.indexOf(e);
-        if (t >= 0) {
-            this.Qt.splice(t, 1);
-            e.ve = null;
-        }
-    }
-    notify(e, t, i, n) {
-        if (this.ve) return this.ve.notify(e, t, i, n);
-        return false;
-    }
-    run(e) {
-        if (this.Lt[e - 1].length) {
-            const t = this.Lt[e - 1];
-            this.Lt[e - 1] = [];
-            runQueue(t, e);
-        }
-        // Effects run here can dispose owners, and disposal removes queues from
-        // this list — the running child itself, an earlier sibling, or several at
-        // once. A plain index walk then skips whatever shifted into the cursor.
-        // Stamping each child before it runs makes the pass idempotent, so a shift
-        // can be recovered by rescanning from the front and every child still runs
-        // exactly once. Children appended mid-pass carry a stale stamp and run,
-        // matching the previous live-array behaviour.
-                const t = this.Qt;
-        const i = ++queueRunToken;
-        for (let n = 0; n < t.length; ) {
-            const s = t[n];
-            if (s.Mt !== i) {
-                s.Mt = i;
-                s.run?.(e);
-                if (t[n] !== s) {
-                    n = 0;
-                    continue;
-                }
-            }
-            n++;
-        }
-    }
-    enqueue(e, t) {
-        if (e) {
-            // Route to lane's effect queue if we're in an optimistic recomputation
-            if (currentOptimisticLane) {
-                const i = findLane(currentOptimisticLane);
-                i.en[e - 1].push(t);
-            } else {
-                this.Lt[e - 1].push(t);
-            }
-        }
-        schedule();
-    }
-    stashQueues(e) {
-        e.Lt[0].push(...this.Lt[0]);
-        e.Lt[1].push(...this.Lt[1]);
-        this.Lt = [ [], [] ];
-        for (let t = 0; t < this.Qt.length; t++) {
-            let i = this.Qt[t];
-            let n = e.Qt[t];
-            if (!n) {
-                n = {
-                    Lt: [ [], [] ],
-                    Qt: []
-                };
-                e.Qt[t] = n;
-            }
-            i.stashQueues(n);
-        }
-    }
-    restoreQueues(e) {
-        this.Lt[0].push(...e.Lt[0]);
-        this.Lt[1].push(...e.Lt[1]);
-        for (let t = 0; t < e.Qt.length; t++) {
-            const i = e.Qt[t];
-            let n = this.Qt[t];
-            if (n) n.restoreQueues(i);
-        }
-    }
-}
-
-class GlobalQueue extends Queue {
-    sn=false;
-    // The current transaction-shaped batch: a plain ambient batch while no
-    // transition is active, the active transition itself after initTransition.
-    k=createBatch();
-    static Ce;
-    static Fe;
-    static tt;
-    static Vt=null;
-    // Store-side hook: drops a keyless affects() mark's identity scope when the
-    // carrier node's last registration releases (wired by store.ts, mirroring
-    // _clearOptimisticStore).
-    static G=null;
-    // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
-    // engine — count/register/release — lives with the feature. Every call site
-    // is gated by state only that module creates, so `!` invocations are safe
-    // once the gate holds.
-    static M=null;
-    static h=null;
-    static j=null;
-    // External-source bridge (wired by enableExternalSource(); null while no
-    // config is active — including after _resetExternalSourceConfig()).
-    static Rt=null;
-    static Gt=null;
-    // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
-    // imported; null in apps that never use them). Call sites either guard for
-    // null or sit behind state only the verdict layer can create (`!` is safe
-    // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
-    // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
-    // isPending()/latest()).
-    static Oe=null;
-    static de=null;
-    static ye=null;
-    static un=null;
-    static Pt=null;
-    static Dt=null;
-    static Ht=null;
-    static Je=null;
-    static p=null;
-    static Bt=null;
-    // Re-asks probes whose verdict was provisionally suppressed by a fresh read
-    // of a held value, once the transaction gains an async blocker (#3028).
-    static wt=null;
-    // Optimistic-engine hooks (wired by core/optimistic.ts via
-    // installOptimisticEngine(), called from verdict.ts / createOptimistic /
-    // createOptimisticStore — every module that can create optimistic state).
-    // Call sites are gated by state only the engine can create: an
-    // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
-    // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
-    // once the gate holds.
-    static vt=null;
-    static fn=null;
-    static dn=null;
-    static En=null;
-    static Tn=null;
-    static Ft=null;
-    static ht=null;
-    static gt=null;
-    static je=null;
-    static $e=null;
-    static ze=null;
-    static Nn=null;
+class GlobalQueue {
+    un=[ [], [] ];
+    Y=false;
     flush() {
-        if (this.sn) return;
-        // Fast drain: nothing in flight but plain pending commits — no dirty
-        // computeds, no queued effects, no child queues, no transitions/lanes/
-        // optimistic state. Commit and go; anything a commit hook schedules
-        // (companion snaps, store folds notifying subs) re-arms `scheduled`
-        // below and the outer drain loop takes the full spine next round.
-                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.xe && this.Lt[0].length === 0 && this.Lt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
-            this.sn = true;
-            try {
-                commitPendingNodes();
-            } finally {
-                this.sn = false;
-            }
-            clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.k.yt.length !== 0;
-            return;
-        }
-        this.sn = true;
+        if (this.Y) return;
+        this.Y = 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).
+                resyncUnflushedCompanions();
+        passLane = null;
+        passTx = null;
         try {
-            if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.Ce);
-            if (activeTransition) {
-                const e = transitionComplete(activeTransition);
-                if (!e) {
-                    const e = activeTransition;
-                    // When the parking batch IS the transition, all of its writes commit
-                    // only with it — every zombie recompute they queued would run against
-                    // a world the zombie never displays (zombies render mainline until
-                    // commit), so cancel them instead of running them. Only an ambient
-                    // batch's mainline writes (the #2916 shape below) legitimately reach
-                    // zombies here. Height-adjust entries still process normally: a
-                    // dirtied one keeps its height flag and falls through to runHeap's
-                    // adjustHeight path on the next pass of the bucket.
-                                        runHeap(zombieQueue, this.k === e ? cancelZombieRecompute : GlobalQueue.Ce);
-                    // Detach: the stashed transition keeps its batch; ambient work that
-                    // follows lands in a fresh one. If the batch is already a separate
-                    // ambient one — action done() restored activeTransition without
-                    // adopting the batch, and an ordinary write landed there before
-                    // the scheduled flush (#2916) — keep it: replacing it would strand
-                    // its queued pending nodes with held _pendingValues forever.
-                                        if (this.k === e) currentBatch = this.k = createBatch();
-                    // Run lane effects immediately (before stashing) - lanes with no pending async
-                                        if (activeLanes.size) {
-                        GlobalQueue.Tn(EFFECT_RENDER);
-                        GlobalQueue.Tn(EFFECT_USER);
-                    }
-                    this.stashQueues(e.bt);
-                    clock++;
-                    // A kept ambient batch may hold pending nodes (#2916): stay
-                    // scheduled so the outer drain loop commits them via the plain
-                    // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.k.yt.length > 0;
-                    reassignPendingTransition(e.yt);
-                    activeTransition = null;
-                    finalizePureQueue(null, true);
-                    return;
-                }
-                const t = activeTransition;
-                const i = this.k;
-                i !== t && i.yt.push(...t.yt);
-                this.restoreQueues(t.bt);
-                transitions.delete(t);
-                activeTransition = null;
-                reassignPendingTransition(i.yt);
-                finalizePureQueue(t);
-                if (i === t) {
-                    // Drop the dead Transition wrapper but keep its (drained) containers
-                    // as the ambient batch — late registrations during finalization live
-                    // there and must survive to the next flush.
-                    const e = createBatch();
-                    e.yt = i.yt;
-                    e.Ke = i.Ke;
-                    e.m = i.m;
-                    e.cn = i.cn;
-                    currentBatch = this.k = e;
-                }
-            } else {
-                if (canUseSimpleSyncFlush(this)) {
-                    commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.xe) {
-                        runHeap(dirtyQueue, GlobalQueue.Ce);
-                        commitPendingNodes();
-                    }
-                } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
-                    finalizePureQueue();
-                }
-            }
+            // Sweep before the heap: unobserved() pulls swept nodes out of it, so
+            // a dormant memo dirtied in the same tick is reclaimed instead of
+            // recomputed; late subscribers (an effect reading a swept memo this
+            // flush) revive it, which is the pay-for-use contract.
+            sweepDormant();
+            runHeap(dirtyQueue, GlobalQueue._e);
+            this.settle();
             clock++;
-            // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.xe;
-            // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Tn(EFFECT_RENDER);
+            // A write the commit sweep staged with no subscriber to dirty is work
+            // too — the next round commits it.
+                        scheduled = dirtyQueue.Et >= dirtyQueue.Fe || pendingNodes.length !== 0;
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Tn(EFFECT_USER);
             this.run(EFFECT_USER);
-            if (false) ;
-            if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
+            if (false && holding) ;
+            if (false && !scheduled) ;
             if (false) ;
         } finally {
-            this.sn = false;
+            this.Y = false;
+            passTx = null;
         }
     }
-    notify(e, t, i, n) {
-        // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
-        if (t & STATUS_PENDING) {
-            if (i & STATUS_PENDING) {
-                const t = n !== undefined ? n : e.o?._;
-                // A visibility-only mark notification (the affects() boundary
-                // channel) updates display state on its way up but must be invisible
-                // to completion accounting BY CONSTRUCTION: it never registers a
-                // reporter and never counts toward the loading-boundary diagnostic.
-                                if (t?.i) return true;
-                if (activeTransition && t) {
-                    const i = t.source;
-                    let n = activeTransition.Ne.get(i);
-                    if (!n) activeTransition.Ne.set(i, n = new Set);
-                    const s = n.size;
-                    n.add(e);
-                    if (n.size !== s) {
-                        schedule();
-                        GlobalQueue.wt?.(activeTransition);
+    /** L2 — the seam: end of the pure phase. Commit this flush's staged nodes,
+     * or park them with the transaction the flush joined; then land every
+     * transaction no frame is waiting on. The landing flush is an ordinary
+     * flush: the settle walk (async.ts) re-ran the parked readers in its pure
+     * phase, and here no flight the transaction holds has a frame deriving
+     * from it (`blocked`). */    settle() {
+        // 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 (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue._e);
+        const e = flushTransaction;
+        flushTransaction = latestOpened = null;
+        // The frame's verdict is in: the guesses written since the last seam
+        // open their lane under the frame's transaction (a lane's own flush
+        // 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.
+                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 o = e !== null && !e.P ? 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 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).
+                                if (!(e.l & (CONFIG_HELD | CONFIG_OVERRIDE)) && (e.T === null || e.T.Re === null || !e.T.Re.P)) {
+                    // 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
+                    // first landing is commit #0, not a resumption of this frame, and
+                    // a write that reaches it later overlaps nothing (#2937: the
+                    // 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.ue === 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.ue !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.me == null && e.T?.Le == 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.le, e.ue)) {
+                        e.ue = NOT_PENDING;
+                        e.l &= ~CONFIG_STAGED;
+                        continue;
                     }
+                    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, o);
+            }
+            pendingNodes.length = 0;
+            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.)
+            // The batch joins: the writes that dirtied these are held with it — a
+            // zombie never displays that world. A verdict reader among them does
+            // (#3444: `latest()` inside a branch a held Show is removing peers
+            // 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).
+            // (Verdict readers exist only with the verdict engine installed.)
+                        const n = deferredZombies.splice(0);
+            if (observeFlightHook) {
+                n.sort((e, o) => e.he - o.he);
+                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.
+                } else {
+            commitPendingNodes();
+            // The flush committed: an unchanged pass's stale tail goes now. Not
+            // after a later pass this flush that threw (NotReady included — it
+            // keeps its full list, `_depsTail` marking where it stopped) or that
+            // 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 o = heldTrims[e];
+                if (o.T?.U == null && !o.Ae) trimStaleDeps(o);
             }
-            return true;
         }
-        return false;
-    }
-    initTransition(e) {
-        if (e) e = currentTransition(e);
-        if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.Te === clock) return;
-        if (!activeTransition) {
-            activeTransition = e ?? createBatch();
-        } else if (e) {
-            const t = activeTransition;
-            mergeTransitionState(e, t);
-            transitions.delete(t);
-            activeTransition = e;
+        // The list is the flush's either way. Reset only when there is something
+        // to reset (`stagedReaders` below likewise): `length = 0` is a runtime
+        // call even on an empty array, and the plain flush — no unchanged pass,
+        // no lane work — has nothing in either.
+                if (heldTrims.length) heldTrims.length = 0;
+        // Lanes: a blocked one parks its frame (its own flight is up); an
+        // unblocked one reveals this round's work. Then land every transaction
+        // no frame is waiting on — its lanes end with it. Backwards: a landing
+        // removes its entry.
+        // This flush's own runs, the lanes' reveals, and the landings' held runs
+        // are collected apart and ordered below.
+                const n = this.un;
+        const l = [ [], [] ];
+        // 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) {
+            this.un = l;
+            laneSeamsHook(o);
+            if (stagedReaders.length) stagedReaders.length = 0;
         }
-        transitions.add(activeTransition);
-        activeTransition.Te = clock;
-        const t = this.k;
-        if (t !== activeTransition) {
-            // Adopt the ambient batch into the transaction, then make the
-            // transaction the batch so later registrations land there directly.
-            // Pending and optimistic nodes are re-stamped as the transaction's;
-            // marks don't hijack the node's _transition — a mark on a plain signal
-            // must not entangle unrelated writes to it; the same rule holds one hop
-            // downstream: propagation never queues pended subscribers as pending
-            // nodes, see propagateAffectsMark, #2893.
-            for (let e = 0; e < t.yt.length; e++) {
-                const i = t.yt[e];
-                i._e = activeTransition;
-                activeTransition.yt.push(i);
-            }
-            for (let e = 0; e < t.Ke.length; e++) {
-                const i = t.Ke[e];
-                i._e = activeTransition;
-                activeTransition.Ke.push(i);
+        this.un = [ [], [] ];
+        for (let e = transactions.length - 1; e >= 0; e--) {
+            const o = transactions[e];
+            if (blocked(o)) continue;
+            transactions.splice(e, 1);
+            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.
+                        e = transactions.length;
+        }
+        // The store folds the pending backings whose container nodes committed
+        // — this flush's, or a landing's (store/store.ts installs it).
+                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).
+                const t = o && liveTx(o);
+        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
+        // re-derived at the landing before a boundary swap held since the
+        // 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 s = t !== null;
+        for (let e = 0; e < 2; e++) {
+            if (s) append(t.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 || l[e].length || this.un[e].length ? l[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, o) => e.he - o.he);
+            for (let o = 0; o < e.length; o++) {
+                if (!(e[o].R & REACTIVE_DISPOSED)) recompute(e[o]);
             }
-            if (t.m.length) activeTransition.m.push(...t.m);
-            for (const e of t.cn) activeTransition.cn.add(e);
-            // Gated readers recorded against the ambient batch move with it: their
-            // replay-at-commit now happens at the transaction's completion.
-                        if (t.ln.size) {
-                for (const e of t.ln) activeTransition.ln.add(e);
-                t.ln.clear();
+        }
+        // Boundaries: readers that settled, landed or died this flush are
+        // dropped; a fallback with none left reveals next round.
+                boundarySeamHook?.();
+    }
+    run(e) {
+        const o = this.un[e - 1];
+        if (o.length) {
+            this.un[e - 1] = [];
+            runQueue(o, e);
+        }
+    }
+    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) (n !== null ? n : this).un[e - 1].push(o);
+        schedule();
+    }
+    /** Status reaching the root: pending is absorbed (the root mount defers —
+     * dev records it for the ASYNC_OUTSIDE_LOADING_BOUNDARY FYI); an error is
+     * unhandled (`false` → the caller halts).
+     *
+     * L2: this is where a transaction is registered. Pending that reaches an
+     * observer (a render effect: the frame) is a frame that cannot show — the
+     * flush parks, and the transaction waits on the flight while a frame
+     * derives from it (`blocked`). Pending nobody observes holds nothing: a
+     * memo in flight that no frame reads is not a frame waiting. (Base: the
+     * queue's `_asyncReporters`, INV-3's one registration site.)
+     *
+     * 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, o, n, l) {
+        if (catchHook?.(e, n & o, l)) 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
+                // it; one whose inputs are held is a stale reader and never gets
+                // here — `read` serves it the committed value). The frame's, not the
+                // observer's: a render effect belongs to whoever dirtied its pass
+                // (A15 shared-hole, #3407) — one held by T1 and re-run by T2's write
+                // pends for T2's flight, and the two stay parallel; a frame that is
+                // T1's already joined T1 through the write or the memo that made it
+                // so. Outside a flush — root setup, a mount — the frame is the
+                // mount's: its pending observers are one transaction, and a flight
+                // started in it resumes it when it lands (maintainer, #3461: "part
+                // of the same one"); what the mount published synchronously stays
+                // published. Lane work going pending holds the lane, not the frame:
+                // `blocked(lane)` finds it in the lane's staging ("if further async
+                // downstream is hit it holds like its own transition").
+                if (passLane === null) joinFuture(null);
             }
-            currentBatch = this.k = activeTransition;
+            return true;
         }
-        for (const e of activeLanes) {
-            if (!e._e) e._e = activeTransition;
+        return false;
+    }
+}
+
+/** A15's stale readers: a frame whose LAST pass read a held node as
+ * committed re-derives on the landed world — next round, after the commits.
+ * One re-derived since (any later pass cleared the bit: in the transaction,
+ * 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. Truthy when an effect re-derives (`land`). */ function reruns(e) {
+    let o;
+    for (let n = 0; n < e.En.length; n++) {
+        const l = 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) — unless that source is errored no longer: the
+        // reader was served a shown error the landing replaces (`throwShown`).
+        // Nor is the reader's own error: its pass threw over the committed value
+        // of what the landing carries, served as the screen (A10; a lane's node
+        // reading its parent's hold, or a pass with no value yet reading a
+        // staging, `stagedScreen`) — the landing is the new answer, and the
+        // reader re-derives on it (A15; D-39). A first load read so has no other
+        // run: its error would stay the screen (async-gen 91501 #1158, #119).
+        // A boundary's structure (its tree, its output: CONFIG_FRAME, no effect
+        // type) re-derives all the same: what it read as the screen is the
+        // content the landing replaces, and only its pass links the new content
+        // whose recovery must reach it (D-3, D-39, #4405).
+                const t = l.T?.U?.source;
+        if (l.R & REACTIVE_DISPOSED || l.m & STATUS_ERROR && (l.i || !(l.l & CONFIG_FRAME)) && t !== l && (t?.m ?? STATUS_ERROR) & STATUS_ERROR) continue;
+        if (l.R & REACTIVE_FRAME_READ || observeFlightHook && l.l & CONFIG_VERDICT) {
+            // A memo re-deriving its own error holds the release as an effect
+            // does (`land`): run first, the held runs showed that error beside a
+            // frame about to replace it (#4407; #4284: the grouping never changes
+            // the screen).
+            o ||= l.i || t === l;
+            // A lane's reveal leaves the mark to the transaction: a reader that
+            // also read a held node as committed (`staleReader`) still observes
+            // that flight until it re-runs — cleared here, the transaction landed
+            // at this seam with the flight up and voided the reveal's run (#4397).
+                        if (!e.P) l.R &= ~REACTIVE_FRAME_READ;
+            l.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 = l.pe; e !== null; e = e.Ge) if (e.i) e.Ae = false;
+            // A frame flight the seam parked (lanes.ts `laneSeams`, R5) asked the
+            // question this landing would: adopted, it is asked once (F-9).
+                        if (!laneAdoptHook?.(l)) enqueueSub(l);
         }
     }
+    e.En.length = 0;
+    return o;
 }
 
-function queuePendingNode(e) {
-    currentBatch.yt.push(e);
+/** The landing: the held frame becomes the frame. */ function land(e) {
+    const o = reruns(e);
+    if (releaseMarksHook && 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 o = 0; o < e.tn.length; o++) {
+        const n = e.tn[o];
+        if (n.T.Re === null || txOf(n) !== e) continue;
+        n.T.Re = 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;
+    // 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 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, o) {
+    for (let n = 0; n < o.length; n++) e.push(o[n]);
 }
 
-// Sticky: flips true on the first refresh() ever (the only setter of
-// REACTIVE_REASK) so the hot notification loop skips the per-subscriber flag
-// clear entirely in apps that never refresh.
-let reaskArmed = false;
+/** Nodes staged this flush (`_pendingValue` set), committed at its end. */ const pendingNodes = [];
+
+/** Passes that read a staging of this flush as the screen — lane work
+ * (core.ts `stagedRead`), a verdict reader before the frame's verdict
+ * (verdict.ts): if the frame parks they read a held write — re-derived next
+ * round (lanes.ts; a lane's runs wait that round). */ const stagedReaders = [];
+
+/** 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, o) {
+    if (!(e.R & REACTIVE_FRAME_READ)) {
+        e.R |= REACTIVE_FRAME_READ;
+        o.En.push(e);
+    }
+}
+
+function queuePendingNode(e) {
+    pendingNodes.push(e);
+    if (!globalQueue.Y) markUnflushedStaged();
+ // A28
+}
 
 /** §12d: bumped by every recompute and every new subscriber edge. A node's
  * staged-rewrite skip is sound only while NOTHING recomputed or linked since
@@ -536,29 +940,17 @@ function bumpNotifyEpoch() {
     notifyEpoch++;
 }
 
-function armReaskClear() {
-    reaskArmed = true;
-}
-
-function insertSubs(e, t = false) {
+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._t = notifyEpoch;
-    // Get source lane: prefer node's own lane over current context
-    // This is important for isPending signals which need their own lane to flush immediately
+    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. Bits are sticky — the field read
-    // stays authoritative when a bit is set.
-        const i = e.T;
-    const n = (i & CONFIG_HAS_LANE ? e.o?.Be : undefined) || currentOptimisticLane;
-    const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.Qe !== undefined;
-    const o = reaskArmed;
-    for (let i = e.u; i !== null; i = i.fe) {
-        const e = i.ae;
-        // A value-change notification is a new question for the subscriber: any
-        // pending re-ask mark (refresh) it carried is superseded.
-                if (o) e.ie &= ~REACTIVE_REASK;
+    // lookups in the hottest notify loop.
+        const o = e.l;
+    const n = (o & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.De !== undefined;
+    for (let o = e.o; o !== null; o = o.t) {
+        const e = o.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
@@ -567,159 +959,126 @@ function insertSubs(e, t = false) {
         // 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.ie & REACTIVE_RECOMPUTING_DEPS && i.ll === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
-        if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-            e.ie |= REACTIVE_SNAPSHOT_STALE;
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.Ne === e.de && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
+        if (n && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
+            e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
-        if (t && n) {
-            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(e, n);
-        } else if (t) {
-            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        if (e.o) e.o.Be = undefined;
-        }
         enqueueSub(e);
     }
 }
 
+/** Lane work re-staged (lanes.ts; `recompute`): the lane's members among
+ * its subscribers re-derive as the lane's work (REACTIVE_LANE_DIRTY), their
+ * runs held with it — not as stale readers republishing the committed view
+ * (#3460). After `insertSubs`. A render effect on no lane is marked too:
+ * 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`).
+ *
+ * A render effect re-run by a verdict memo's change (`createMemo(() =>
+ * latest(x))`, CONFIG_VERDICT) is the verdict reader the same read inline
+ * makes it, for that pass (F-6; D-26 `[s(), L()]`, #4284): a frame reader
+ * of its other reads — a staging's screen, a flight's committed value. One
+ * an earlier propagation this flush seated in another lane leaves that
+ * seat: its pass starts from the frame's, as the inline effect's does, and
+ * `laneRead` re-derives it on the screen if that lane holds (`entered`). */ function laneDirty(e, o) {
+    for (let n = e.o; n !== null; n = n.t) {
+        const l = n.u, t = l.T?.Re;
+        if (l.i === EFFECT_RENDER && e.l & CONFIG_VERDICT) l.l |= CONFIG_VERDICT, l.R &= ~REACTIVE_LANE_DIRTY;
+        if (t?.P ? sameLane(t, o) : l.i) l.R |= REACTIVE_LANE_DIRTY;
+    }
+}
+
+/** One lane, or two of one link group (#3335): one reveal unit. */ function sameLane(e, o) {
+    return e === o || e.en !== null && e.en === o.en;
+}
+
 function commitPendingNode(e) {
-    const t = e;
-    if (!t.Se) {
-        if (e.Pe !== NOT_PENDING) {
-            e.be = e.Pe;
-            e.Pe = NOT_PENDING;
+    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 (!o.X) {
+        e.l &= -385;
+        if (e.ue !== NOT_PENDING) {
+            e.le = e.ue;
+            e.ue = NOT_PENDING;
         }
-        if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
         return;
     }
-    if (e.Pe !== NOT_PENDING) {
-        e.be = e.Pe;
-        e.Pe = NOT_PENDING;
-        // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Re && e.Re !== EFFECT_TRACKED) e.Xe = true;
+    // 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 n = e.ue === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
+    const l = e.l & CONFIG_STAGED_ERROR;
+    // An answer commits: the error it replaces leaves the display (D-41).
+        if (!n && o.T) o.T.Te = null;
+    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 (l) {
+        const n = e.ue;
+        e.ue = NOT_PENDING;
+        e.ie = clock + 1;
+        notifyStatus(o, STATUS_ERROR, n);
+    } else if (e.ue !== NOT_PENDING) {
+        e.le = e.ue;
+        e.ue = NOT_PENDING;
+        // A node born staged (recompute) initializes at this commit.
+                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 (o.T != null) o.T.Ve = false, o.T.je = 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.Ae = true;
+            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.q.bind(null, o));
+        }
     }
-    // The committed hold is the first observable answer for a loading-window
+    // 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.
-        t.Ie = false;
-    t.ie &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.o != null && (t.o.qe !== null || t.o.We !== null)) GlobalQueue.Fe(t, false, true);
-    if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
-}
-
-// Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
-// module at init (same treeshakeable pattern as _resolveOptimistic /
-// _clearOptimisticStores). Folds committed store-node values into their
-// backing objects at the same moment pending values commit — the single
-// mutation point of the owned-raw model.
-let storeCommitHook = null;
-
-function setStoreCommitHook(e) {
-    storeCommitHook = e;
+        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 (o.T?.U == 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 (!n && o.T != null && (o.T.me !== null || o.T.Le !== null)) GlobalQueue.Ce(o, false, true);
 }
 
 function commitPendingNodes() {
-    const e = currentBatch.yt;
-    for (let t = 0; t < e.length; t++) {
-        commitPendingNode(e[t]);
-    }
-    e.length = 0;
-    storeCommitHook?.();
-}
-
-function finalizePureQueue(e = null, t = false) {
-    // For incomplete transitions, skip pending resolution and optimistic reversion
-    // For completing transitions or no-transition, resolve pending and revert optimistic
-    const i = !t;
-    if (i) commitPendingNodes();
-    if (!t && globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.xe;
-    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
-    if (i) {
-        if (n) commitPendingNodes();
-        // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.k;
-        // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
-        // which installed the engine's hooks.
-                if (t.Ke.length) GlobalQueue.fn(t.Ke);
-        // Replay entanglement: subs recorded by the read-time gate get rescheduled
-        // so they re-run with the now-committed values visible. The ambient batch
-        // replays too — laneReadsCommitted records readers whose committed-view
-        // read hid a same-tick plain write that just committed above (#2963).
-                if (t.ln.size) {
-            for (const e of t.ln) {
-                if (e.ie & REACTIVE_DISPOSED) continue;
-                enqueueSub(e);
-            }
-            t.ln.clear();
-            // A completing transition keeps the outer flush loop alive by itself;
-            // the ambient batch needs the re-arm or the replay sits in the heap
-            // until the next unrelated write.
-                        schedule();
-        }
-        // Declared motion ends with the transaction: settle (or plain flush end
-        // for ambient marks) releases each registration's refcount. A non-empty
-        // batch means registerAffectsMark ran, which installed the hook. Marks
-        // held boundary display state through the visual channel, and their
-        // release is the display-state update point — re-run the boundary sweep
-        // (the earlier sweep above ran while the marks were still live).
-                if (t.m.length) {
-            GlobalQueue.M(t.m);
-            if (globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
-        }
-        // A non-empty set means trackOptimisticStore ran, which installed the
-        // hook; the hook iterates, clears, and schedules (keeping the loop out of
-        // core lets esbuild shake it — rollup already folds the null guard). The
-        // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.Vt(t.cn, e);
-        sweepTransientStoreNodes();
-        // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.En(e);
-    }
-}
-
-function checkBoundaryChildren(e) {
-    for (const t of e.Qt) {
-        t.se?.();
-        checkBoundaryChildren(t);
-    }
-}
-
-/**
- * Count of live `affects()` registrations across the system (including
- * store-scope inherited marks). Gates the read-path mark check in `read()` so
- * graphs that never use the feature pay one integer compare.
- */ let activeAffectsMarks = 0;
-
-/**
- * Counter mutation seam for the mark engine in affects.ts: an imported `let`
- * binding is read-only, and the read-path gate above must stay a plain module
- * variable so `read()` pays one integer compare, not a function call.
- *
- * @internal
- */ function shiftAffectsMarks(e) {
-    activeAffectsMarks += e;
-}
-
-function reassignPendingTransition(e) {
-    for (let t = 0; t < e.length; t++) {
-        e[t]._e = activeTransition;
+    for (let e = 0; e < pendingNodes.length; 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 (!(o.l & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(o);
     }
+    pendingNodes.length = 0;
 }
 
 const globalQueue = new GlobalQueue;
 
-// Hot-path mirror of `globalQueue._batch`: `queuePendingNode` runs once per
-// staged write and `commitPendingNodes` once per flush, and the extra
-// property hop through `_batch` was a measured instruction-count regression
-// (CodSpeed update1to1, PR #2905). The field stays authoritative for
-// cross-module readers; every `_batch` assignment updates both.
-let currentBatch = globalQueue.k;
-
 function flush(e) {
+    if (actionDepth > 0) {
+        return e ? e() : undefined;
+    }
     if (e) {
         syncDepth++;
         try {
@@ -734,73 +1093,20 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.sn) {
+    if (globalQueue.Y) {
         return;
     }
     if (halted) return;
-    // `flush()` is an explicit drain point, so it must also process an active
-    // transition even if no microtask was scheduled for it yet.
-        while (scheduled || activeTransition) {
+    while (scheduled) {
         globalQueue.flush();
     }
+    // A cleanup that threw during the drain, now that the drain is complete
+    // (owner.ts).
+        rethrowCleanupError();
 }
 
-function runQueue(e, t) {
-    for (let i = 0; i < e.length; i++) e[i](t);
-}
-
-function reporterBlocksSource(e, t) {
-    if (e.ie & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.o?.le?.has(t)) return true;
-    for (let i = e.nt; i; i = i.it) {
-        let e = i.ut;
-        while (e) {
-            if (e === t || e.lt === t) return true;
-            e = e.o?.It;
-        }
-    }
-    return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
-}
-
-function transitionComplete(e) {
-    if (e.an) return true;
-    if (e.oe.length) return false;
-    let t = true;
-    for (const [i, n] of e.Ne) {
-        let s = false;
-        for (const e of n) {
-            if (reporterBlocksSource(e, i)) {
-                s = true;
-                break;
-            }
-            n.delete(e);
-        }
-        if (!s) e.Ne.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
-            t = false;
-            break;
-        }
-    }
-    // Override blockage lives with the engine (absent hook = "no optimistic
-    // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
-    // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.dn?.(e)) t = false;
-    t && (e.an = true);
-    return t;
-}
-
-function currentTransition(e) {
-    while (e.an && typeof e.an === "object") e = e.an;
-    return e;
-}
-
-function runInTransition(e, t) {
-    const i = activeTransition;
-    try {
-        activeTransition = currentTransition(e);
-        return t();
-    } finally {
-        activeTransition = i;
-    }
+function runQueue(e, o) {
+    for (let n = 0; n < e.length; n++) e[n](o);
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, notifyEpoch, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, armGuessing, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, guessing, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, holdWorkHook, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneAdoptHook, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneServedHook, laneStageHook, laneWriteHook, lanesBlockedHook, latestOpened, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, pendingNodes, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };