@solidjs/signals 2.0.0-beta.8 → 2.0.0-rc.0

package/dist/prod/core/dev.js

@@ -0,0 +1,3 @@
+const DEV = undefined;
+
+export { DEV };

package/dist/prod/core/effect.js

@@ -0,0 +1,145 @@
+import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
+
+import { createEffectNode, recompute, computed, staleValues } from "./core.js";
+
+import { unwrapStatusError, StatusError } from "./error.js";
+
+import { GlobalQueue, haltReactivity } from "./scheduler.js";
+
+/**
+ * Effects are the leaf nodes of our reactive graph. When their sources change, they are
+ * automatically added to the queue of effects to re-execute, which will cause them to fetch their
+ * sources and recompute
+ */ function effect(t, E, e, R) {
+    const r = !!R?.user;
+    const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
+    recompute(f, true);
+    !R?.defer && (f.Re === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f));
+}
+
+function notifyEffectStatus(t, E) {
+    // Use passed values if provided, otherwise read from node
+    const e = t !== undefined ? t : this.S;
+    const R = E !== undefined ? E : this._;
+    if (e & STATUS_ERROR) {
+        this.C.notify(this, STATUS_PENDING, 0);
+        if (this.Re === EFFECT_USER) {
+            // The error handler is the error arm of the effect phase (#2840 ruling):
+            // queue it like the effect function. It runs in the same imperative,
+            // writable scope, throws escalate the same way, and a held transition
+            // (or optimistic lane) defers it exactly as it defers the success arm.
+            // No payload is queued — the node already carries `_statusFlags`/`_error`,
+            // and the runner dispatches on them, so a recovery before the effect
+            // phase takes the success arm instead. Blocked forwards (explicit
+            // `status` arg without node-state writes) don't queue: the status
+            // re-propagates unblocked at commit.
+            if (this.S & STATUS_ERROR) {
+                this.Je = true;
+                this.C.enqueue(this.Re, this.Xe ??= runEffect.bind(null, this));
+            }
+            return;
+        }
+        if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(unwrapStatusError(R));
+            throw R;
+        }
+    } else if (this.Re === EFFECT_RENDER) {
+        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
+    }
+}
+
+function runEffect(t) {
+    if (!t.Je || t.se & REACTIVE_DISPOSED) return;
+    // Error arm (#2840), user effects only: a compute-phase error that is still
+    // the node's settled state at effect time runs the bundle's error handler in
+    // this same imperative, writable scope. Unwrap the StatusError used for
+    // source tracking — user code gets the error it threw, as boundaries do. No
+    // handler: log and keep the system alive (the run was skipped). A handler
+    // (or logging) consumes the error; a handler throw falls to the shared
+    // catch below and escalates boundary-or-halt like any effect-phase throw.
+    // Render effects bypass: their errors route to boundaries synchronously in
+    // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
+    // same flush must not be hijacked by a later-arriving error status.
+        if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
+        const E = unwrapStatusError(t._);
+        t._t = t.Ue;
+        t.Je = false;
+        try {
+            t.Et ? t.Et(E, () => {
+                const E = t.Tt;
+                t.Tt = undefined;
+                E?.();
+            }) : console.error(E);
+        } catch (E) {
+            if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+                haltReactivity(E);
+                throw E;
+            }
+        }
+        return;
+    }
+    const E = t.Tt;
+    t.Tt = undefined;
+    try {
+        E?.();
+        const e = t.ft(t.Ue, t._t);
+        if (false && e !== undefined && typeof e !== "function") ;
+        // The final cleanup is invoked by disposeChildren at true disposal.
+                t.Tt = e;
+    } catch (E) {
+        t._ = new StatusError(t, E);
+        t.S |= STATUS_ERROR;
+        if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(E);
+            throw E;
+        }
+    } finally {
+        t._t = t.Ue;
+        t.Je = false;
+    }
+}
+
+GlobalQueue.et = runEffect;
+
+/**
+ * Internal tracked effect - bypasses heap, goes directly to effect queue.
+ * Runs as a leaf owner: child primitives and onCleanup are forbidden (false throws).
+ * Uses stale reads.
+ */ function trackedEffect(t, E) {
+    const run = () => {
+        if (!e.Je || e.se & REACTIVE_DISPOSED) return;
+        try {
+            e.Je = false;
+            recompute(e);
+        } finally {}
+    };
+    const e = computed(() => {
+        const E = e.Tt;
+        e.Tt = undefined;
+        E?.();
+        const R = staleValues(t);
+        e.Tt = R;
+    }, {
+        ...E,
+        lazy: true
+    });
+    e.Tt = undefined;
+    e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    e.Je = true;
+    e.Re = EFFECT_TRACKED;
+    e.i = (t, E) => {
+        const R = t !== undefined ? t : e.S;
+        if (R & STATUS_ERROR) {
+            e.C.notify(e, STATUS_PENDING, 0);
+            const t = E !== undefined ? E : e._;
+            if (!e.C.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+                haltReactivity(unwrapStatusError(t));
+                throw t;
+            }
+        }
+    };
+    e.Ft = run;
+    e.C.enqueue(EFFECT_USER, run);
+}
+
+export { effect, trackedEffect };

package/dist/prod/core/error.js

@@ -0,0 +1,68 @@
+/**
+ * Thrown by a tracked read whose value is currently pending (an async memo /
+ * `createSignal(asyncFn)` / projection / store derivation that hasn't settled
+ * yet). Surfacing through the reactive graph is what suspends the consumer
+ * scope — the nearest enclosing `<Loading>` boundary catches the throw and
+ * renders its fallback until the source resolves.
+ *
+ * App code rarely catches this directly; `<Loading>` is the canonical
+ * handler. The error type is exposed for advanced cases — e.g. interop layers
+ * that bridge Solid's pending-throw protocol to a different async strategy,
+ * or tests that want to assert on the suspension shape.
+ *
+ * @example
+ * ```ts
+ * // Advanced: distinguish "not ready yet" from a real error in custom
+ * // boundary plumbing. App code should rely on `<Loading>` / `<Errored>`.
+ * try {
+ *   const value = readReactiveSource();
+ * } catch (err) {
+ *   if (err instanceof NotReadyError) throw err; // re-throw to suspend
+ *   reportError(err);
+ * }
+ * ```
+ */
+class NotReadyError extends Error {
+    source;
+    constructor(r) {
+        // Control-flow throw: it happens on every read of a pending source, so in
+        // production skip V8's eager stack capture (proportional to stack depth —
+        // real cost under SSR) by zeroing the V8-specific stackTraceLimit around
+        // super(). Dev keeps the stack for debuggability; non-V8 engines (no
+        // stackTraceLimit) take the plain path.
+        const o = Error;
+        const t = o.stackTraceLimit;
+        if (t !== undefined) o.stackTraceLimit = 0;
+        super();
+        if (t !== undefined) o.stackTraceLimit = t;
+        this.source = r;
+    }
+}
+
+class StatusError extends Error {
+    source;
+    constructor(r, o) {
+        super(o instanceof Error ? o.message : String(o), {
+            cause: o
+        });
+        this.source = r;
+    }
+}
+
+/** Return the user's error from an internal status wrapper. */ function unwrapStatusError(r) {
+    return r instanceof StatusError ? r.cause : r;
+}
+
+class NoOwnerError extends Error {
+    constructor() {
+        super("");
+    }
+}
+
+class ContextNotFoundError extends Error {
+    constructor() {
+        super("");
+    }
+}
+
+export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, unwrapStatusError };

package/dist/prod/core/external.js

@@ -0,0 +1,98 @@
+import { signal, setSignal, read } from "./core.js";
+
+import { cleanup } from "./owner.js";
+
+import { GlobalQueue } from "./scheduler.js";
+
+let externalSourceConfig = null;
+
+/**
+ * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
+ * into Solid's tracking graph. Every computation will be wrapped so that the
+ * external library can track its own dependencies alongside Solid's.
+ *
+ * Multiple calls pipe together: each new factory wraps the previous one.
+ *
+ * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
+ *   call trigger when external deps change. Return `{ track, dispose }`.
+ * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
+ *
+ * @example
+ * ```ts
+ * // Bridge an external "subscribe / notify" library into Solid's graph.
+ * // `factory` wraps every Solid compute so the external library can attach
+ * // its own dependency tracker; `trigger` re-runs the compute on external
+ * // change. `untrack` mirrors Solid's `untrack()` into the external library
+ * // so that reads inside `untrack(...)` don't get tracked twice.
+ * enableExternalSource({
+ *   factory: (compute, trigger) => {
+ *     const sub = externalLib.subscribe(trigger);
+ *     return {
+ *       track: prev => externalLib.run(() => compute(prev)),
+ *       dispose: () => sub.unsubscribe()
+ *     };
+ *   },
+ *   untrack: fn => externalLib.untracked(fn)
+ * });
+ * ```
+ */
+// Wires a freshly created computed through the active external-source bridge.
+// Lives here (installed on GlobalQueue while a config is active) rather than
+// inline in core: esbuild cannot literal-track the mutable config binding the
+// way rollup does, so an inline `if (externalSourceConfig)` block ships in
+// every bundle even though only enableExternalSource() can make it reachable.
+function wireExternalSource(e) {
+    const n = signal(undefined, {
+        equals: false,
+        ownedWrite: true
+    });
+    const r = externalSourceConfig.factory(e.ce, () => {
+        setSignal(n, undefined);
+    });
+    cleanup(() => r.dispose());
+    e.ce = e => {
+        read(n);
+        return r.track(e);
+    };
+}
+
+function externalUntrack(e) {
+    return externalSourceConfig.untrack(e);
+}
+
+// The hooks mirror the config's liveness exactly (installed on enable,
+// removed on reset) so core's null checks stay equivalent to the old
+// `externalSourceConfig` truthiness checks.
+function syncExternalHooks() {
+    GlobalQueue.It = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.St = externalSourceConfig ? externalUntrack : null;
+}
+
+function enableExternalSource(e) {
+    const {factory: n, untrack: r = e => e()} = e;
+    if (externalSourceConfig) {
+        const {factory: e, untrack: o} = externalSourceConfig;
+        externalSourceConfig = {
+            factory: (r, o) => {
+                const t = e(r, o);
+                const a = n(e => t.track(e), o);
+                return {
+                    track: e => a.track(e),
+                    dispose() {
+                        a.dispose();
+                        t.dispose();
+                    }
+                };
+            },
+            untrack: e => o(() => r(e))
+        };
+    } else {
+        externalSourceConfig = {
+            factory: n,
+            untrack: r
+        };
+    }
+    syncExternalHooks();
+}
+
+export { enableExternalSource, externalSourceConfig };

package/dist/prod/core/graph.js

@@ -0,0 +1,104 @@
+import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, STATUS_PENDING, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+
+import { deleteFromHeap, queueFor } from "./heap.js";
+
+import { disposeChildren } from "./owner.js";
+
+import "./scheduler.js";
+
+// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
+function unlinkSubs(l) {
+    const n = l.it;
+    const e = l.nt;
+    const u = l.le;
+    const s = l.ll;
+    if (u !== null) u.ll = s; else n.rt = s;
+    if (s !== null) s.le = u; else {
+        n.o = u;
+        if (u === null) {
+            n.ut?.();
+            // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+            // A pending node is exempt: its in-flight async work (or the
+            // transition holding it) is an observer — tearing down would orphan
+            // the work and re-execute it on the next read. The settle path runs
+            // this same last-one-out check when that observer releases (the
+            // untracked-read dispose in core.ts guards on pending identically).
+                        const l = n;
+            l.ce && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
+        }
+    }
+    return e;
+}
+
+function trimStaleDeps(l) {
+    const n = l.Ye;
+    let e = n !== null ? n.nt : l.tt;
+    if (e !== null) {
+        do {
+            e = unlinkSubs(e);
+        } while (e !== null);
+        if (n !== null) n.nt = null; else l.tt = null;
+    }
+}
+
+function unobserved(l) {
+    deleteFromHeap(l, queueFor(l));
+    let n = l.tt;
+    while (n !== null) {
+        n = unlinkSubs(n);
+    }
+    l.tt = null;
+    l.Ye = null;
+    disposeChildren(l, true);
+}
+
+// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
+function link(l, n, e = false) {
+    // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
+    // read (`isPending(() => x())`) beside a value read of the same dep must
+    // not relabel the value dependency as probe-only — the value read is what
+    // real-error propagation and affects() coverage key off, regardless of
+    // read order within the computation.
+    const u = n.Ye;
+    if (u !== null && u.it === l) {
+        u.Ge &&= e;
+        return;
+    }
+    let s = null;
+    const t = n.se & REACTIVE_RECOMPUTING_DEPS;
+    if (t) {
+        s = u !== null ? u.nt : n.tt;
+        if (s !== null && s.it === l) {
+            s.nl = n.Ze;
+            n.Ye = s;
+            // First touch of this pass: the previous pass's label is stale.
+                        s.Ge = e;
+            return;
+        }
+    }
+    // A link stamped with the current pass generation was created or reused
+    // in-order during this recompute, i.e. it already sits in the validated
+    // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
+    // (the old alien-signals `isValidLink` walk, O(n²) when a computation
+    // re-reads earlier deps non-consecutively, e.g. store leaf reads).
+        const i = l.rt;
+    if (i !== null && i.fe === n && (!t || i.nl === n.Ze)) {
+        // Gen-matched during a recompute = repeat touch this pass (AND); outside
+        // a recompute there is no pass boundary, so the latest read labels it.
+        if (t) i.Ge &&= e; else i.Ge = e;
+        return;
+    }
+    const o = n.Ye = l.rt = {
+        it: l,
+        fe: n,
+        nt: s,
+        ll: i,
+        le: null,
+        nl: n.Ze,
+        Ge: e
+    };
+    if (u !== null) u.nt = o; else n.tt = o;
+    if (i !== null) i.le = o; else l.o = o;
+}
+
+export { link, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -0,0 +1,140 @@
+import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
+
+import { zombieQueue, dirtyQueue } from "./scheduler.js";
+
+/** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
+    return e.se & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+}
+
+/**
+ * Schedule one subscriber to re-run on the next flush: tracked effects bypass
+ * the heap and go directly to their effect queue; everything else is inserted
+ * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ */ function enqueueSub(e) {
+    if (e.Re === EFFECT_TRACKED) {
+        const E = e;
+        if (!E.Je) {
+            E.Je = true;
+            E.C.enqueue(EFFECT_USER, E.Ft);
+        }
+        return;
+    }
+    const E = queueFor(e);
+    if (E.Ve > e.xe) E.Ve = e.xe;
+    insertIntoHeap(e, E);
+}
+
+function actualInsertIntoHeap(e, E) {
+    const t = (e.ke?.Nt ? e.ke.dt?.xe : e.ke?.xe) ?? -1;
+    if (t >= e.xe) e.xe = t + 1;
+    const n = e.xe;
+    const I = E.eE[n];
+    if (I === undefined) E.eE[n] = e; else {
+        const E = I.st;
+        E.ot = e;
+        e.st = E;
+        I.st = e;
+    }
+    if (n > E.EE) E.EE = n;
+}
+
+function insertIntoHeap(e, E) {
+    let t = e.se;
+    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
+    if (t & REACTIVE_CHECK) {
+        e.se = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+    } else {
+        e.se = t | REACTIVE_IN_HEAP;
+        // An unmarked node entering a marked heap invalidates the markHeap memo:
+        // `_marked` is only reset by runHeap, so a write between two mid-tick
+        // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+        // this node unmarked and every downstream pull stale until the next
+        // flush (#2922: the second `latest()` returned the first write's value).
+                if (E.tE && !(t & REACTIVE_DIRTY)) E.tE = false;
+    }
+    if (!(t & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, E);
+}
+
+function insertIntoHeapHeight(e, E) {
+    let t = e.se;
+    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
+    e.se = t | REACTIVE_IN_HEAP_HEIGHT;
+    actualInsertIntoHeap(e, E);
+}
+
+function deleteFromHeap(e, E) {
+    const t = e.se;
+    if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+    e.se = t & -25;
+    const n = e.xe;
+    if (e.st === e) E.eE[n] = undefined; else {
+        const t = e.ot;
+        const I = E.eE[n];
+        const o = t ?? I;
+        if (e === I) E.eE[n] = t; else e.st.ot = t;
+        o.st = e.st;
+    }
+    e.st = e;
+    e.ot = undefined;
+}
+
+function markHeap(e) {
+    if (e.tE) return;
+    e.tE = true;
+    for (let E = 0; E <= e.EE; E++) {
+        for (let t = e.eE[E]; t !== undefined; t = t.ot) {
+            if (t.se & REACTIVE_IN_HEAP) markNode(t);
+        }
+    }
+}
+
+function markNode(e, E = REACTIVE_DIRTY) {
+    const t = e.se;
+    if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
+    e.se = t & -4 | E;
+    for (let E = e.o; E !== null; E = E.le) {
+        markNode(E.fe, REACTIVE_CHECK);
+    }
+    if (e.u !== null) {
+        for (let E = e.u; E !== null; E = E.ae) {
+            for (let e = E.o; e !== null; e = e.le) {
+                markNode(e.fe, REACTIVE_CHECK);
+            }
+        }
+    }
+}
+
+function runHeap(e, E) {
+    e.tE = false;
+    for (e.Ve = 0; e.Ve <= e.EE; e.Ve++) {
+        let t = e.eE[e.Ve];
+        while (t !== undefined) {
+            if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.Ve];
+        }
+    }
+    e.EE = 0;
+}
+
+function adjustHeight(e, E) {
+    deleteFromHeap(e, E);
+    let t = e.xe;
+    for (let E = e.tt; E; E = E.nt) {
+        const e = E.it;
+        const n = e.lt || e;
+        if (n.ce && n.xe >= t) t = n.xe + 1;
+    }
+    if (e.xe !== t) {
+        e.xe = t;
+        for (let E = e.o; E !== null; E = E.le) {
+            // Route each subscriber by its own zombie flag, mirroring the
+            // post-recompute height-adjust path. Inserting into the running `heap`
+            // unconditionally can park a zombie in `dirtyQueue` (or a live node in
+            // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
+            // relies on — the same corruption class as #2759.
+            insertIntoHeapHeight(E.fe, queueFor(E.fe));
+        }
+    }
+}
+
+export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, queueFor, runHeap };

package/dist/prod/core/invariants.js

@@ -0,0 +1,42 @@
+/**
+ * INV-2: a node with an *active* override must be registered for reversion in
+ * the queue's or a transition's `_optimisticNodes`. An unregistered active
+ * override would survive transition completion forever. Runs at the end of
+ * every flush (not just quiescence — the invariant holds mid-transition).
+ * (There is no revert-target requirement: authoritative values commit
+ * silently into `_value` under the override mask — A17 — so reverting is
+ * just dropping the override.)
+ */
+function devCheckActiveOverrides(e) {
+    return;
+}
+
+/** INV-1: an isPending() probe must never leak past its own call. */ function devCheckFlushStart() {
+    return;
+}
+
+/**
+ * Companion-vs-oracle census (#2838 pre-work). A NON-ASSERTING diff logger:
+ * at the end of every flush it compares each live companion's cached state
+ * against a fresh oracle and logs every distinct divergence fingerprint once
+ * (console, `[census]` prefix). Legit lane-scoped windows will show up too —
+ * the census exists to enumerate the full taxonomy of mid-flight divergence
+ * so the write-driven redesign knows every case it must produce, not to
+ * judge them. Enabled only when the COMPANION_CENSUS env var is set (in
+ * addition to `false`), so normal test runs pay one boolean check.
+ */ typeof globalThis !== "undefined" && !!globalThis.process?.env?.COMPANION_CENSUS;
+
+function devCensusCompanions(e) {
+    return;
+}
+
+/**
+ * Quiescence checks. Run only when the system is fully drained: nothing
+ * scheduled, no active/stashed transitions, no live lanes. At that point no
+ * transition-scoped state may survive, and the lazily-created companions must
+ * agree with a fresh computation of their owner's state.
+ */ function devCheckQuiescent(e) {
+    return;
+}
+
+export { devCensusCompanions, devCheckActiveOverrides, devCheckFlushStart, devCheckQuiescent };