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

package/dist/prod/core/scheduler.js

@@ -0,0 +1,689 @@
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_REASK, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, 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) {
+    return transitions.size === 0 && activeLanes.size === 0 && e.wt.length === 0 && e.Be.length === 0 && e.N.length === 0 && e.Lt.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.P) 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;
+}
+
+function mergeTransitionState(e, t) {
+    t.Ht = 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 may still alias the outgoing
+        // array, 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.N.length) {
+        // Move (don't copy): the global queue may still alias the outgoing
+        // array, and the adoption pass in initTransition would re-push its
+        // contents into the target — double-releasing every mark.
+        e.N.push(...t.N);
+        t.N.length = 0;
+    }
+    for (const i of t.Lt) e.Lt.add(i);
+    for (const [i, n] of t.qt) {
+        let t = e.qt.get(i);
+        if (!t) e.qt.set(i, t = new Set);
+        for (const e of n) t.add(e);
+    }
+    for (const i of t.Qt) e.Qt.add(i);
+}
+
+function schedule() {
+    if (halted) {
+        notifyHalted();
+        return;
+    }
+    if (scheduled) return;
+    scheduled = true;
+    if (!syncDepth && !globalQueue.Bt && !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 {
+    He=null;
+    zt=[ [], [] ];
+    wt=[];
+    created=clock;
+    addChild(e) {
+        this.wt.push(e);
+        e.He = this;
+    }
+    removeChild(e) {
+        const t = this.wt.indexOf(e);
+        if (t >= 0) {
+            this.wt.splice(t, 1);
+            e.He = null;
+        }
+    }
+    notify(e, t, i, n) {
+        if (this.He) return this.He.notify(e, t, i, n);
+        return false;
+    }
+    run(e) {
+        if (this.zt[e - 1].length) {
+            const t = this.zt[e - 1];
+            this.zt[e - 1] = [];
+            runQueue(t, e);
+        }
+        for (let t = 0; t < this.wt.length; t++) this.wt[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.zt[e - 1].push(t);
+            }
+        }
+        schedule();
+    }
+    stashQueues(e) {
+        e.zt[0].push(...this.zt[0]);
+        e.zt[1].push(...this.zt[1]);
+        this.zt = [ [], [] ];
+        for (let t = 0; t < this.wt.length; t++) {
+            let i = this.wt[t];
+            let n = e.wt[t];
+            if (!n) {
+                n = {
+                    zt: [ [], [] ],
+                    wt: []
+                };
+                e.wt[t] = n;
+            }
+            i.stashQueues(n);
+        }
+    }
+    restoreQueues(e) {
+        this.zt[0].push(...e.zt[0]);
+        this.zt[1].push(...e.zt[1]);
+        for (let t = 0; t < e.wt.length; t++) {
+            const i = e.wt[t];
+            let n = this.wt[t];
+            if (n) n.restoreQueues(i);
+        }
+    }
+}
+
+class GlobalQueue extends Queue {
+    Bt=false;
+    xt=null;
+    Yt=[];
+    Be=[];
+    N=[];
+    Lt=new Set;
+    static Ce;
+    static Oe;
+    static ut;
+    static Kt=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 _=null;
+    static me=null;
+    static R=null;
+    static Gt=null;
+    static Pt=null;
+    static vt=null;
+    static tt=null;
+    static nt=null;
+    static Zt=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 Ut=null;
+    static yt=null;
+    static Wt=null;
+    static jt=null;
+    static Mt=null;
+    static gt=null;
+    static Dt=null;
+    static ht=null;
+    static kt=null;
+    static $e=null;
+    static et=null;
+    static Xe=null;
+    static Vt=null;
+    flush() {
+        if (this.Bt) return;
+        this.Bt = true;
+        try {
+            if (false) ;
+            runHeap(dirtyQueue, GlobalQueue.Ce);
+            if (activeTransition) {
+                const e = transitionComplete(activeTransition);
+                if (!e) {
+                    const e = activeTransition;
+                    runHeap(zombieQueue, GlobalQueue.Ce);
+                    this.xt = null;
+                    this.Yt = [];
+                    this.Be = [];
+                    this.N = [];
+                    this.Lt = new Set;
+                    // Run lane effects immediately (before stashing) - lanes with no pending async
+                                        if (activeLanes.size) {
+                        GlobalQueue.Mt(EFFECT_RENDER);
+                        GlobalQueue.Mt(EFFECT_USER);
+                    }
+                    this.stashQueues(e.Jt);
+                    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.qt.size && e.Be.length) {
+                        GlobalQueue.yt(e);
+                    } else {
+                        finalizePureQueue(null, true);
+                    }
+                    return;
+                }
+                this.Yt !== activeTransition.Yt && this.Yt.push(...activeTransition.Yt);
+                this.restoreQueues(activeTransition.Jt);
+                transitions.delete(activeTransition);
+                const t = activeTransition;
+                activeTransition = null;
+                reassignPendingTransition(this.Yt);
+                finalizePureQueue(t);
+            } 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.Mt(EFFECT_RENDER);
+            this.run(EFFECT_RENDER);
+            activeLanes.size && GlobalQueue.Mt(EFFECT_USER);
+            this.run(EFFECT_USER);
+            if (false) ;
+            if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
+            if (false) ;
+        } finally {
+            this.Bt = 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.qt.get(i);
+                    if (!n) activeTransition.qt.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 ?? {
+                Ie: clock,
+                Yt: [],
+                qt: new Map,
+                Be: [],
+                N: [],
+                Lt: new Set,
+                Te: [],
+                Jt: {
+                    zt: [ [], [] ],
+                    wt: []
+                },
+                Ht: false,
+                Qt: new Set
+            };
+        } else if (e) {
+            const t = activeTransition;
+            mergeTransitionState(e, t);
+            transitions.delete(t);
+            activeTransition = e;
+        }
+        transitions.add(activeTransition);
+        activeTransition.Ie = clock;
+        if (this.xt !== null) {
+            this.xt.ve = activeTransition;
+            activeTransition.Yt.push(this.xt);
+            this.xt = null;
+        }
+        if (this.Yt !== activeTransition.Yt) {
+            for (let e = 0; e < this.Yt.length; e++) {
+                const t = this.Yt[e];
+                t.ve = activeTransition;
+                activeTransition.Yt.push(t);
+            }
+            this.Yt = activeTransition.Yt;
+        }
+        if (this.Be !== activeTransition.Be) {
+            for (let e = 0; e < this.Be.length; e++) {
+                const t = this.Be[e];
+                t.ve = activeTransition;
+                activeTransition.Be.push(t);
+            }
+            this.Be = activeTransition.Be;
+        }
+        if (this.N !== activeTransition.N) {
+            // Adopt ambient marks into the transaction (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). After adoption the queue aliases the
+            // transition's array, so later registrations land there directly.
+            activeTransition.N.push(...this.N);
+            this.N = activeTransition.N;
+        }
+        for (const e of activeLanes) {
+            if (!e.ve) e.ve = activeTransition;
+        }
+        if (this.Lt !== activeTransition.Lt) {
+            for (const e of this.Lt) activeTransition.Lt.add(e);
+            this.Lt = activeTransition.Lt;
+        }
+    }
+}
+
+function queuePendingNode(e) {
+    if (activeTransition) {
+        globalQueue.Yt.push(e);
+        return;
+    }
+    if (globalQueue.xt === null && globalQueue.Yt.length === 0) {
+        globalQueue.xt = e;
+        return;
+    }
+    if (globalQueue.xt !== null) {
+        globalQueue.Yt.push(globalQueue.xt);
+        globalQueue.xt = null;
+    }
+    globalQueue.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 a = e.p; a !== null; a = a.de) {
+        // A value-change notification is a new question for the subscriber: any
+        // pending re-ask mark (refresh) it carried is superseded.
+        if (s) a.Ee.u &= ~REACTIVE_REASK;
+        if (n && a.Ee.U & CONFIG_IN_SNAPSHOT_SCOPE) {
+            a.Ee.u |= REACTIVE_SNAPSHOT_STALE;
+            continue;
+        }
+        if (t && i) {
+            a.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(a.Ee, i);
+        } else if (t) {
+            a.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            // No source lane means reversion - clear subscriber's lane so effects go to regular queue
+                        a.Ee.Je = undefined;
+        }
+        enqueueSub(a.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() {
+    if (globalQueue.xt !== null) {
+        commitPendingNode(globalQueue.xt);
+        globalQueue.xt = null;
+    }
+    const e = globalQueue.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.wt.length) checkBoundaryChildren(globalQueue);
+    const n = dirtyQueue.EE >= dirtyQueue.Le;
+    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
+    if (i) {
+        if (n) commitPendingNodes();
+        // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
+        // which installed the engine's hooks.
+                const t = e ? e.Be : globalQueue.Be;
+        if (t.length) GlobalQueue.Ut(t);
+        // Replay entanglement: subs recorded by the read-time gate get rescheduled
+        // so they re-run with the now-committed values visible.
+                if (e && e.Qt.size) {
+            for (const t of e.Qt) {
+                if (t.u & REACTIVE_DISPOSED) continue;
+                enqueueSub(t);
+            }
+            e.Qt.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.
+                const i = e ? e.N : globalQueue.N;
+        if (i.length) GlobalQueue.h(i);
+        const s = e ? e.Lt : globalQueue.Lt;
+        // 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).
+                if (s.size) GlobalQueue.Kt(s);
+        sweepTransientStoreNodes();
+        // Lanes only enter activeLanes through the engine's getOrCreateLane.
+                if (activeLanes.size) GlobalQueue.jt(e);
+    }
+}
+
+function checkBoundaryChildren(e) {
+    for (const t of e.wt) {
+        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;
+
+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.Bt) {
+        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 === t || 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.Ht) return true;
+    if (e.Te.length) return false;
+    let t = true;
+    for (const [i, n] of e.qt) {
+        let s = false;
+        for (const e of n) {
+            if (reporterBlocksSource(e, i)) {
+                s = true;
+                break;
+            }
+            n.delete(e);
+        }
+        if (!s) e.qt.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.Wt(e)) t = false;
+    t && (e.Ht = true);
+    return t;
+}
+
+function currentTransition(e) {
+    while (e.Ht && typeof e.Ht === "object") e = e.Ht;
+    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 };