@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/observe/core/scheduler.js

@@ -0,0 +1,1190 @@
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, CONFIG_HELD_TRUTH, REACTIVE_ZOMBIE, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_INPUTS_PUBLISHED, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED, CONFIG_AUTHORITATIVE_READ } from "./constants.js";
+
+import { attrHooks } from "./attribution-hooks.js";
+
+import { currentOptimisticLane, slotUnobservedHook } from "./core.js";
+
+import { DEV, GRAPH_SIZE_WARN_AT, noteFanOut } from "./dev.js";
+
+import { NotReadyError } from "./error.js";
+
+import { sweepDormant } from "./graph.js";
+
+import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
+
+import { activeLanes, assignOrMergeLane, findLane, hasActiveOverride } from "./lanes.js";
+
+export { getOrCreateLane, mergeLanes, resolveLane } from "./lanes.js";
+
+import { devCheckFlushStart, devCheckActiveOverrides, devCensusCompanions, devCheckQuiescent } from "./invariants.js";
+
+const transitions = new Set;
+
+const dirtyQueue = {
+    eE: new Array(2e3).fill(undefined),
+    tE: false,
+    St: 0,
+    EE: 0
+};
+
+const zombieQueue = {
+    eE: new Array(2e3).fill(undefined),
+    tE: false,
+    St: 0,
+    EE: 0
+};
+
+/** 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.it & REACTIVE_IN_HEAP_HEIGHT) e.it &= -12; else {
+        deleteFromHeap(e, zombieQueue);
+        e.it &= -4;
+    }
+}
+
+let clock = 0;
+
+let activeTransition = null;
+
+let scheduled = false;
+
+let halted = false;
+
+let haltNotified = false;
+
+let syncDepth = 0;
+
+let projectionWriteActive = false;
+
+/** > 0 while an action's generator body is on the stack (the synchronous
+ * slice between yields). Maintained by action.ts around `it.next()`. */ let actionStepDepth = 0;
+
+function enterActionStep() {
+    actionStepDepth++;
+}
+
+function exitActionStep() {
+    actionStepDepth--;
+}
+
+// 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;
+
+function canUseSimpleSyncFlush(e) {
+    const t = e.m;
+    return transitions.size === 0 && activeLanes.size === 0 && e.ei.length === 0 && t.en.length === 0 && t.A.length === 0 && t.nn.size === 0 && transientStoreNodes.size === 0;
+}
+
+function sweepTransientStoreNodes() {
+    if (transientStoreNodes.size === 0) return;
+    for (const e of transientStoreNodes) {
+        if (e.u !== null) {
+            transientStoreNodes.delete(e);
+            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);
+        if (e.T & CONFIG_SLOT_NODE) slotUnobservedHook(e); else e.o?.qt?.();
+    }
+}
+
+/**
+ * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
+ * window. Only `render()` calls this — wrapping the initial mount so that a
+ * top-level uncaught async read surfaces the diagnostic. Not part of the
+ * user-facing API.
+ *
+ * @internal
+ */ function enforceLoadingBoundary(e) {}
+
+function setProjectionWriteActive(e) {
+    projectionWriteActive = e;
+}
+
+/**
+ * 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 {
+        ae: clock,
+        tn: [],
+        Ie: new Map,
+        en: [],
+        A: [],
+        nn: new Set,
+        ut: [],
+        ti: {
+            ii: [ [], [] ],
+            ei: []
+        },
+        Ut: false,
+        ht: new Set,
+        xt: null
+    };
+}
+
+function mergeTransitionState(e, t) {
+    if (attrHooks !== null) attrHooks.transitionMerged(e, t);
+    t.Ut = e;
+    e.ut.push(...t.ut);
+    for (const i of activeLanes) if (i.Ee === t) i.Ee = e;
+    if (t.en.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.en.push(...t.en);
+        t.en.length = 0;
+    }
+    if (t.A.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.A.push(...t.A);
+        t.A.length = 0;
+    }
+    for (const i of t.nn) e.nn.add(i);
+    for (const [i, n] of t.Ie) {
+        let t = e.Ie.get(i);
+        if (!t) e.Ie.set(i, t = new Set);
+        for (const e of n) t.add(e);
+    }
+    for (const i of t.ht) e.ht.add(i);
+    if (t.xt) (e.xt ??= []).push(...t.xt);
+}
+
+/**
+ * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
+ * relatedness — the predicate names the condition that confirms the awaiting
+ * transaction. When the predicate settles truthy, every live foreign
+ * transition whose staged write it read IS the confirming event by the
+ * user's own definition, so it merges into the awaiting transaction and
+ * reveals at the joint settle — the cross-primitive twin of the family fold
+ * (a landing on an optimism-carrying family joins the retaining
+ * transaction). Non-flipping updates never pass through here: falsy
+ * evaluations don't entangle, so unrelated traffic on the watched sources
+ * reveals freely on its own schedule.
+ *
+ * Runs inside the predicate's compute (pure phase) — the confirming
+ * transition's stamps are still live and its commit decision hasn't run, so
+ * the merge lands before any reveal. Only the tree-shaken graphs that call
+ * `until()` retain this.
+ */ function entangleConfirmingTransitions(e, t) {
+    t = currentTransition(t);
+    if (t.Ut === true) return;
+    // The confirming evidence is a dep whose value is STAGED (pending,
+    // uncommitted) at flip evaluation — committed deps are public already and
+    // carry nothing to entangle. A staged dep lives in one of two carriers: a
+    // stamped transition, or the queue's current batch (ambient registrations
+    // don't stamp; "ambient work IS a transaction" — the batch is the
+    // carrier). The entangle STEALS the carrier's staged cargo — its pending
+    // nodes move (re-stamped) into the awaiting transaction and reveal at its
+    // settle — but never the carrier itself: its async reporters, actions,
+    // and stashes are its own future (a live stream's flight must not chain
+    // the awaiting transaction to landings that haven't happened; a merged
+    // reporter deadlocked exactly that way).
+        let i = false;
+    for (let n = e.te; n !== null; n = n.ne) {
+        const r = n.oe;
+        if (r.Pe !== NOT_PENDING) {
+            const e = r.Ee;
+            const n = e != null ? currentTransition(e) : null;
+            // Skip the awaiting transaction's own cargo (t === target: a
+            // fold-staged landing or a write the action itself issued — hold and
+            // reveal already correct) and dead carriers. Ambient-batch staging
+            // (t === null) must leave the batch NOW — it commits at this flush's
+            // end, which would reveal the confirmation under the live optimism
+            // it just confirmed.
+                        const o = n === null ? currentBatch.tn : n !== t && n.Ut !== true ? n.tn : null;
+            if (o !== null) i = stealEntangledCargo(o, t) || i;
+        }
+        if (n === e.Dt) break;
+    }
+    // The steal never activates the awaiting transaction: the predicate can
+    // flip inside another transaction's finalize heap, and adopting the queue
+    // batch there hands the stolen cargo to that finalize's commit sweep — a
+    // premature reveal at a foreign settle. Subscribers that computed against
+    // the pre-steal world were re-dirtied by the steal itself, so this
+    // flush's applies paint the masked (mid-hold) view; the cargo commits at
+    // the awaiting transaction's own settle.
+}
+
+/** Move a confirming carrier's staged nodes into the awaiting transaction:
+ * re-stamp and arm the held-truth mask (override-covered nodes skip it —
+ * the override already hides their staged value per A17, and is usually
+ * the very optimism this confirmation settles); the mask's commit
+ * registers the settle-side post-revert wake. The carrier's array is
+ * emptied so its own commit point commits none of the stolen cargo.
+ *
+ * EFFECT subs of stolen nodes re-run: any that recomputed against the
+ * staging BEFORE the steal (the carrier's landing notified them as a plain
+ * write) hold a private torn result — override composed with confirming
+ * truth — that the next paint gate (stash-point lane run, a foreign
+ * flush's completion drain) would show. Re-running them under the mask
+ * re-derives the mid-hold view in this same heap pass. PURE computeds are
+ * deliberately NOT re-run: a torn staged value of theirs is itself stolen
+ * cargo — masked at read, so ordinary readers already serve their
+ * committed value — while re-running them would re-derive the OLD world
+ * and re-stage it over the held truth. The reveal re-notifies
+ * (commitPendingNodes), which is when they re-derive for real. */ function stealEntangledCargo(e, t) {
+    if (e === t.tn || e.length === 0) return false;
+    for (let i = 0; i < e.length; i++) {
+        const n = e[i];
+        n.Ee = t;
+        t.tn.push(n);
+        // Override-covered nodes stay silent AND unmasked: the override is the
+        // display (A17 — its staging never notified, its revert will), so their
+        // subs saw nothing and re-running one would break the silence with a
+        // duplicate fire of an unchanged view.
+                if (!hasActiveOverride(n)) {
+            n.T |= CONFIG_HELD_TRUTH;
+            for (let e = n.u; e !== null; e = e.se) {
+                const t = e.le;
+                if (t.Re && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+            }
+        }
+    }
+    e.length = 0;
+    transitions.add(t);
+    return true;
+}
+
+function schedule() {
+    if (halted) {
+        notifyHalted();
+        return;
+    }
+    if (scheduled) return;
+    scheduled = true;
+    if (!syncDepth && !globalQueue.Qn && !projectionWriteActive) 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) {
+    if (halted) return;
+    halted = true;
+    let t = "[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.
+    // 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 i = e !== undefined && globalThis.reportError;
+    i || e === undefined ? console.error(t) : console.error(t, e);
+    i && i(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]");
+}
+
+/** @internal Test/dev-reload hook. Revives scheduling after a halt. */ function resetErrorHalt() {
+    halted = false;
+    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 {
+    Nt=null;
+    ii=[ [], [] ];
+    ei=[];
+    ni=0;
+    created=clock;
+    addChild(e) {
+        this.ei.push(e);
+        e.Nt = this;
+    }
+    removeChild(e) {
+        const t = this.ei.indexOf(e);
+        if (t >= 0) {
+            this.ei.splice(t, 1);
+            e.Nt = null;
+        }
+    }
+    notify(e, t, i, n) {
+        if (this.Nt) return this.Nt.notify(e, t, i, n);
+        return false;
+    }
+    run(e) {
+        if (this.ii[e - 1].length) {
+            const t = this.ii[e - 1];
+            this.ii[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.ei;
+        const i = ++queueRunToken;
+        for (let n = 0; n < t.length; ) {
+            const r = t[n];
+            if (r.ni !== i) {
+                r.ni = i;
+                r.run?.(e);
+                if (t[n] !== r) {
+                    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.vn[e - 1].push(t);
+            } else {
+                this.ii[e - 1].push(t);
+            }
+        }
+        schedule();
+    }
+    stashQueues(e) {
+        // Attribution hook: the parking transition's lane effects have run; its
+        // queues are being stashed. Root call only (children recurse below).
+        if (attrHooks !== null && this === globalQueue) attrHooks.holdEnd();
+        e.ii[0].push(...this.ii[0]);
+        e.ii[1].push(...this.ii[1]);
+        this.ii = [ [], [] ];
+        for (let t = 0; t < this.ei.length; t++) {
+            let i = this.ei[t];
+            let n = e.ei[t];
+            if (!n) {
+                n = {
+                    ii: [ [], [] ],
+                    ei: []
+                };
+                e.ei[t] = n;
+            }
+            i.stashQueues(n);
+        }
+    }
+    restoreQueues(e) {
+        this.ii[0].push(...e.ii[0]);
+        this.ii[1].push(...e.ii[1]);
+        for (let t = 0; t < e.ei.length; t++) {
+            const i = e.ei[t];
+            let n = this.ei[t];
+            if (n) n.restoreQueues(i);
+        }
+    }
+}
+
+class GlobalQueue extends Queue {
+    Qn=false;
+    // The current transaction-shaped batch: a plain ambient batch while no
+    // transition is active, the active transition itself after initTransition.
+    m=createBatch();
+    static lt;
+    static Et;
+    static bt;
+    static ri=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 p=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 G=null;
+    static M=null;
+    static N=null;
+    // External-source bridge (wired by enableExternalSource(); null while no
+    // config is active — including after _resetExternalSourceConfig()).
+    static un=null;
+    static cn=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 Ae=null;
+    static fe=null;
+    static Ge=null;
+    static Dn=null;
+    static In=null;
+    static Nn=null;
+    static Cn=null;
+    static gt=null;
+    static k=null;
+    static oi=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 si=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 pn=null;
+    static Un=null;
+    static Pn=null;
+    static Fn=null;
+    static Vn=null;
+    /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
+     * apply at lane-effect timing — visible in flight, unlike the regular
+     * effect queues an action stashes. Injected; null when unused. */
+    static bn=null;
+    static An=null;
+    static dn=null;
+    /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
+     * carve-out asks before showing a foreign-held pending node's committed
+     * value: a lane-derived flight's inputs are already revealed through the
+     * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
+    static Tn=null;
+    static On=null;
+    static Ft=null;
+    static vt=null;
+    /** Authoritative-view reader wakeup: installed by until() and refresh() before
+     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
+     * only such a reader's carve-out read can set, so `!` invocations are safe once
+     * the gate holds (#3303). */
+    static En=null;
+    static Ht=null;
+    /** A18 supersession (#3331): own-source truth `value` landed under an active
+     * override. The engine decides whether the graph re-derives — the value
+     * differs from the override and is not a stale (older-action) answer (mark
+     * the node, demote its lane cascade, notify), or returns to it after an
+     * earlier differing arrival (clear the mark, notify) — and owns the
+     * authoritative-observer wake for a silent confirm. Installed with the
+     * optimistic engine; only reachable on a node that has an override. */
+    static Oe=null;
+    /** read()'s value for a TRACKED reader of a superseded node (#3331): the
+     * staged truth, unless the reader is a stale (render) reader of another
+     * transaction — then the displayed override, as it keeps a foreign
+     * transaction's committed value over its staged write. */
+    static Sn=null;
+    /** setSignal's authoritative (projection-write) landing on an override-
+     * covered node (#3331 store twin): stage the truth for its transaction's
+     * commit whatever its relation to the committed value — a landing equal to
+     * committed still differs from the override — then _supersedeOverride
+     * decides. Installed with the optimistic engine; only reachable on a node
+     * that has an override. */
+    static Rn=null;
+    static Hn=null;
+    flush() {
+        if (this.Qn) 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.St && this.ii[0].length === 0 && this.ii[1].length === 0 && this.ei.length === 0 && canUseSimpleSyncFlush(this)) {
+            this.Qn = true;
+            try {
+                // Sweep first: unobserved() pulls swept nodes out of the dirty heap,
+                // so a dormant memo dirtied in the same tick is reclaimed instead of
+                // recomputed (matching the old inline dispose-on-read counts).
+                sweepDormant();
+                commitPendingNodes();
+            } finally {
+                this.Qn = false;
+            }
+            clock++;
+            scheduled = dirtyQueue.EE >= dirtyQueue.St || this.ii[0].length !== 0 || this.ii[1].length !== 0 || this.m.tn.length !== 0;
+            return;
+        }
+        this.Qn = true;
+        try {
+            if (false) ;
+            // Before runHeap for the same reason as the fast drain above; late
+            // subscribers (an effect reading a swept memo this flush) revive it,
+            // which is the pay-for-use contract.
+                        sweepDormant();
+            runHeap(dirtyQueue, GlobalQueue.lt);
+            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.m === e ? cancelZombieRecompute : GlobalQueue.lt);
+                    // 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.m === e) currentBatch = this.m = createBatch();
+                    // Run lane effects immediately (before stashing) - lanes with no pending async
+                                        if (activeLanes.size) {
+                        GlobalQueue.Vn(EFFECT_RENDER);
+                        GlobalQueue.Vn(EFFECT_USER);
+                    }
+                    this.stashQueues(e.ti);
+                    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.St || this.m.tn.length > 0;
+                    reassignPendingTransition(e.tn);
+                    activeTransition = null;
+                    finalizePureQueue(null, true);
+                    return;
+                }
+                const t = activeTransition;
+                const i = this.m;
+                i !== t && i.tn.push(...t.tn);
+                this.restoreQueues(t.ti);
+                transitions.delete(t);
+                activeTransition = null;
+                reassignPendingTransition(i.tn);
+                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.tn = i.tn;
+                    e.en = i.en;
+                    e.A = i.A;
+                    e.nn = i.nn;
+                    currentBatch = this.m = e;
+                }
+            } else {
+                if (canUseSimpleSyncFlush(this)) {
+                    commitPendingNodes();
+                    if (dirtyQueue.EE >= dirtyQueue.St) {
+                        runHeap(dirtyQueue, GlobalQueue.lt);
+                        commitPendingNodes();
+                    }
+                } else {
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.lt);
+                    finalizePureQueue();
+                }
+            }
+            clock++;
+            // Check if finalization added items to the heap (from optimistic reversion).
+            // Finalization may also have ENTERED a transaction (a commit hook, boundary
+            // sweep or recompute wrote a node it owns): effects computed under it
+            // since are its to apply, not this flush's — runEffect leaves them queued
+            // and the next pass parks them with it (#3319). Everything computed
+            // mainline applies now.
+                        scheduled = dirtyQueue.EE >= dirtyQueue.St || activeTransition !== null;
+            // Run lane effects first (for ready lanes), then regular effects
+                        activeLanes.size && GlobalQueue.Vn(EFFECT_RENDER);
+            this.run(EFFECT_RENDER);
+            activeLanes.size && GlobalQueue.Vn(EFFECT_USER);
+            this.run(EFFECT_USER);
+            if (false) ;
+            if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
+            if (false) ;
+        } finally {
+            this.Qn = false;
+        }
+    }
+    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) {
+                // Callers pass either nothing or this node's own `_x._error`, so `??`
+                // is exact (a null error falls back to the same null).
+                const t = 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?.l) return true;
+                if (t) {
+                    // A reveal can discover a flight started in an earlier flush. Hold
+                    // the staged writes with that reader (A15), even if the reader is
+                    // new. Fresh/reset loading boundaries consume pending before it
+                    // reaches here. A reader already parked in a transition must not
+                    // open a second one.
+                    if (!activeTransition && !e.Ee && currentBatch.tn.length) this.initTransition();
+                    if (activeTransition) {
+                        const i = t.source;
+                        let n = activeTransition.Ie.get(i);
+                        if (!n) activeTransition.Ie.set(i, n = new Set);
+                        const r = n.size;
+                        n.add(e);
+                        if (n.size !== r) {
+                            schedule();
+                            GlobalQueue.si?.(activeTransition);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    initTransition(e) {
+        if (e) {
+            e = currentTransition(e);
+            // A finished transaction cannot be re-entered: its state is committed
+            // or reverted, so "rejoining" it (A26) is meaningless and re-activating
+            // it spins the drain loop (#3140). The refusal must be a bare return —
+            // redirecting the caller to a fresh batch would re-arm the loop with a
+            // new transaction identity each pass. Stamps are cleared at commit, so
+            // this is a belt for paths that hand over a chased-dead reference
+            // (merged chains, async settles racing completion).
+                        if (e.Ut === true || e === activeTransition) return;
+        }
+        if (!e && activeTransition && activeTransition.ae === clock) return;
+        if (!activeTransition) {
+            activeTransition = e ?? createBatch();
+        } else if (e) {
+            const t = activeTransition;
+            mergeTransitionState(e, t);
+            // Effects the outgoing transaction parked belong to the surviving one
+            // now: back onto the live queue, where this flush parks them under
+            // `transition` or runs them at its completion. The outgoing stash is
+            // never read again — the transaction is dead (#3310).
+                        this.restoreQueues(t.ti);
+            transitions.delete(t);
+            activeTransition = e;
+        }
+        transitions.add(activeTransition);
+        activeTransition.ae = clock;
+        const t = this.m;
+        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.tn.length; e++) {
+                const i = t.tn[e];
+                i.Ee = activeTransition;
+                activeTransition.tn.push(i);
+            }
+            for (let e = 0; e < t.en.length; e++) {
+                const i = t.en[e];
+                i.Ee = activeTransition;
+                activeTransition.en.push(i);
+            }
+            if (t.A.length) activeTransition.A.push(...t.A);
+            for (const e of t.nn) activeTransition.nn.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.ht.size) {
+                for (const e of t.ht) activeTransition.ht.add(e);
+                t.ht.clear();
+            }
+            currentBatch = this.m = activeTransition;
+        }
+        for (const e of activeLanes) {
+            if (!e.Ee) e.Ee = activeTransition;
+        }
+        // A transaction's ambient window is one flush. Entering must therefore
+        // guarantee a flush: a transaction opened with no writes (an action whose
+        // first statements only await) otherwise leaves activeTransition and the
+        // adopted batch armed across the async gap, and the next unrelated work
+        // to arrive — an optimistic store's authoritative landing, a plain async
+        // settle — is adopted into a transaction it has nothing to do with
+        // (#3141). The scheduled flush parks the incomplete transaction through
+        // the normal machinery and detaches the ambient slots first.
+                schedule();
+    }
+}
+
+function queuePendingNode(e) {
+    currentBatch.tn.push(e);
+}
+
+// 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;
+
+/** §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
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */ let notifyEpoch = 0;
+
+function bumpNotifyEpoch() {
+    notifyEpoch++;
+}
+
+function armReaskClear() {
+    reaskArmed = true;
+}
+
+/** Provenance of the work currently running (A18 supersession, #3331): the
+ * invocation sequence of the action whose ambient window this is — set by
+ * action() for each slice; the flush that ends the window clears it — or,
+ * inside an async landing, the sequence captured when that flight was
+ * registered (asyncWrite sets it for the landing's synchronous propagation,
+ * so a sync recompute downstream of the landing — an optimistic wrapper over
+ * the async source — derives under the flight's provenance, and flights it
+ * registers inherit it). 0 is mainline: no action, always the current
+ * question. An override stamps this at its write (`_overrideStamp`); an
+ * answer whose flight an OLDER action issued is a stale question the user
+ * has since changed — it holds silently to commit instead of superseding. A
+ * slow source must not leak back in over a newer intent. Transactions merge,
+ * so the transition object cannot say WHICH action asked; this can. */ let origin = 0;
+
+function setOrigin(e) {
+    const t = origin;
+    origin = e;
+    return t;
+}
+
+function insertSubs(e, t = false) {
+    // §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.Mt = 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
+    // 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?.Te : undefined) || currentOptimisticLane;
+    const r = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.Ot !== undefined;
+    const o = reaskArmed;
+    // 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 s = 0;
+    for (let i = e.u; i !== null; i = i.se) {
+        const e = i.le;
+        s++;
+        // A value-change notification is a new question for the subscriber: any
+        // pending re-ask mark (refresh) it carried is superseded.
+                if (o) e.it &= ~REACTIVE_REASK;
+        // 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
+        // already validated this dep — the value it read is now stale — so latch
+        // for recompute's tail to reschedule. Untouched links need no latch (the
+        // 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.it & REACTIVE_RECOMPUTING_DEPS && i.fn === e.Pt && i !== e.Dt) e.it |= REACTIVE_MISSED_WAKE;
+        if (r && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            e.it |= REACTIVE_SNAPSHOT_STALE;
+            continue;
+        }
+        if (t && n) {
+            e.it |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(e, n);
+        } else if (t) {
+            e.it |= REACTIVE_OPTIMISTIC_DIRTY;
+            // No source lane means reversion - clear subscriber's lane so effects go to regular queue
+                        if (e.o) e.o.Te = undefined;
+        }
+        enqueueSub(e);
+    }
+    if (s >= GRAPH_SIZE_WARN_AT) noteFanOut(e, s);
+}
+
+function commitPendingNode(e) {
+    const t = e;
+    if (!t.ot) {
+        if (e.Pe !== NOT_PENDING) {
+            e.ge = e.Pe;
+            e.Pe = NOT_PENDING;
+        }
+        if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.Dn(e);
+        return;
+    }
+    if (e.Pe !== NOT_PENDING) {
+        e.ge = 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._t = true;
+        // A quiet re-ask classification preserved through a held landing dies
+        // with the value commit — the commit IS the reveal (#3178). Gated on the
+        // staged value: status propagation queues pending nodes whose windows
+        // are still OPEN (no staged value), and their live classification must
+        // survive this sweep.
+                if (e.o) e.o.Ne = false;
+    }
+    // The committed hold 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.de = false;
+    t.it &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
+    // A flight this commit leaves in the air (unobserved, or observed only by
+    // a boundary) now has PUBLISHED inputs: its committed value is stale
+    // against the frame. read()'s reveal carve-out keys on the mark (#3305).
+     else e.T |= CONFIG_INPUTS_PUBLISHED;
+    if (t.o != null && (t.o.Rt !== null || t.o.Ct !== null)) GlobalQueue.Et(t, false, true);
+    if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.Dn(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;
+}
+
+/** Held truth committed this finalize, awaiting its post-revert wake (see
+ * finalizePureQueue): the commit IS the reveal, but subscribers must not
+ * re-derive until the settling transaction's optimistic overrides have
+ * reverted — a commit-time wake recomputes them in the window where
+ * confirming truth is committed and the override still displays, a torn
+ * frame no timeline contains. */ const heldRevealed = [];
+
+function commitPendingNodes() {
+    const e = currentBatch.tn;
+    for (let t = 0; t < e.length; t++) {
+        const i = e[t];
+        commitPendingNode(i);
+        // The stamp dies with the commit (#3143) — symmetric with
+        // resolveOptimisticNodes clearing optimistic stamps. A stamp outliving
+        // its transaction let any later write (even a value-equal no-op, which
+        // re-opens before the equality bail) resurrect the finished transaction;
+        // a boundary flag rewritten every finalize pass then spun the drain loop
+        // forever (#3140). The held-truth mark dies the same death — the commit
+        // IS the reveal — but its wake defers to the post-revert pass: ordinary
+        // subscribers were masked to committed all hold (some re-derived against
+        // that old view and cached it), and commits are otherwise silent
+        // (staging already notified), so without a wake they'd hold the old
+        // world forever.
+                i.Ee = null;
+        if (i.T & CONFIG_HELD_TRUTH) {
+            i.T &= ~CONFIG_HELD_TRUTH;
+            heldRevealed.push(i);
+        }
+    }
+    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 = currentBatch;
+    const n = !t;
+    if (n) commitPendingNodes();
+    if (!t && globalQueue.ei.length) checkBoundaryChildren(globalQueue);
+    // Contested effects (#3322) re-derive from the world this commit just
+    // produced. Ahead of the heap run — not the post-heap gated replay — so
+    // the recompute and the effect phase land in this same pass and the value
+    // the other transaction wrote into the slot is never published.
+    // (No clear: a completed transition is never finalized again.)
+    // A transaction whose settle reverts optimism re-derives them post-revert
+    // instead (below, with the gated replay): between commitPendingNodes and
+    // _resolveOptimistic the truth is committed but the overrides still
+    // display, and a re-derive here would compose the two — the #3164 tear,
+    // one window later. The slot meanwhile holds the frame that is on screen.
+        const r = e?.xt;
+    const o = n && (e ?? i).en.length !== 0;
+    if (r && !o) for (const e of r) if (!(e.it & REACTIVE_DISPOSED)) enqueueSub(e);
+    const s = dirtyQueue.EE >= dirtyQueue.St;
+    if (s) runHeap(dirtyQueue, GlobalQueue.lt);
+    if (n) {
+        // Boundary checks, commit hooks and recomputes can enter a transaction,
+        // which adopts the batch this finalize was settling: nothing batch-derived
+        // may be committed or reverted here — the entered transaction owns it now
+        // (#3319). A completing transaction's OWN containers are a different
+        // matter: when the ambient batch was separate from it (the #2916 shape),
+        // adoption never touched them and it must still settle them; when the
+        // batch WAS the completing transaction, adoption re-stamped its contents
+        // into the entered one and there is nothing left to settle.
+        if (currentBatch !== i) {
+            if (e === null || e === i) return;
+        } else if (s) commitPendingNodes();
+        // The settling batch: the completing transaction's, or the ambient one.
+                const t = e ?? i;
+        // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
+        // which installed the engine's hooks.
+                if (t.en.length) GlobalQueue.Un(t.en);
+        if (r && o) {
+            for (const e of r) if (!(e.it & REACTIVE_DISPOSED)) enqueueSub(e);
+            schedule();
+        }
+        // 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.ht.size) {
+            for (const e of t.ht) {
+                if (e.it & REACTIVE_DISPOSED) continue;
+                enqueueSub(e);
+            }
+            t.ht.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.A.length) {
+            GlobalQueue.G(t.A);
+            if (globalQueue.ei.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.nn.size) GlobalQueue.ri(t.nn, e);
+        // Held-truth reveal wake (#3164), post-revert by construction: this
+        // finalize committed confirming truth whose subscribers were masked all
+        // hold — some re-derived against the committed view (the staging, or a
+        // confirming carrier's landing, notified them as a plain write) and
+        // cached it, and stash-restored applies may carry those torn values.
+        // Waking and recomputing HERE — after _resolveOptimistic and the store
+        // clears above — means every apply paints the settled view; a wake at
+        // commit time would recompute them in the window where truth is
+        // committed but the settling transaction's overrides still display.
+                if (heldRevealed.length !== 0) {
+            while (heldRevealed.length) insertSubs(heldRevealed.pop());
+            if (dirtyQueue.EE >= dirtyQueue.St) {
+                runHeap(dirtyQueue, GlobalQueue.lt);
+                commitPendingNodes();
+            }
+        }
+        sweepTransientStoreNodes();
+        // Lanes only enter activeLanes through the engine's getOrCreateLane.
+                if (activeLanes.size) GlobalQueue.Fn(e);
+    }
+}
+
+function checkBoundaryChildren(e) {
+    for (const t of e.ei) {
+        t.st?.();
+        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].Ee = activeTransition;
+    }
+}
+
+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.m;
+
+function flush(e) {
+    // Inside an action body the drain is incoherent (#3333): the action's
+    // writes are held by its transaction until it settles, so a drain can't
+    // reveal them — and the loop below only exits once `activeTransition` is
+    // null, so it would PARK the transaction mid-slice and every write after it
+    // in the body would land as a plain, committed write. The reporter's
+    // "leading flush()" workaround was exactly that leak. Prod: run `fn` if
+    // given (its writes stay in the transaction) and skip the drain.
+    if (actionStepDepth > 0) {
+        return e ? e() : undefined;
+    }
+    if (e) {
+        syncDepth++;
+        try {
+            return e();
+        } finally {
+            // Decrement even if the drain throws (a throwing effect): a leaked
+            // syncDepth would stop `schedule()` from ever queuing a microtask again.
+            try {
+                flush();
+            } finally {
+                syncDepth--;
+            }
+        }
+    }
+    if (globalQueue.Qn) {
+        return;
+    }
+    if (halted) return;
+    // 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 t = false;
+    // `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) {
+        globalQueue.flush();
+        t = true;
+    }
+    // Provenance ends with the drain: every ambient window (an action's first
+    // slice, a landing's propagation) runs to this flush.
+        origin = 0;
+    // 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, or parked" instant for
+    // everything the loop processed.
+        if (t && attrHooks !== null) attrHooks.flushEnd();
+}
+
+function runQueue(e, t) {
+    for (let i = 0; i < e.length; i++) e[i](t);
+}
+
+function reporterBlocksSource(e, t) {
+    if (e.it & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.o?.ee?.has(t)) return true;
+    for (let i = e.te; i; i = i.ne) {
+        let e = i.oe;
+        while (e) {
+            if (e === t || e.re === t) return true;
+            e = e.o?.Qe;
+        }
+    }
+    return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
+}
+
+function transitionComplete(e) {
+    if (e.Ut) return true;
+    if (e.ut.length) {
+        // A live action parks the transaction regardless of async state.
+        if (attrHooks !== null) attrHooks.holdStart(e);
+        return false;
+    }
+    let t = true;
+    for (const [i, n] of e.Ie) {
+        let r = false;
+        for (const e of n) {
+            if (reporterBlocksSource(e, i)) {
+                r = true;
+                break;
+            }
+            n.delete(e);
+        }
+        if (!r) e.Ie.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.Pn?.(e)) t = false;
+    // Attribution hook: this verdict is the fork between settling (held writes
+    // commit next — `_pendingNodes` still lists them) and parking (the flush
+    // runs the lane effects, then stashes; `holdEnd` fires from stashQueues).
+    // Fired here rather than at flush()'s call site because that site is inside
+    // a `try` (see the rule in attribution-hooks.ts).
+        if (attrHooks !== null) t ? attrHooks.transitionSettled(e) : attrHooks.holdStart(e);
+    t && (e.Ut = true);
+    return t;
+}
+
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */ function createTransition() {
+    return createBatch();
+}
+
+function currentTransition(e) {
+    while (e.Ut && typeof e.Ut === "object") e = e.Ut;
+    return e;
+}
+
+/**
+ * The live transition blocked on `source` — the one whose render reader
+ * observed it pending (INV-3 records the observation in whichever transaction
+ * was active when the reader was notified). The observation is a fact about
+ * the node, so a hold check must not assume it was recorded in the transaction
+ * it happens to hold — lanes merge across transactions (#2912), and a merged
+ * root's transaction knows nothing of the async its members' transactions
+ * observed (#3335). Null when nobody is waiting.
+ */ function waitingTransition(e) {
+    for (const t of transitions) if (t.Ie.has(e)) return t;
+    return null;
+}
+
+function runInTransition(e, t) {
+    const i = activeTransition;
+    try {
+        activeTransition = currentTransition(e);
+        return t();
+    } finally {
+        activeTransition = i;
+    }
+}
+
+/** Run `fn` with `transition` as BOTH the ambient transaction and the
+ * registration batch, restoring both after. runInTransition alone is not
+ * enough for code that WRITES on behalf of a transaction from inside someone
+ * else's window (optimistic replay re-arming a still-open action's edits
+ * during a landing commit, #3123): registrations route through the queue's
+ * batch pointer, and a bare activeTransition swap leaves them in the ambient
+ * batch — a plain batch "completes" at the next flush and reverts optimistic
+ * registrations that were supposed to live with the transaction.
+ * initTransition is the wrong tool here: it MERGES the currently ambient
+ * transaction into the target, entangling whatever the interrupted window
+ * belonged to. */ function runAsTransitionBatch(e, t) {
+    const i = activeTransition;
+    const n = globalQueue.m;
+    try {
+        activeTransition = currentTransition(e);
+        currentBatch = globalQueue.m = activeTransition;
+        return t();
+    } finally {
+        activeTransition = i;
+        currentBatch = globalQueue.m = n;
+    }
+}
+
+export { GlobalQueue, Queue, actionStepDepth, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, createTransition, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, enterActionStep, exitActionStep, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, origin, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setOrigin, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, waitingTransition, zombieQueue };