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

package/dist/prod/core/async.js

@@ -0,0 +1,380 @@
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
+
+import { untrack, context, setSignal } from "./core.js";
+
+import "./invariants.js";
+
+import { NotReadyError, StatusError } from "./error.js";
+
+import { trimStaleDeps } from "./graph.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane } from "./lanes.js";
+
+import { cleanup } from "./owner.js";
+
+import { globalQueue, GlobalQueue, clock, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
+
+// The lazily-created Set is the ONE container for pending sources. Its
+// predecessor — a singular slot promoted to a Set on the second source —
+// created dual state whose migration invariant was easy to break: a third
+// overlapping source landed beside the Set and removePendingSource refused
+// to clear it, stranding the Set members' pending forever (#2893).
+function addPendingSource(e, n) {
+    if (e.m?.has(n)) return false;
+    (e.m ??= new Set).add(n);
+    return true;
+}
+
+function removePendingSource(e, n) {
+    if (!e.m?.delete(n)) return false;
+    if (e.m.size === 0) e.m = undefined;
+    return true;
+}
+
+function clearPendingSources(e) {
+    e.m?.clear();
+    e.m = undefined;
+}
+
+function setPendingError(e, n, r) {
+    if (!n) {
+        e.k = null;
+        return;
+    }
+    if (r instanceof NotReadyError && r.source === n) {
+        e.k = r;
+        return;
+    }
+    const t = e.k;
+    if (!(t instanceof NotReadyError) || t.source !== n) {
+        e.k = new NotReadyError(n);
+    }
+}
+
+function forEachDependent(e, n) {
+    for (let r = e.p; r !== null; r = r.de) n(r.Ee, r);
+    // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
+        for (let r = e.G ?? null; r !== null; r = r.Ne) {
+        for (let e = r.p; e !== null; e = e.de) n(e.Ee, e);
+    }
+}
+
+// Queue a node to re-run on the next flush (used both when a pending source
+// settles and when an `isPending` observer must re-evaluate after a real error):
+// shared scheduling helper in heap.ts (tracked effects bypass the heap).
+function settlePendingSource(e, n = e, 
+// Mark release runs inside queue finalization: companion writes must go
+// through the settlement snap (committed), because a setSignal here would
+// open a fresh transition-scoped override window that nothing reverts.
+r = false) {
+    let t = false;
+    const o = new Set;
+    // Companion updates no-op without the verdict layer (null hooks).
+        const u = r ? GlobalQueue.R : GlobalQueue.P;
+    const settle = e => {
+        if (o.has(e) || !removePendingSource(e, n)) return;
+        o.add(e);
+        e.Ie = clock;
+        const r = e.m?.values().next().value;
+        if (r) {
+            setPendingError(e, r);
+            u !== null && u(e);
+        } else {
+            e.i &= ~STATUS_PENDING;
+            setPendingError(e);
+            u !== null && u(e);
+            if (e.Re) {
+                enqueueSub(e);
+                t = true;
+            }
+            e.Re = false;
+        }
+        forEachDependent(e, settle);
+    };
+    forEachDependent(e, settle);
+    if (t) schedule();
+}
+
+// Object-thenable detection (Promises/A+ shape).
+function isThenable(e) {
+    return e != null && typeof e === "object" && typeof e.then === "function";
+}
+
+function handleAsync(e, n, r) {
+    let t = false;
+    let o = false;
+    if (typeof n === "object" && n !== null) {
+        untrack(() => {
+            t = n[Symbol.asyncIterator];
+            o = !t && isThenable(n);
+        });
+    }
+    if (!o && !t) {
+        e.Ae = null;
+        return n;
+    }
+    e.Ae = n;
+    let u;
+    const handleError = r => {
+        if (e.Ae !== n) return;
+        globalQueue.initTransition(resolveTransition(e));
+        // NotReadyError from rejected promises should be treated as pending, not error
+                notifyStatus(e, r instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, r);
+        e.Ie = clock;
+    };
+    const asyncWrite = (t, o) => {
+        if (e.Ae !== n) return;
+        // If the node was dirtied by a newer write (optimistic override or regular),
+        // skip this stale async result — the upcoming flush will recompute the node
+        // with the new value, creating a fresh Promise that supersedes this one.
+                if (e.u & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+        globalQueue.initTransition(resolveTransition(e));
+        const u = !!(e.i & STATUS_UNINITIALIZED);
+        trimStaleDeps(e);
+        clearStatus(e);
+        const l = resolveLane(e);
+        if (l) l.Pe.delete(e);
+        if (r) {
+            r(t);
+            if (u) clearStatus(e, true);
+        } else if (e.be !== undefined) {
+            // Optimistic node — resting OR covered by an active override — holds
+            // through the shared pending-node path, exactly like a plain async memo,
+            // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
+            // _value happens on this value's OWN transition schedule (A18 as
+            // re-ruled 2026-07-07: _value only changes at commit points). With an
+            // override active the hold and its eventual commit are unobservable
+            // (A17 — every reader sees the override); the revert reveals whatever
+            // has committed by then, so corrections reveal atomically with their
+            // transition rather than escaping it.
+            if (e.ge === NOT_PENDING) queuePendingNode(e);
+            e.ge = t;
+            // The hold is a companion-visible write like any other (A13/A19): the
+            // clearStatus() above computed its verdict before the hold existed, so
+            // isPending must re-derive (the value is not final until commit — V1)
+            // and latest() must see the fresh in-flight value (V2). Subscribers are
+            // only notified when the hold is visible to them: under an active
+            // override every reader sees the override (A17), so waking subs would
+            // re-show an unchanged view — the revert is the notification point.
+                        GlobalQueue._e !== null && GlobalQueue._e(e, t);
+            if (!hasActiveOverride(e)) insertSubs(e);
+            e.Ie = clock;
+        } else if (l) {
+            // Route through lane's effect queue for independent flushing
+            const n = e.De;
+            const r = e.Ue;
+            const o = e.Ge;
+            try {
+                if (!n && u || !o || !o(t, r)) {
+                    e.Ue = t;
+                    e.Ie = clock;
+                    // The latest() shadow write gives latest() effects independent lanes; the
+                    // _pendingSignal update is a no-op repeat of the clearStatus() call above
+                    // (computePendingState doesn't read _value).
+                                        GlobalQueue._e !== null && GlobalQueue._e(e, t);
+                    insertSubs(e, true);
+                }
+            } catch (n) {
+                // A user comparator throwing during async resolution has no caller to
+                // surface to (we're in promise machinery) — route it through the node's
+                // error status so boundaries contain it instead of an unhandled
+                // rejection (#2837).
+                notifyStatus(e, STATUS_ERROR, n);
+            }
+        } else {
+            try {
+                setSignal(e, () => t);
+            } catch (n) {
+                // Same containment as above: setSignal's comparator throw is the only
+                // pre-commit failure here, and there is no user callsite to throw to.
+                notifyStatus(e, STATUS_ERROR, n);
+            }
+        }
+        settlePendingSource(e);
+        schedule();
+        flush();
+        o?.();
+    };
+    if (o) {
+        let r = false, t = false, o, l = true;
+        n.then(e => {
+            if (l) {
+                u = e;
+                r = true;
+            } else asyncWrite(e);
+        }, e => {
+            if (l) {
+                o = e;
+                t = true;
+            } else handleError(e);
+        });
+        l = false;
+        if (t) {
+            // Settle through the same status path an async rejection uses, then
+            // unwind the in-progress synchronous read so the errored node isn't
+            // momentarily read as `undefined`.
+            handleError(o);
+            throw o;
+        } else if (!r) {
+            globalQueue.initTransition(resolveTransition(e));
+            throw new NotReadyError(context);
+        }
+    }
+    if (t) {
+        const r = n[Symbol.asyncIterator]();
+        let t = false;
+        let o = false;
+        let l = true;
+        cleanup(() => {
+            if (o) return;
+            o = true;
+            try {
+                const e = r.return?.();
+                if (isThenable(e)) e.then(undefined, () => {});
+            } catch {}
+        });
+        const iterate = () => {
+            let i, s, f = false, a = false, c = true;
+            r.next().then(r => {
+                if (c) {
+                    i = r;
+                    f = true;
+                    if (r.done) o = true;
+                } else if (e.Ae !== n) {
+                    return;
+                } else if (!r.done) {
+                    t = true;
+                    asyncWrite(r.value, iterate);
+                } else {
+                    o = true;
+                    if (t) {
+                        schedule();
+                        flush();
+                    } else {
+                        // Empty completion settles like the immediately-done sync path.
+                        asyncWrite(undefined);
+                    }
+                }
+            }, r => {
+                if (c) {
+                    s = r;
+                    a = true;
+                } else if (e.Ae === n) {
+                    o = true;
+                    handleError(r);
+                }
+            });
+            c = false;
+            if (a) {
+                // Match the promise branch, but only rethrow during the initial read.
+                o = true;
+                handleError(s);
+                if (l) throw s;
+                return true;
+            }
+            if (f && !i.done) {
+                u = i.value;
+                t = true;
+                return iterate();
+            }
+            return f && i.done;
+        };
+        const i = iterate();
+        // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
+                l = false;
+        if (!t && !i) {
+            globalQueue.initTransition(resolveTransition(e));
+            throw new NotReadyError(context);
+        }
+    }
+    return u;
+}
+
+function clearStatus(e, n = false) {
+    if (e.m) clearPendingSources(e);
+    if (e.Re) e.Re = false;
+    // The pending window is over; its quiet classification dies with it.
+    // (Unconditional: _reask is baked into the node literals, so this is a
+    // plain store to an existing slot — no shape change.)
+        e.A = false;
+    e.i = n ? 0 : e.i & STATUS_UNINITIALIZED;
+    if (e.k) setPendingError(e);
+    // Update pending signal for isPending() reactivity (companions only exist
+    // once the verdict layer created them, which installs the hooks).
+        if (e.ye || e.pe) GlobalQueue.P(e);
+    if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
+    if (e.C) e.C();
+}
+
+function notifyStatus(e, n, r, t, o) {
+    // Wrap regular errors to track source node
+    if (n === STATUS_ERROR && !(r instanceof StatusError) && !(r instanceof NotReadyError)) r = new StatusError(e, r);
+    const u = n === STATUS_PENDING && r instanceof NotReadyError ? r.source : undefined;
+    // Mark-sourced propagation must not capture subscribers into the marking
+    // action's transaction (#2893): they carry no held value needing a
+    // transition-scheduled commit, and stamping `_transition` on them would
+    // freeze unrelated writes that share a downstream memo until the action
+    // settles. Real async keeps queuing (its commits ride the transition).
+        const l = u?.l !== undefined;
+    // A real error is a settled verdict a mark must not erase (#2893): landing
+    // STATUS_PENDING here would clobber `_error` with the sentinel's
+    // NotReadyError, and unlike real async there is no arriving value whose
+    // recompute would surface the error again. Descent stops too — everything
+    // downstream holds the propagated error for the same reason.
+        if (l && e.i & STATUS_ERROR) return;
+    const i = u === e;
+    const s = n === STATUS_PENDING && e.be !== undefined && !i;
+    const f = s && hasActiveOverride(e);
+    if (!t) {
+        if (n === STATUS_PENDING && u) {
+            addPendingSource(e, u);
+            e.i = STATUS_PENDING | e.i & STATUS_UNINITIALIZED;
+            // Preserve the current source on this propagation so render-effect notification
+            // can register every distinct pending source with the transition.
+                        setPendingError(e, u, r);
+        } else {
+            clearPendingSources(e);
+            e.i = n | (n !== STATUS_ERROR ? e.i & STATUS_UNINITIALIZED : 0);
+            e.k = r;
+        }
+        GlobalQueue.P !== null && GlobalQueue.P(e);
+        if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
+    }
+    if (o && !t) {
+        assignOrMergeLane(e, o);
+    }
+    const a = t || f;
+    const c = t || s ? undefined : o;
+    if (e.C) {
+        if (t && n === STATUS_PENDING) {
+            return;
+        }
+        if (a) {
+            e.C(n, r);
+        } else {
+            e.C();
+        }
+        return;
+    }
+    forEachDependent(e, (e, t) => {
+        e.Ie = clock;
+        if (n === STATUS_PENDING && u && !e.m?.has(u) || n !== STATUS_PENDING && (e.k !== r || e.m)) {
+            // A pending-observer link is the subscription an `isPending` read created.
+            // It exists so the observer re-runs when the source settles, but it must
+            // not carry a real (non-NotReadyError) error — the synchronous `isPending`
+            // read swallows those, and the async path must match. Re-run the observer
+            // so `isPending` re-evaluates (to not-pending) instead of forwarding.
+            if (t.Qe && n !== STATUS_PENDING && !(r instanceof NotReadyError)) {
+                enqueueSub(e);
+                schedule();
+                return;
+            }
+            if (!a && !l && !e.ve) queuePendingNode(e);
+            notifyStatus(e, n, r, a, c);
+        }
+    });
+}
+
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, setPendingError, settlePendingSource };

package/dist/prod/core/constants.js

@@ -0,0 +1,92 @@
+const REACTIVE_NONE = 0;
+
+const REACTIVE_CHECK = 1 << 0;
+
+const REACTIVE_DIRTY = 1 << 1;
+
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+
+const REACTIVE_IN_HEAP = 1 << 3;
+
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+
+const REACTIVE_ZOMBIE = 1 << 5;
+
+const REACTIVE_DISPOSED = 1 << 6;
+
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+
+const REACTIVE_SNAPSHOT_STALE = 1 << 8;
+
+const REACTIVE_LAZY = 1 << 9;
+
+const REACTIVE_MANUAL_WRITE = 1 << 10;
+
+/**
+ * The pending recompute is a re-ask of the same question: `refresh()` dirtied
+ * the node while no tracked input changed value. Cleared whenever a real
+ * value-change notification arrives (`insertSubs`), and consumed by
+ * `recompute` into the node's `_reask` classification — a quiet (re-ask)
+ * pending window does not read as pending (question-scoped pending model).
+ */ const REACTIVE_REASK = 1 << 11;
+
+// Static configuration bits packed into Owner/Computed/Signal _config.
+const CONFIG_OWNED_WRITE = 1 << 0;
+
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+
+const CONFIG_TRANSPARENT = 1 << 2;
+
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+
+const CONFIG_AUTO_DISPOSE = 1 << 5;
+
+const CONFIG_SYNC = 1 << 6;
+
+const STATUS_PENDING = 1 << 0;
+
+const STATUS_ERROR = 1 << 1;
+
+const STATUS_UNINITIALIZED = 1 << 2;
+
+const EFFECT_RENDER = 1;
+
+const EFFECT_USER = 2;
+
+const EFFECT_TRACKED = 3;
+
+const NOT_PENDING = {};
+
+const NO_SNAPSHOT = {};
+
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */ const OVERRIDE_UNDEFINED = {};
+
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */ function unwrapOverride(E) {
+    return E === OVERRIDE_UNDEFINED ? undefined : E;
+}
+
+const STORE_SNAPSHOT_PROPS = "sp";
+
+const SUPPORTS_PROXY = typeof Proxy === "function";
+
+const defaultContext = {};
+
+/**
+ * Brand symbol used by `Refreshable<T>` values (projection stores, async
+ * memos) to expose their underlying computation to `refresh()`. Not part of
+ * the user-facing API.
+ *
+ * @internal
+ */ const $REFRESH = Symbol("refresh");
+
+export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };

package/dist/prod/core/context.js

@@ -0,0 +1,67 @@
+import { NoOwnerError, ContextNotFoundError } from "./error.js";
+
+import { getOwner } from "./owner.js";
+
+/**
+ * Context provides a form of dependency injection. It is used to save from needing to pass
+ * data as props through intermediate components. This function creates a new context object
+ * that can be used with `getContext` and `setContext`.
+ *
+ * A default value can be provided here which will be used when a specific value is not provided
+ * via a `setContext` call.
+ */ function createContext(e, t) {
+    return {
+        id: Symbol(t),
+        defaultValue: e
+    };
+}
+
+/**
+ * Low-level owner-targeted context read. The user-facing read API is
+ * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
+ * cross-package wiring (e.g. hydration-aware context plumbing).
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ *
+ * @internal
+ */ function getContext(e, t = getOwner()) {
+    if (!t) {
+        throw new NoOwnerError;
+    }
+    const n = hasContext(e, t) ? t.we[e.id] : e.defaultValue;
+    if (isUndefined(n)) {
+        throw new ContextNotFoundError;
+    }
+    return n;
+}
+
+/**
+ * Low-level owner-targeted context write. The user-facing API is
+ * `createContext` (in `solid-js`); its provider component wraps this
+ * primitive. Exposed here for cross-package wiring.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ *
+ * @internal
+ */ function setContext(e, t, n = getOwner()) {
+    if (!n) {
+        throw new NoOwnerError;
+    }
+    // We're creating a new object to avoid child context values being exposed to parent owners. If
+    // we don't do this, everything will be a singleton and all hell will break lose.
+        n.we = {
+        ...n.we,
+        [e.id]: isUndefined(t) ? e.defaultValue : t
+    };
+}
+
+function hasContext(e, t) {
+    return !isUndefined(t?.we[e.id]);
+}
+
+function isUndefined(e) {
+    return typeof e === "undefined";
+}
+
+export { createContext, getContext, setContext };