@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

package/dist/prod/core/scheduler.js

@@ -0,0 +1,689 @@
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, 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, 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,
+    Le: 0,
+    EE: 0
+};
+
+const zombieQueue = {
+    eE: new Array(2e3).fill(undefined),
+    tE: false,
+    Le: 0,
+    EE: 0
+};
+
+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 registerTransientStoreNode(e) {
+    transientStoreNodes.add(e);
+}
+
+function canUseSimpleSyncFlush(e) {
+    const t = e.N;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Be.length === 0 && t._.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
+}
+
+function sweepTransientStoreNodes() {
+    if (transientStoreNodes.size === 0) return;
+    for (const e of transientStoreNodes) {
+        if (e.p !== null) {
+            transientStoreNodes.delete(e);
+            continue;
+        }
+        if (e.ge !== NOT_PENDING) continue;
+        if (e.be !== undefined && e.be !== 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.M) continue;
+        transientStoreNodes.delete(e);
+        e.ct?.();
+    }
+}
+
+/**
+ * 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 {
+        Ie: clock,
+        yt: [],
+        Lt: new Map,
+        Be: [],
+        _: [],
+        dn: new Set,
+        Te: [],
+        Bt: {
+            Mt: [ [], [] ],
+            Qt: []
+        },
+        cn: false,
+        un: new Set
+    };
+}
+
+function mergeTransitionState(e, t) {
+    t.cn = e;
+    e.Te.push(...t.Te);
+    for (const i of activeLanes) if (i.ve === t) i.ve = e;
+    if (t.Be.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.Be.push(...t.Be);
+        t.Be.length = 0;
+    }
+    if (t._.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._.push(...t._);
+        t._.length = 0;
+    }
+    for (const i of t.dn) e.dn.add(i);
+    for (const [i, n] of t.Lt) {
+        let t = e.Lt.get(i);
+        if (!t) e.Lt.set(i, t = new Set);
+        for (const e of n) t.add(e);
+    }
+    for (const i of t.un) e.un.add(i);
+}
+
+function schedule() {
+    if (halted) {
+        notifyHalted();
+        return;
+    }
+    if (scheduled) return;
+    scheduled = true;
+    if (!syncDepth && !globalQueue.Ut && !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;
+}
+
+class Queue {
+    Fe=null;
+    Mt=[ [], [] ];
+    Qt=[];
+    created=clock;
+    addChild(e) {
+        this.Qt.push(e);
+        e.Fe = this;
+    }
+    removeChild(e) {
+        const t = this.Qt.indexOf(e);
+        if (t >= 0) {
+            this.Qt.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.Mt[e - 1].length) {
+            const t = this.Mt[e - 1];
+            this.Mt[e - 1] = [];
+            runQueue(t, e);
+        }
+        for (let t = 0; t < this.Qt.length; t++) this.Qt[t].run?.(e);
+    }
+    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.tn[e - 1].push(t);
+            } else {
+                this.Mt[e - 1].push(t);
+            }
+        }
+        schedule();
+    }
+    stashQueues(e) {
+        e.Mt[0].push(...this.Mt[0]);
+        e.Mt[1].push(...this.Mt[1]);
+        this.Mt = [ [], [] ];
+        for (let t = 0; t < this.Qt.length; t++) {
+            let i = this.Qt[t];
+            let n = e.Qt[t];
+            if (!n) {
+                n = {
+                    Mt: [ [], [] ],
+                    Qt: []
+                };
+                e.Qt[t] = n;
+            }
+            i.stashQueues(n);
+        }
+    }
+    restoreQueues(e) {
+        this.Mt[0].push(...e.Mt[0]);
+        this.Mt[1].push(...e.Mt[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 {
+    Ut=false;
+    // The current transaction-shaped batch: a plain ambient batch while no
+    // transition is active, the active transition itself after initTransition.
+    N=createBatch();
+    static Ce;
+    static Oe;
+    static ut;
+    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 T=null;
+    // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
+    // engine — count/register/release plus the post-commit re-application of
+    // marked reads — lives with the feature. Every call site is gated by state
+    // only that module creates, so `!` invocations are safe once the gate holds.
+    static j=null;
+    static h=null;
+    static D=null;
+    static F=null;
+    static $=null;
+    static I=null;
+    // External-source bridge (wired by enableExternalSource(); null while no
+    // config is active — including after _resetExternalSourceConfig()).
+    static Ot=null;
+    static Rt=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 _e=null;
+    static P=null;
+    static me=null;
+    static R=null;
+    static Gt=null;
+    static Pt=null;
+    static kt=null;
+    static tt=null;
+    static nt=null;
+    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 bt=null;
+    static En=null;
+    static Tn=null;
+    static In=null;
+    static Nn=null;
+    static On=null;
+    static Dt=null;
+    static gt=null;
+    static ht=null;
+    static vt=null;
+    static $e=null;
+    static et=null;
+    static Xe=null;
+    static mn=null;
+    flush() {
+        if (this.Ut) return;
+        this.Ut = true;
+        try {
+            if (false) ;
+            runHeap(dirtyQueue, GlobalQueue.Ce);
+            if (activeTransition) {
+                const e = transitionComplete(activeTransition);
+                if (!e) {
+                    const e = activeTransition;
+                    runHeap(zombieQueue, GlobalQueue.Ce);
+                    // Detach: the stashed transition keeps its batch; ambient work that
+                    // follows lands in a fresh one.
+                                        currentBatch = this.N = createBatch();
+                    // Run lane effects immediately (before stashing) - lanes with no pending async
+                                        if (activeLanes.size) {
+                        GlobalQueue.On(EFFECT_RENDER);
+                        GlobalQueue.On(EFFECT_USER);
+                    }
+                    this.stashQueues(e.Bt);
+                    clock++;
+                    scheduled = dirtyQueue.EE >= dirtyQueue.Le;
+                    reassignPendingTransition(e.yt);
+                    activeTransition = null;
+                    // The stash pass (committed-view rerun of plain optimistic signals)
+                    // wraps finalizePureQueue in the engine; a non-empty _optimisticNodes
+                    // means _optimisticWrite ran, which installed the hook.
+                                        if (!e.Te.length && !e.Lt.size && e.Be.length) {
+                        GlobalQueue.Tn(e);
+                    } else {
+                        finalizePureQueue(null, true);
+                    }
+                    return;
+                }
+                const t = activeTransition;
+                const i = this.N;
+                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.Be = i.Be;
+                    e._ = i._;
+                    e.dn = i.dn;
+                    currentBatch = this.N = e;
+                }
+            } else {
+                if (canUseSimpleSyncFlush(this)) {
+                    commitPendingNodes();
+                    if (dirtyQueue.EE >= dirtyQueue.Le) {
+                        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.Le;
+            // Run lane effects first (for ready lanes), then regular effects
+                        activeLanes.size && GlobalQueue.On(EFFECT_RENDER);
+            this.run(EFFECT_RENDER);
+            activeLanes.size && GlobalQueue.On(EFFECT_USER);
+            this.run(EFFECT_USER);
+            if (false) ;
+            if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
+            if (false) ;
+        } finally {
+            this.Ut = 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.k;
+                if (activeTransition && t) {
+                    const i = t.source;
+                    let n = activeTransition.Lt.get(i);
+                    if (!n) activeTransition.Lt.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.Ie === 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.Ie = clock;
+        const t = this.N;
+        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.ve = activeTransition;
+                activeTransition.yt.push(i);
+            }
+            for (let e = 0; e < t.Be.length; e++) {
+                const i = t.Be[e];
+                i.ve = activeTransition;
+                activeTransition.Be.push(i);
+            }
+            if (t._.length) activeTransition._.push(...t._);
+            for (const e of t.dn) activeTransition.dn.add(e);
+            currentBatch = this.N = activeTransition;
+        }
+        for (const e of activeLanes) {
+            if (!e.ve) e.ve = activeTransition;
+        }
+    }
+}
+
+function queuePendingNode(e) {
+    currentBatch.yt.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.Je || currentOptimisticLane;
+    const n = e.Ye !== undefined;
+    const s = reaskArmed;
+    for (let r = e.p; r !== null; r = r.de) {
+        // A value-change notification is a new question for the subscriber: any
+        // pending re-ask mark (refresh) it carried is superseded.
+        if (s) r.Ee.u &= ~REACTIVE_REASK;
+        if (n && r.Ee.U & CONFIG_IN_SNAPSHOT_SCOPE) {
+            r.Ee.u |= REACTIVE_SNAPSHOT_STALE;
+            continue;
+        }
+        if (t && i) {
+            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(r.Ee, i);
+        } else if (t) {
+            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            // No source lane means reversion - clear subscriber's lane so effects go to regular queue
+                        r.Ee.Je = undefined;
+        }
+        enqueueSub(r.Ee);
+    }
+}
+
+function commitPendingNode(e) {
+    const t = e;
+    if (!t.xe) {
+        if (e.ge !== NOT_PENDING) {
+            e.Ue = e.ge;
+            e.ge = NOT_PENDING;
+        }
+        if (e.ye || e.pe) GlobalQueue.R(e);
+        return;
+    }
+    if (e.ge !== NOT_PENDING) {
+        e.Ue = e.ge;
+        e.ge = NOT_PENDING;
+        // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
+                if (e.De && e.De !== EFFECT_TRACKED) e.it = true;
+    }
+    t.u &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.i & STATUS_PENDING)) t.i &= ~STATUS_UNINITIALIZED;
+    if (t.Ze !== null || t.We !== null) GlobalQueue.Oe(t, false, true);
+    if (e.ye || e.pe) GlobalQueue.R(e);
+}
+
+function commitPendingNodes() {
+    const e = currentBatch.yt;
+    for (let t = 0; t < e.length; t++) {
+        commitPendingNode(e[t]);
+    }
+    e.length = 0;
+}
+
+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.Le;
+    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.N;
+        // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
+        // which installed the engine's hooks.
+                if (t.Be.length) GlobalQueue.En(t.Be);
+        // Replay entanglement: subs recorded by the read-time gate get rescheduled
+        // so they re-run with the now-committed values visible.
+                if (e && e.un.size) {
+            for (const t of e.un) {
+                if (t.u & REACTIVE_DISPOSED) continue;
+                enqueueSub(t);
+            }
+            e.un.clear();
+        }
+        // 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.
+                if (t._.length) GlobalQueue.h(t._);
+        // 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.Vt(t.dn, e);
+        sweepTransientStoreNodes();
+        // Lanes only enter activeLanes through the engine's getOrCreateLane.
+                if (activeLanes.size) GlobalQueue.Nn(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].ve = 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.N;
+
+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.Ut) {
+        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.u & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.m?.has(t)) return true;
+    for (let i = e.S; i; i = i.st) {
+        let e = i.ot;
+        while (e) {
+            if (e === t || e.rt === t) return true;
+            e = e.en;
+        }
+    }
+    return !!(e.i & STATUS_PENDING && e.k instanceof NotReadyError && e.k.source === t);
+}
+
+function transitionComplete(e) {
+    if (e.cn) return true;
+    if (e.Te.length) return false;
+    let t = true;
+    for (const [i, n] of e.Lt) {
+        let s = false;
+        for (const e of n) {
+            if (reporterBlocksSource(e, i)) {
+                s = true;
+                break;
+            }
+            n.delete(e);
+        }
+        if (!s) e.Lt.delete(i); else if (i.i & STATUS_PENDING && i.k?.source === i) {
+            t = false;
+            break;
+        }
+    }
+    // Override blockage lives with the engine. Absent hook = "no optimistic
+    // blockage", which is exact: only _optimisticWrite (engine) pushes to
+    // _optimisticNodes, so without the engine the loop was vacuous anyway.
+        if (t && e.Be.length && GlobalQueue.In(e)) t = false;
+    t && (e.cn = true);
+    return t;
+}
+
+function currentTransition(e) {
+    while (e.cn && typeof e.cn === "object") e = e.cn;
+    return e;
+}
+
+function setActiveTransition(e) {
+    activeTransition = 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, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setActiveTransition, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };