@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.1

package/dist/prod/core/scheduler.js

@@ -0,0 +1,757 @@
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
+
+import { currentOptimisticLane } from "./core.js";
+
+import { DEV } from "./dev.js";
+
+import { NotReadyError } from "./error.js";
+
+import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
+
+import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
+
+export { getOrCreateLane, hasActiveOverride, 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,
+    Ve: 0,
+    EE: 0
+};
+
+const zombieQueue = {
+    eE: new Array(2e3).fill(undefined),
+    tE: false,
+    Ve: 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.se & REACTIVE_IN_HEAP_HEIGHT) e.se &= -12; else {
+        deleteFromHeap(e, zombieQueue);
+        e.se &= -4;
+    }
+}
+
+let clock = 0;
+
+let activeTransition = null;
+
+let scheduled = false;
+
+let halted = false;
+
+let haltNotified = false;
+
+let syncDepth = 0;
+
+let projectionWriteActive = false;
+
+// 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.vt.length === 0 && t.Me.length === 0 && t.A.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
+}
+
+function sweepTransientStoreNodes() {
+    if (transientStoreNodes.size === 0) return;
+    for (const e of transientStoreNodes) {
+        if (e.o !== null) {
+            transientStoreNodes.delete(e);
+            continue;
+        }
+        if (e._e !== NOT_PENDING) continue;
+        if (e.De !== undefined && e.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.t) continue;
+        transientStoreNodes.delete(e);
+        e.ut?.();
+    }
+}
+
+/**
+ * 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 {
+        de: clock,
+        Qt: [],
+        Ie: new Map,
+        Me: [],
+        A: [],
+        dn: new Set,
+        ie: [],
+        yt: {
+            bt: [ [], [] ],
+            vt: []
+        },
+        fn: false,
+        ln: new Set
+    };
+}
+
+function mergeTransitionState(e, t) {
+    t.fn = e;
+    e.ie.push(...t.ie);
+    for (const i of activeLanes) if (i.Ne === t) i.Ne = e;
+    if (t.Me.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.Me.push(...t.Me);
+        t.Me.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.dn) e.dn.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.ln) e.ln.add(i);
+}
+
+function schedule() {
+    if (halted) {
+        notifyHalted();
+        return;
+    }
+    if (scheduled) return;
+    scheduled = true;
+    if (!syncDepth && !globalQueue.cn && !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]";
+    // Log 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);
+}
+
+// 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 {
+    Fe=null;
+    bt=[ [], [] ];
+    vt=[];
+    kt=0;
+    created=clock;
+    addChild(e) {
+        this.vt.push(e);
+        e.Fe = this;
+    }
+    removeChild(e) {
+        const t = this.vt.indexOf(e);
+        if (t >= 0) {
+            this.vt.splice(t, 1);
+            e.Fe = null;
+        }
+    }
+    notify(e, t, i, n) {
+        if (this.Fe) return this.Fe.notify(e, t, i, n);
+        return false;
+    }
+    run(e) {
+        if (this.bt[e - 1].length) {
+            const t = this.bt[e - 1];
+            this.bt[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.vt;
+        const i = ++queueRunToken;
+        for (let n = 0; n < t.length; ) {
+            const s = t[n];
+            if (s.kt !== i) {
+                s.kt = 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.rn[e - 1].push(t);
+            } else {
+                this.bt[e - 1].push(t);
+            }
+        }
+        schedule();
+    }
+    stashQueues(e) {
+        e.bt[0].push(...this.bt[0]);
+        e.bt[1].push(...this.bt[1]);
+        this.bt = [ [], [] ];
+        for (let t = 0; t < this.vt.length; t++) {
+            let i = this.vt[t];
+            let n = e.vt[t];
+            if (!n) {
+                n = {
+                    bt: [ [], [] ],
+                    vt: []
+                };
+                e.vt[t] = n;
+            }
+            i.stashQueues(n);
+        }
+    }
+    restoreQueues(e) {
+        this.bt[0].push(...e.bt[0]);
+        this.bt[1].push(...e.bt[1]);
+        for (let t = 0; t < e.vt.length; t++) {
+            const i = e.vt[t];
+            let n = this.vt[t];
+            if (n) n.restoreQueues(i);
+        }
+    }
+}
+
+class GlobalQueue extends Queue {
+    cn=false;
+    // The current transaction-shaped batch: a plain ambient batch while no
+    // transition is active, the active transition itself after initTransition.
+    m=createBatch();
+    static Ce;
+    static me;
+    static et;
+    static gt=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 h=null;
+    // External-source bridge (wired by enableExternalSource(); null while no
+    // config is active — including after _resetExternalSourceConfig()).
+    static dt=null;
+    static St=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 Pe=null;
+    static Se=null;
+    static Ge=null;
+    static un=null;
+    static At=null;
+    static Ct=null;
+    static Pt=null;
+    static $e=null;
+    static k=null;
+    static Lt=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 Gt=null;
+    static En=null;
+    static Tn=null;
+    static In=null;
+    static Nn=null;
+    static Rt=null;
+    static Ot=null;
+    static Dt=null;
+    static je=null;
+    static ze=null;
+    static Be=null;
+    static Qn=null;
+    flush() {
+        if (this.cn) return;
+        this.cn = true;
+        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.m === 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.m === e) currentBatch = this.m = createBatch();
+                    // Run lane effects immediately (before stashing) - lanes with no pending async
+                                        if (activeLanes.size) {
+                        GlobalQueue.Nn(EFFECT_RENDER);
+                        GlobalQueue.Nn(EFFECT_USER);
+                    }
+                    this.stashQueues(e.yt);
+                    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.Ve || this.m.Qt.length > 0;
+                    reassignPendingTransition(e.Qt);
+                    activeTransition = null;
+                    finalizePureQueue(null, true);
+                    return;
+                }
+                const t = activeTransition;
+                const i = this.m;
+                i !== t && i.Qt.push(...t.Qt);
+                this.restoreQueues(t.yt);
+                transitions.delete(t);
+                activeTransition = null;
+                reassignPendingTransition(i.Qt);
+                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.Qt = i.Qt;
+                    e.Me = i.Me;
+                    e.A = i.A;
+                    e.dn = i.dn;
+                    currentBatch = this.m = e;
+                }
+            } else {
+                if (canUseSimpleSyncFlush(this)) {
+                    commitPendingNodes();
+                    if (dirtyQueue.EE >= dirtyQueue.Ve) {
+                        runHeap(dirtyQueue, GlobalQueue.Ce);
+                        commitPendingNodes();
+                    }
+                } else {
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
+                    finalizePureQueue();
+                }
+            }
+            clock++;
+            // Check if finalization added items to the heap (from optimistic reversion)
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Ve;
+            // Run lane effects first (for ready lanes), then regular effects
+                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
+            this.run(EFFECT_RENDER);
+            activeLanes.size && GlobalQueue.Nn(EFFECT_USER);
+            this.run(EFFECT_USER);
+            if (false) ;
+            if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
+            if (false) ;
+        } finally {
+            this.cn = 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) {
+                const t = n !== undefined ? n : e._;
+                // 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 (activeTransition && t) {
+                    const i = t.source;
+                    let n = activeTransition.Ie.get(i);
+                    if (!n) activeTransition.Ie.set(i, n = new Set);
+                    const s = n.size;
+                    n.add(e);
+                    if (n.size !== s) schedule();
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    initTransition(e) {
+        if (e) e = currentTransition(e);
+        if (e && e === activeTransition) return;
+        if (!e && activeTransition && activeTransition.de === clock) return;
+        if (!activeTransition) {
+            activeTransition = e ?? createBatch();
+        } else if (e) {
+            const t = activeTransition;
+            mergeTransitionState(e, t);
+            transitions.delete(t);
+            activeTransition = e;
+        }
+        transitions.add(activeTransition);
+        activeTransition.de = 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.Qt.length; e++) {
+                const i = t.Qt[e];
+                i.Ne = activeTransition;
+                activeTransition.Qt.push(i);
+            }
+            for (let e = 0; e < t.Me.length; e++) {
+                const i = t.Me[e];
+                i.Ne = activeTransition;
+                activeTransition.Me.push(i);
+            }
+            if (t.A.length) activeTransition.A.push(...t.A);
+            for (const e of t.dn) activeTransition.dn.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();
+            }
+            currentBatch = this.m = activeTransition;
+        }
+        for (const e of activeLanes) {
+            if (!e.Ne) e.Ne = activeTransition;
+        }
+    }
+}
+
+function queuePendingNode(e) {
+    currentBatch.Qt.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;
+
+function armReaskClear() {
+    reaskArmed = true;
+}
+
+function insertSubs(e, t = false) {
+    // 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
+    const i = e.Ke || currentOptimisticLane;
+    const n = e.xe !== undefined;
+    const s = reaskArmed;
+    for (let r = e.o; r !== null; r = r.ue) {
+        // A value-change notification is a new question for the subscriber: any
+        // pending re-ask mark (refresh) it carried is superseded.
+        if (s) r.fe.se &= ~REACTIVE_REASK;
+        if (n && r.fe.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            r.fe.se |= REACTIVE_SNAPSHOT_STALE;
+            continue;
+        }
+        if (t && i) {
+            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(r.fe, i);
+        } else if (t) {
+            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            // No source lane means reversion - clear subscriber's lane so effects go to regular queue
+                        r.fe.Ke = undefined;
+        }
+        enqueueSub(r.fe);
+    }
+}
+
+function commitPendingNode(e) {
+    const t = e;
+    if (!t.ce) {
+        if (e._e !== NOT_PENDING) {
+            e.be = e._e;
+            e._e = NOT_PENDING;
+        }
+        if (e.Oe || e.ge) GlobalQueue.un(e);
+        return;
+    }
+    if (e._e !== NOT_PENDING) {
+        e.be = e._e;
+        e._e = NOT_PENDING;
+        // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
+                if (e.Re && e.Re !== EFFECT_TRACKED) e.Je = true;
+    }
+    // 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.Ee = false;
+    t.se &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
+    if (t.We !== null || t.Qe !== null) GlobalQueue.me(t, false, true);
+    if (e.Oe || e.ge) 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;
+}
+
+function commitPendingNodes() {
+    const e = currentBatch.Qt;
+    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.vt.length) checkBoundaryChildren(globalQueue);
+    const n = dirtyQueue.EE >= dirtyQueue.Ve;
+    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.m;
+        // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
+        // which installed the engine's hooks.
+                if (t.Me.length) GlobalQueue.En(t.Me);
+        // 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.se & 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.A.length) {
+            GlobalQueue.G(t.A);
+            if (globalQueue.vt.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.dn.size) GlobalQueue.gt(t.dn, e);
+        sweepTransientStoreNodes();
+        // Lanes only enter activeLanes through the engine's getOrCreateLane.
+                if (activeLanes.size) GlobalQueue.In(e);
+    }
+}
+
+function checkBoundaryChildren(e) {
+    for (const t of e.vt) {
+        t.ne?.();
+        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].Ne = 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) {
+    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.cn) {
+        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) {
+        globalQueue.flush();
+    }
+}
+
+function runQueue(e, t) {
+    for (let i = 0; i < e.length; i++) e[i](t);
+}
+
+function reporterBlocksSource(e, t) {
+    if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.oe?.has(t)) return true;
+    for (let i = e.tt; i; i = i.nt) {
+        let e = i.it;
+        while (e) {
+            if (e === t || e.lt === t) return true;
+            e = e.nn;
+        }
+    }
+    return !!(e.S & STATUS_PENDING && e._ instanceof NotReadyError && e._.source === t);
+}
+
+function transitionComplete(e) {
+    if (e.fn) return true;
+    if (e.ie.length) return false;
+    let t = true;
+    for (const [i, n] of e.Ie) {
+        let s = false;
+        for (const e of n) {
+            if (reporterBlocksSource(e, i)) {
+                s = true;
+                break;
+            }
+            n.delete(e);
+        }
+        if (!s) e.Ie.delete(i); else if (i.S & STATUS_PENDING && i._?.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.Tn?.(e)) t = false;
+    t && (e.fn = true);
+    return t;
+}
+
+function currentTransition(e) {
+    while (e.fn && typeof e.fn === "object") e = e.fn;
+    return e;
+}
+
+function runInTransition(e, t) {
+    const i = activeTransition;
+    try {
+        activeTransition = currentTransition(e);
+        return t();
+    } finally {
+        activeTransition = i;
+    }
+}
+
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };