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

package/dist/prod/core/core.js

@@ -0,0 +1,772 @@
+import { handleAsync, clearStatus, notifyStatus } from "./async.js";
+
+import { $REFRESH, REACTIVE_DISPOSED, REACTIVE_MANUAL_WRITE, REACTIVE_DIRTY, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT, REACTIVE_SNAPSHOT_STALE, EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_RECOMPUTING_DEPS, STATUS_ERROR, REACTIVE_IN_HEAP_HEIGHT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+
+import { NotReadyError } from "./error.js";
+
+import { trimStaleDeps, link, unobserved } from "./graph.js";
+
+import { insertIntoHeap, queueFor, deleteFromHeap, insertIntoHeapHeight, markNode, markHeap } from "./heap.js";
+
+import { schedule, GlobalQueue, globalQueue, clock, activeTransition, queuePendingNode, insertSubs, dirtyQueue, activeAffectsMarks, runInTransition, projectionWriteActive, armReaskClear } from "./scheduler.js";
+
+import "./invariants.js";
+
+import { inheritId, disposeChildren, markDisposal } from "./owner.js";
+
+GlobalQueue.Ce = recompute;
+
+GlobalQueue.Oe = disposeChildren;
+
+let tracking = false;
+
+/** @internal verdict-module glue */ function setPendingCheckActive(e) {
+    pendingCheckActive = e;
+}
+
+/** @internal verdict-module glue */ function setLatestReadActive(e) {
+    latestReadActive = e;
+}
+
+/** @internal verdict-module glue */ function setContextInternal(e) {
+    context = e;
+}
+
+let stale = false;
+
+let pendingCheckActive = false;
+
+let latestReadActive = false;
+
+let context = null;
+
+let currentOptimisticLane = null;
+
+/**
+ * Marked sources read by the recompute currently on the stack (saved/restored
+ * per recompute, like `context`). A computed that reads a node with a live
+ * `affects()` mark inherits the mark's pendingness — `recompute` applies the
+ * collected sources through `applyAffectsReads` after its commit, because the
+ * `clearStatus` at the top of the commit path wipes whatever sentinel entries
+ * the node held from the registration-time push. This is the pull half of
+ * mark propagation (real async re-establishes itself by re-throwing on read;
+ * marks are value-transparent, so they re-establish here instead).
+ */ let affectsReads = null;
+
+let snapshotCaptureActive = false;
+
+let snapshotSources = null;
+
+function ownerInSnapshotScope(e) {
+    while (e) {
+        if (e.ke) return true;
+        e = e.He;
+    }
+    return false;
+}
+
+function setSnapshotCapture(e) {
+    snapshotCaptureActive = e;
+    if (e && !snapshotSources) snapshotSources = new Set;
+}
+
+function markSnapshotScope(e) {
+    e.ke = true;
+}
+
+function releaseSnapshotScope(e) {
+    e.ke = false;
+    releaseSubtree(e);
+    schedule();
+}
+
+function releaseSubtree(e) {
+    let t = e.Fe;
+    while (t) {
+        if (t.ke) {
+            t = t.Ve;
+            continue;
+        }
+        if (t.xe) {
+            const e = t;
+            e.U &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.u & REACTIVE_SNAPSHOT_STALE) {
+                e.u &= ~REACTIVE_SNAPSHOT_STALE;
+                e.u |= REACTIVE_DIRTY;
+                if (dirtyQueue.Le > e.qe) dirtyQueue.Le = e.qe;
+                insertIntoHeap(e, dirtyQueue);
+            }
+        }
+        releaseSubtree(t);
+        t = t.Ve;
+    }
+}
+
+function clearSnapshots() {
+    if (snapshotSources) {
+        for (const e of snapshotSources) {
+            delete e.Ye;
+            delete e[STORE_SNAPSHOT_PROPS];
+        }
+        snapshotSources = null;
+    }
+    snapshotCaptureActive = false;
+}
+
+function recompute(e, t = false) {
+    const n = e.De;
+    if (!t) {
+        if (e.ve && (!n || activeTransition) && activeTransition !== e.ve) globalQueue.initTransition(e.ve);
+        deleteFromHeap(e, queueFor(e));
+        e.Ae = null;
+        // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
+                if (e.ve || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Fe !== null || e.Me !== null) {
+            markDisposal(e);
+            e.We = e.Me;
+            e.Ze = e.Fe;
+            e.Me = null;
+            e.Fe = null;
+            e.je = 0;
+        } else ;
+    }
+    let i = !!(e.u & REACTIVE_OPTIMISTIC_DIRTY);
+    const l = e.be !== undefined && e.be !== NOT_PENDING;
+    const u = !!(e.i & STATUS_UNINITIALIZED);
+    // Re-ask classification lives in the verdict module; capture the flag before
+    // the recompute wipes _flags below.
+        const s = (e.u & REACTIVE_REASK) !== 0;
+    const o = context;
+    context = e;
+    e.Ke = null;
+    e.ze++;
+    e.u = REACTIVE_RECOMPUTING_DEPS;
+    e.Ie = clock;
+    let a = e.ge === NOT_PENDING ? e.Ue : e.ge;
+    let r = e.qe;
+    let c = tracking;
+    const _ = affectsReads;
+    affectsReads = null;
+    let f = null;
+    let E = currentOptimisticLane;
+    tracking = true;
+    // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
+    // engine-driven paths, and _optimisticNodes is only pushed by
+    // _optimisticWrite, so the hook is installed whenever either gate holds.
+        if (i) {
+        const t = GlobalQueue.$e(e, true);
+        if (t) currentOptimisticLane = t;
+    } else if (activeTransition && !t && activeTransition.Be.length) {
+        // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
+        // child propagates. Walk deps once and inherit the OPT lane so this node
+        // recomputes under the right posture and propagates correctly.
+        const t = GlobalQueue.$e(e, false);
+        if (t) {
+            i = true;
+            currentOptimisticLane = t;
+        }
+    }
+    const T = n && n !== EFFECT_USER;
+    const N = stale;
+    if (T) stale = true;
+    try {
+        if (!false && e.U & CONFIG_SYNC) {
+            a = e.xe(a);
+            e.Ae = null;
+        } else {
+            // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
+            // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
+            // with a setter callback). In that case, the outer `handleAsync` call below would
+            // clobber the fresh subscription, so we skip it and let the internally-registered
+            // iteration drive updates.
+            const t = e.Ae;
+            const n = e.xe(a);
+            const i = typeof n === "object" && n !== null;
+            const l = e.Ae !== t;
+            a = l || !i ? n : handleAsync(e, n);
+            if (!l && !i) e.Ae = null;
+        }
+        clearStatus(e, t);
+        // _optimisticLane is only ever assigned by engine paths.
+                if (e.Je) GlobalQueue.Xe(e);
+    } catch (t) {
+        // Track pending async in the lane (not the lane's source — it creates the lane
+        // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
+        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.et(e);
+        let n = false;
+        if (t instanceof NotReadyError) {
+            e.Re = true;
+            if (GlobalQueue.tt !== null) n = GlobalQueue.tt(e, s);
+        }
+        notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.Je : undefined);
+        if (n) GlobalQueue.nt(e);
+    } finally {
+        tracking = c;
+        if (T) stale = N;
+        e.u = REACTIVE_NONE | (t ? e.u & REACTIVE_SNAPSHOT_STALE : 0);
+        context = o;
+        f = affectsReads;
+        affectsReads = _;
+    }
+    if (!e.k) {
+        trimStaleDeps(e);
+        const s = l ? e.be : e.ge === NOT_PENDING ? e.Ue : e.ge;
+        let o = false;
+        try {
+            o = !n && u || !e.Ge || !e.Ge(s, a);
+        } catch (t) {
+            // A throwing user comparator is an error of this node's computation.
+            // Route it through the same status path as a compute-phase throw so
+            // error boundaries contain it; otherwise it unwinds the scheduler
+            // flush, bypassing every boundary and wedging the queue (#2837).
+            notifyStatus(e, STATUS_ERROR, t);
+        }
+        // Effects use `_equals: false` (no per-effect closure). The side effects that
+        // the equals closure used to perform — flagging the effect dirty and enqueueing
+        // its runner — happen here instead. `!create` matches the previous `initialized`
+        // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
+        // effect() can call its runner synchronously for the first run.
+                if (n && o) {
+            e.it = !e.k;
+            // Reuse one bound runner per effect — runEffect no-ops on a stale
+            // `_modified`, so re-enqueueing the same function is harmless.
+                        if (!t) e.v.enqueue(n, e.lt ??= GlobalQueue.ut.bind(null, e));
+        }
+        if (e.k) ; else if (o) {
+            const u = l ? e.be : undefined;
+            if (t || n && activeTransition !== e.ve || i) {
+                e.Ue = a;
+                // Lane-propagated correction: upstream data is fresh, correct the
+                // override unconditionally. The direct _value commit is the lane's
+                // own reveal schedule; drop any superseded older hold so its queued
+                // commit can't clobber the fresh value.
+                                if (l && i) {
+                    e.be = a;
+                    e.ge = NOT_PENDING;
+                }
+            } else {
+                e.ge = a;
+                // Transition-held sync recompute is a write path like setSignal/asyncWrite,
+                // so sync derivations of held sources stay visible to isPending()/latest()
+                // (#2831). Both companion writes are transition-scoped (optimistic) and
+                // auto-revert/re-derive at commit. Skipped for plain flushes where the
+                // pending value commits before effects run.
+                                if ((activeTransition || e.ve) && GlobalQueue._e !== null) GlobalQueue._e(e, a);
+            }
+            if (!l || i || e.be !== u) insertSubs(e, i || l);
+        } else if (l) {
+            // Unchanged value (equals the override) recomputed while the override
+            // is active: _value may still be stale, so hold the authoritative value
+            // for commit on its own transition's schedule — invisibly (A17/A18).
+            if (e.ge === NOT_PENDING) queuePendingNode(e);
+            e.ge = a;
+        } else if (e.qe != r) {
+            for (let t = e.p; t !== null; t = t.de) {
+                insertIntoHeapHeight(t.Ee, queueFor(t.Ee));
+            }
+        }
+    }
+    currentOptimisticLane = E;
+    // Marks read during this recompute re-attach after the commit above:
+    // earlier, the sentinel's NotReadyError in `_error` would have routed the
+    // fresh value into the error-skip branch instead of committing it. A real
+    // (non-NotReady) error wins over marks (#2893): applying the sentinel here
+    // would clobber the user's error with a NotReadyError from a node whose
+    // reads value-transparency promises can never throw NotReady.
+    // `markedReads` only collects under a live mark, so the hook is installed.
+        if (f && !(e.i & STATUS_ERROR)) GlobalQueue.j(e, f);
+    // Mark-only pending doesn't queue (#2893): the node holds no value needing
+    // a transition-scheduled commit, and queueing would stamp the marking
+    // action's transaction onto it — freezing unrelated writes that share it.
+    // (Single mask test up front keeps the mark-free hot path at original cost.)
+        const I = e.i & (STATUS_PENDING | STATUS_UNINITIALIZED);
+    const S = e.ge !== NOT_PENDING || e.Ze !== null || e.We !== null || I !== 0 && (I !== STATUS_PENDING || activeAffectsMarks === 0 || !GlobalQueue.$(e));
+    // Override-covered holds (hasOverride) always queue: their commit belongs
+    // to their own transition's schedule (A18 re-rule) and is unobservable
+    // under the override (A17). Revert no longer commits anything, so an
+    // unqueued covered hold would leak (INV-7) once the revert clears
+    // _transition.
+        S && (!t || e.i & STATUS_PENDING) && (!e.ve || l) && queuePendingNode(e);
+    e.ve && n && activeTransition !== e.ve && runInTransition(e.ve, () => recompute(e));
+}
+
+function updateIfNecessary(e) {
+    if (e.u & REACTIVE_CHECK) {
+        for (let t = e.S; t; t = t.st) {
+            const n = t.ot;
+            const i = n.rt || n;
+            if (i.xe) {
+                updateIfNecessary(i);
+            }
+            if (e.u & REACTIVE_DIRTY) {
+                break;
+            }
+        }
+    }
+    if (e.u & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.k && e.Ie < clock && !e.Ae) {
+        recompute(e);
+    }
+    e.u = e.u & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+}
+
+function computed(e, t) {
+    const n = t?.transparent ?? false;
+    const i = {
+        id: inheritId(t, n, context),
+        U: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.re ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ge: t?.equals != null ? t.equals : isEqual,
+        ct: t?.unobserved,
+        Me: null,
+        v: context?.v ?? globalQueue,
+        we: context?.we ?? defaultContext,
+        je: 0,
+        xe: e,
+        Ue: undefined,
+        qe: 0,
+        G: null,
+        _t: undefined,
+        ft: null,
+        S: null,
+        Ke: null,
+        ze: 0,
+        p: null,
+        Et: null,
+        He: context,
+        Ve: null,
+        Tt: null,
+        Fe: null,
+        u: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        i: STATUS_UNINITIALIZED,
+        Ie: clock,
+        ge: NOT_PENDING,
+        We: null,
+        Ze: null,
+        Ae: null,
+        ve: null,
+        A: false
+    };
+    setupComputedNode(i, t);
+    return i;
+}
+
+/**
+ * Build an Effect node with all effect-specific fields baked into a single object literal,
+ * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
+ * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
+ * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
+ */ function createEffectNode(e, t, n, i, l, u) {
+    const s = u?.transparent ?? false;
+    const o = {
+        id: inheritId(u, s, context),
+        U: (s ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ge: false,
+        ct: u?.unobserved,
+        Me: null,
+        v: context?.v ?? globalQueue,
+        we: context?.we ?? defaultContext,
+        je: 0,
+        xe: e,
+        Ue: undefined,
+        qe: 0,
+        G: null,
+        _t: undefined,
+        ft: null,
+        S: null,
+        Ke: null,
+        ze: 0,
+        p: null,
+        Et: null,
+        He: context,
+        Ve: null,
+        Tt: null,
+        Fe: null,
+        u: REACTIVE_LAZY,
+        i: STATUS_UNINITIALIZED,
+        Ie: clock,
+        ge: NOT_PENDING,
+        We: null,
+        Ze: null,
+        Ae: null,
+        ve: null,
+        A: false,
+        it: false,
+        Nt: undefined,
+        It: t,
+        St: n,
+        At: undefined,
+        De: i,
+        C: l
+    };
+    setupComputedNode(o, lazyOptions);
+    return o;
+}
+
+const lazyOptions = {
+    lazy: true
+};
+
+function setupComputedNode(e, t) {
+    e.ft = e;
+    const n = context?.dt ? context.Ct : context;
+    if (context) {
+        const t = context.Fe;
+        if (t === null) {
+            context.Fe = e;
+        } else {
+            e.Ve = t;
+            t.Tt = e;
+            context.Fe = e;
+        }
+    }
+    if (n) e.qe = n.qe + 1;
+    if (GlobalQueue.Ot !== null) GlobalQueue.Ot(e);
+    !t?.lazy && recompute(e, true);
+    if (snapshotCaptureActive && !t?.lazy) {
+        if (!(e.i & STATUS_PENDING) && !(e.U & CONFIG_NO_SNAPSHOT)) {
+            e.Ye = e.Ue === undefined ? NO_SNAPSHOT : e.Ue;
+            snapshotSources.add(e);
+        }
+    }
+}
+
+function signal(e, t, n = null) {
+    const i = {
+        Ge: t?.equals != null ? t.equals : isEqual,
+        U: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.re ? CONFIG_NO_SNAPSHOT : 0),
+        ct: t?.unobserved,
+        Ue: e,
+        p: null,
+        Et: null,
+        Ie: clock,
+        rt: n,
+        Ne: n?.G || null,
+        ge: NOT_PENDING
+    };
+    n && (n.G = i);
+    if (snapshotCaptureActive && !(i.U & CONFIG_NO_SNAPSHOT) && !((n?.i ?? 0) & STATUS_PENDING)) {
+        i.Ye = e === undefined ? NO_SNAPSHOT : e;
+        snapshotSources.add(i);
+    }
+    return i;
+}
+
+function optimisticSignal(e, t) {
+    const n = signal(e, t);
+    n.be = NOT_PENDING;
+    return n;
+}
+
+function optimisticComputed(e, t) {
+    const n = computed(e, t);
+    n.be = NOT_PENDING;
+    return n;
+}
+
+function isEqual(e, t) {
+    return e === t;
+}
+
+/**
+ * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
+ * subscribe the current scope. Returns whatever `fn` returns.
+ *
+ * Use `untrack` inside a memo or effect when you need to read a signal once
+ * without making the surrounding computation depend on its future changes.
+ *
+ * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
+ * read inside `fn` that isn't inside a nested tracking scope will log a
+ * warning naming the label.
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => trigger(),                 // tracks `trigger` only
+ *   () => {
+ *     const snapshot = untrack(() => state); // read once, untracked
+ *     log(snapshot);
+ *   }
+ * );
+ * ```
+ */ function untrack(e, t) {
+    if (GlobalQueue.Rt === null && !tracking && true) return e();
+    const n = tracking;
+    tracking = false;
+    try {
+        if (GlobalQueue.Rt !== null) return GlobalQueue.Rt(e);
+        return e();
+    } finally {
+        tracking = n;
+    }
+}
+
+/**
+ * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
+ * an isPending() probe (`refresh`) additionally pulls the node fully up to
+ * date so its status flags reflect the current graph.
+ */ function prepareComputed(e, t) {
+    if (e.u & REACTIVE_LAZY) {
+        e.u &= ~REACTIVE_LAZY;
+        recompute(e, true);
+    } else if (e.u & REACTIVE_DISPOSED) {
+        recompute(e, true);
+    } else if (t) {
+        updateIfNecessary(e);
+    }
+}
+
+function read(e) {
+    // Handle latest() mode: read from _latestValueComputed
+    // Checked before isPending so that isPending(() => latest(x)) checks
+    // the _pendingSignal of _latestValueComputed (async in flight) rather
+    // than the original node (which stays "pending" while held in a transition).
+    if (latestReadActive) return GlobalQueue.Gt(e);
+    let t = context;
+    if (t?.dt) t = t.Ct;
+    const n = e;
+    const i = e.rt;
+    const l = i || e;
+    // Handle isPending() mode: collect pending state while preserving normal read semantics.
+    // Probe mode is suspended while preparing the node so nested reads during a
+    // recompute don't collect into the probe.
+        if (pendingCheckActive) {
+        GlobalQueue.Pt(e, t, l, i);
+    } else if (typeof n.xe === "function") {
+        prepareComputed(e, false);
+    }
+    if (!n.xe && l === e && e.be === undefined && e.Ye === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+        if (t && tracking) {
+            link(e, t);
+            // A live mark on a read source flows to the reader (probe reads are
+            // excluded: the probe's own collection owns that verdict, and marking
+            // the enclosing memo would make an `isPending` wrapper itself pending).
+                        if (activeAffectsMarks !== 0 && e.P && !pendingCheckActive) (affectsReads ??= []).push(e);
+        }
+        return !t || e.ge === NOT_PENDING ? e.Ue : e.ge;
+    }
+    if (t && tracking) {
+        link(e, t, pendingCheckActive);
+        // Mark inheritance through derivation (see the fast path above), and its
+        // transitive half (#2893): a mark-pended owner's sentinel sources flow to
+        // the reader like a direct mark — value-transparent reads have no throw
+        // to re-establish through, so without this a mid-window recompute sheds
+        // pendingness permanently past one derivation level.
+                if (activeAffectsMarks !== 0 && !pendingCheckActive) {
+            if (e.P) (affectsReads ??= []).push(e);
+            if (l.i & STATUS_PENDING) GlobalQueue.I(l, affectsReads ??= []);
+        }
+        if (l.xe) {
+            const n = queueFor(e);
+            if (l.qe >= n.Le) {
+                markNode(t);
+                markHeap(n);
+                updateIfNecessary(l);
+            }
+            const i = l.qe;
+            // parent check is shallow, might need to be recursive
+                        if (i >= t.qe && e.He !== t) {
+                t.qe = i + 1;
+            }
+        }
+    }
+    // Mark-only pending never suspends the reader (#2886): an affects() mark is
+    // a promise of change, not an absence of value, so a derived node whose only
+    // pending sources are mark sentinels keeps its real value readable —
+    // pendingness reaches readers through verdicts (isPending), not throws.
+    // (`activeAffectsMarks` gates the source scan off the mark-free hot path;
+    // sentinels can't survive in pending sources past their last release.)
+        if (l.i & STATUS_PENDING && !(activeAffectsMarks !== 0 && GlobalQueue.$(l))) {
+        if (t && !(stale && l.ve && activeTransition !== l.ve)) {
+            // Per-lane suspension lives with the engine (a non-null lane implies it
+            // is installed): under a lane, only same-lane pending async without an
+            // active override throws.
+            if (currentOptimisticLane === null || GlobalQueue.ht(l)) {
+                if (!tracking && e !== t) link(e, t);
+                throw l.k;
+            }
+        } else if (t && l !== e && l.i & STATUS_UNINITIALIZED) {
+            if (!tracking && e !== t) link(e, t);
+            throw l.k;
+        } else if (!t && l.i & STATUS_UNINITIALIZED) {
+            throw l.k;
+        }
+    }
+    if (e.xe && e.i & STATUS_ERROR) {
+        // Only a genuine reactive re-read may retry an errored async source:
+        // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
+        // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
+        // - el._time < clock: only on a later cycle than the one the error was found
+        if (tracking && !pendingCheckActive && e.Ie < clock) {
+            recompute(e);
+            return read(e);
+        } else throw e.k;
+    }
+    if (snapshotCaptureActive && t && t.U & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.Ye;
+        if (n !== undefined) {
+            const i = n === NO_SNAPSHOT ? undefined : n;
+            const l = e.ge !== NOT_PENDING ? e.ge : e.Ue;
+            if (l !== i) t.u |= REACTIVE_SNAPSHOT_STALE;
+            return i;
+        }
+    }
+    if (e.be !== undefined && e.be !== NOT_PENDING) {
+        // An active override means the engine is installed (A17: the override IS
+        // the value for every reader — that check itself stays right here).
+        if (t && stale && GlobalQueue.gt(e)) return e.Ue;
+        return e.be;
+    }
+    // Entanglement gate: a reader recomputing under an optimistic lane that reads
+    // a pending mid-transition write sees the committed value. Projection-store
+    // manual writes use the firewall's manual-write flag to opt into this path.
+    // Async drivers are not under an optimistic lane and so bypass this, reading
+    // _pendingValue for correct fetching. The sub is recorded for replay at commit
+    // so it re-runs with the new committed view. (Gate details live with the
+    // engine — a non-null lane implies it is installed.)
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Dt(e, l, t)) {
+        return e.Ue;
+    }
+    // In optimistic lane context, return _value for optimistic/lane-assigned signals
+    // and for regular signals in stale mode (render effects). Non-stale readers (user
+    // effects) see _pendingValue so that latest() and direct reads stay consistent.
+    // (The lane-context clause lives with the engine.)
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.kt(e, l, t) || e.ge === NOT_PENDING || stale && e.ve && activeTransition !== e.ve ? e.Ue : e.ge;
+    // Record that this isPending() probe observed the fresh pending value, so
+    // the probe doesn't pair "pending" with the new value (#2831).
+        if (pendingCheckActive) GlobalQueue.vt(e, u);
+    if (!t && l === e && typeof n.xe === "function" && e.U & CONFIG_AUTO_DISPOSE && !(l.i & STATUS_PENDING) && !e.p) {
+        unobserved(e);
+    }
+    return u;
+}
+
+function setSignal(e, t) {
+    if (e.ve && activeTransition !== e.ve) globalQueue.initTransition(e.ve);
+    // The optimistic write path lives with the engine: only optimisticSignal /
+    // optimisticComputed callers and optimistic store nodes carry an
+    // _overrideValue slot, and every module that creates one installs the
+    // engine first.
+        if (e.be !== undefined && !projectionWriteActive) return GlobalQueue.bt(e, t);
+    const n = e.ge === NOT_PENDING ? e.Ue : e.ge;
+    if (typeof t === "function") t = t(n);
+    // Uninitialized check first: the first commit has no previous value, so the
+    // user comparator must not run against `undefined` (matches recompute).
+        const i = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(n, t);
+    if (!i) return t;
+    if (e.ge === NOT_PENDING) queuePendingNode(e);
+    e.ge = t;
+    GlobalQueue._e !== null && GlobalQueue._e(e, t);
+    e.Ie = clock;
+    insertSubs(e);
+    schedule();
+    return t;
+}
+
+/**
+ * Suppresses automatic recomputation of `el` until the scheduler drains. Used
+ * when a manual write should win over dependency changes queued in the same
+ * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
+ * computeds don't commit values, but they still need the same end-of-tick
+ * cleanup point.
+ */ function suppressComputedRecompute(e) {
+    deleteFromHeap(e, queueFor(e));
+    if (!(e.u & REACTIVE_MANUAL_WRITE) && e.ge === NOT_PENDING) {
+        queuePendingNode(e);
+        schedule();
+    }
+    e.u = e.u & -4 | REACTIVE_MANUAL_WRITE;
+}
+
+/**
+ * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
+ * `setSignal`, but also cancels any pending recompute of the memo so the
+ * manual value wins over a value that would otherwise be produced by an
+ * upstream change in the same tick.
+ */ function setMemo(e, t) {
+    const n = setSignal(e, t);
+    suppressComputedRecompute(e);
+    return n;
+}
+
+/**
+ * Executes `fn` with the given `owner` set as the current owner. Any reactive
+ * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
+ * `cleanup`, etc.) created inside `fn` are attached to that owner, so they
+ * are disposed when the owner is disposed.
+ *
+ * The classic pattern: capture the current owner with `getOwner()` inside a
+ * component, then re-enter it from a callback (event handler, async resolve,
+ * setTimeout) so disposables created in the callback get cleaned up with the
+ * component.
+ *
+ * @example
+ * ```ts
+ * function delayed<T>(ms: number, fn: () => T) {
+ *   const owner = getOwner();
+ *   setTimeout(() => runWithOwner(owner, fn), ms);
+ * }
+ * ```
+ */ function runWithOwner(e, t) {
+    const n = context;
+    const i = tracking;
+    context = e;
+    tracking = false;
+    try {
+        return t();
+    } finally {
+        context = n;
+        tracking = i;
+    }
+}
+
+function staleValues(e, t = true) {
+    const n = stale;
+    stale = t;
+    try {
+        return e();
+    } finally {
+        stale = n;
+    }
+}
+
+/**
+ * Invalidates one reactive source, forcing it to re-execute even if its inputs
+ * haven't changed.
+ *
+ * Pass either a Solid-created accessor or a projected store created from
+ * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
+ * write-like invalidation operation: it does not read the target's value, and
+ * refreshing a plain signal accessor is a no-op.
+ *
+ * Use it to invalidate cached async values (e.g. force a re-fetch) without
+ * tearing the consumer down.
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // Re-fetch on demand
+ * <button onClick={() => refresh(user)}>Reload</button>
+ * ```
+ */ function refresh(e) {
+    const t = e?.[$REFRESH];
+    if (!t) {
+        return;
+    }
+    if (typeof t.xe === "function" && !(t.u & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+        // A refresh with no value-change dirt already queued is a re-ask of the
+        // same question: mark it so the recompute classifies any resulting
+        // pending window as quiet (not pending). If the node is already dirty
+        // from a real input change, the question changed — don't mark.
+        // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
+        // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
+        // change followed by refresh() must not be laundered into a quiet re-ask.
+        if (!(t.u & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.u |= REACTIVE_REASK;
+            armReaskClear();
+        }
+        t.u = t.u & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        insertIntoHeap(t, queueFor(t));
+        schedule();
+    }
+}
+
+export { clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, suppressComputedRecompute, tracking, untrack };