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

package/dist/prod/core/action.js

@@ -0,0 +1,139 @@
+import { globalQueue, activeTransition, currentTransition, schedule, flush } from "./scheduler.js";
+
+import { isThenable } from "./async.js";
+
+import "./core.js";
+
+function restoreTransition(e, r) {
+    globalQueue.initTransition(e);
+    const t = r();
+    flush();
+    return t;
+}
+
+/**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
+ * Wraps a generator function so each invocation runs as a single transaction
+ * (a "transition") that batches every signal/store write between yields. The
+ * surrounding UI sees one atomic update per yielded step; nothing is committed
+ * until the action either completes or the next `yield` resolves.
+ *
+ * `yield` is the transaction-safe suspension point: the action waits for a
+ * yielded promise and re-enters the transaction before running the code after
+ * it. A plain `await` does NOT — the runtime has no hook into an async
+ * generator's internal await continuations, so writes to fresh signals
+ * between an `await` and the next `yield` escape the transaction and commit
+ * immediately. `await` is still the ergonomic choice for typed results; just
+ * put a bare `yield` before any writes that follow it:
+ *
+ * ```ts
+ * const saved = await api.createTodo(text); // typed result
+ * yield; // re-enter the transaction before writing
+ * setTodos(t => { ... });
+ * ```
+ *
+ * (For the same reason, don't call `flush()` inside an action body — it
+ * drains the transaction mid-step.)
+ *
+ * Each call returns a `Promise` that resolves with the generator's return
+ * value, or rejects if it throws. Pair with `createOptimistic` /
+ * `createOptimisticStore` to apply tentative writes that auto-revert if the
+ * action fails.
+ *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
+ *
+ * const addTodo = action(async function* (text: string) {
+ *   const tempId = crypto.randomUUID();
+ *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
+ *   const saved = await api.createTodo(text); // network round-trip, typed
+ *   yield; // re-enter the transaction
+ *   setTodos(t => {
+ *     const i = t.findIndex(x => x.id === tempId);
+ *     if (i >= 0) t[i] = saved;
+ *   });
+ *   return saved;
+ * });
+ *
+ * await addTodo("buy milk");
+ * ```
+ */ function action(e) {
+    return (...r) => new Promise((t, n) => {
+        const i = e(...r);
+        globalQueue.initTransition();
+        let o = activeTransition;
+        o.ie.push(i);
+        const done = (e, r, u = false) => {
+            o = currentTransition(o);
+            const s = o.ie.indexOf(i);
+            if (s >= 0) o.ie.splice(s, 1);
+            // Re-adopt through initTransition like every other resumption site:
+            // a bare setActiveTransition leaves globalQueue._batch as a detached
+            // ambient batch, and anything registered before the scheduled flush
+            // (held writes on a merging transition, optimistic overrides,
+            // affects() marks) lands there with nothing to ever finalize it.
+                        globalQueue.initTransition(o);
+            schedule();
+            u ? n(r) : t(e);
+        };
+        const step = (e, r) => {
+            let t;
+            try {
+                t = r ? i.throw(e) : i.next(e);
+            } catch (e) {
+                return done(undefined, e, true);
+            }
+            // A rejected iterator result (async generators) means the error already
+            // escaped the generator body — it is completed, and throwing back in
+            // would just reject again forever. Settle instead.
+                        if (isThenable(t)) return void t.then(run, e => done(undefined, e, true));
+            run(t);
+        };
+        const run = e => {
+            if (e.done) return done(e.value);
+            // Thenable assimilation can itself throw synchronously (a `then`
+            // getter, or a `then()` method that throws — #2918). Match `await`
+            // semantics: the failure is thrown back into the generator at the
+            // yield point (catchable there); if uncaught, step()'s guard settles
+            // the action so its iterator never leaks in the transition. The
+            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+            // already called a callback is ignored.
+                        let r = false;
+            try {
+                if (isThenable(e.value)) return void e.value.then(e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e));
+                }, e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e, true));
+                });
+            } catch (e) {
+                if (r) return;
+                r = true;
+                return void restoreTransition(o, () => step(e, true));
+            }
+            restoreTransition(o, () => step(e.value));
+        };
+        step();
+    });
+}
+
+export { action };

package/dist/prod/core/async.js

@@ -0,0 +1,553 @@
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
+
+import { untrack, context, setSignal } from "./core.js";
+
+import "./invariants.js";
+
+import { NotReadyError, StatusError } from "./error.js";
+
+import { trimStaleDeps, unobserved } from "./graph.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane } from "./lanes.js";
+
+import { cleanup } from "./owner.js";
+
+import { globalQueue, GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition } 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.oe?.has(n)) return false;
+    (e.oe ??= new Set).add(n);
+    return true;
+}
+
+function removePendingSource(e, n) {
+    if (!e.oe?.delete(n)) return false;
+    if (e.oe.size === 0) e.oe = undefined;
+    return true;
+}
+
+function clearPendingSources(e) {
+    e.oe?.clear();
+    e.oe = undefined;
+}
+
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */ function parkLoadingWindow(e, n) {
+    e.ue = true;
+    if (n.source) addPendingSource(e, n.source);
+    // A settled error is the node's answer ("the error stays the answer until
+    // this retry can actually run") — the park must not replace it: reads
+    // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
+    // a pending-class NotReadyError from a read-invisible park (#2989).
+        if (!(e.S & STATUS_ERROR)) setPendingError(e, n.source, n);
+}
+
+function setPendingError(e, n, t) {
+    if (!n) {
+        e._ = null;
+        return;
+    }
+    if (t instanceof NotReadyError && t.source === n) {
+        e._ = t;
+        return;
+    }
+    const r = e._;
+    if (!(r instanceof NotReadyError) || r.source !== n) {
+        e._ = new NotReadyError(n);
+    }
+}
+
+function forEachDependent(e, n) {
+    for (let t = e.o; t !== null; t = t.le) n(t.fe, t);
+    // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
+        for (let t = e.u ?? null; t !== null; t = t.ae) {
+        for (let e = t.o; e !== null; e = e.le) n(e.fe, 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).
+// Settle-time counterpart of unlinkSubs' last-one-out check. A lazy node that
+// loses its last subscriber while STATUS_PENDING is exempt from autodispose
+// (the in-flight work is an observer), so whatever CLEARS that pending state
+// must run the release — otherwise the node stays linked and recomputes
+// forever with zero subscribers (#2934). The node's own promise/iterator
+// callbacks handle their own release (settleAutodispose in handleAsync); this
+// covers derivatively-pending dependents, which have no callbacks of their own.
+function releaseIfSettledUnobserved(e) {
+    e.ce && e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.se & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+}
+
+// Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
+// sources through its own recursion (no per-node settle callback), so after
+// the propagation completes, walk the same graph for stranded lazy nodes.
+// Collect-then-release so unobserved() never unlinks under the walk.
+function releaseSettledDependents(e) {
+    let n;
+    const t = new Set;
+    const visit = e => {
+        if (t.has(e)) return;
+        t.add(e);
+        if (!e.o && e.T & CONFIG_AUTO_DISPOSE) (n ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (n) for (const e of n) releaseIfSettledUnobserved(e);
+}
+
+// Error-dimension twin of settlePendingSource's blocked re-enqueue (#2949):
+// a node in STATUS_ERROR that recovers by recomputing to an UNCHANGED value
+// fires no value notification — the recovery is completely silent. But a
+// dependent that re-ran during the error window consumed its dirty flag and
+// committed nothing (the fresh sibling values it read were absorbed into an
+// errored run), so its committed value is stale. The propagated error is one
+// object identity down the whole dependent tree, and holding it is exactly
+// the "blocked on this error" marker — re-enqueue those holders so they
+// re-run: fresh values commit and flow, and a dependent with another
+// still-broken source simply re-errors. The async dimension needs no twin of
+// its own: recovery there passes through a pending window whose re-runners
+// set _blocked and ride settlePendingSource. Walks the full dependent graph
+// (releaseSettledDependents shape): identity holders can sit below an
+// intermediate whose own error state has since been scrubbed or replaced
+// (e.g. an error boundary's tree node).
+function settleErroredDependents(e, n) {
+    let t = false;
+    const r = new Set;
+    const visit = e => {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e._ === n) {
+            enqueueSub(e);
+            t = true;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) schedule();
+}
+
+function settlePendingSource(e) {
+    let n = false;
+    let t;
+    const r = new Set;
+    // Companion updates no-op without the verdict layer (null hook).
+        const o = GlobalQueue.Se;
+    const settle = u => {
+        if (r.has(u) || !removePendingSource(u, e)) return;
+        r.add(u);
+        u.de = clock;
+        const i = u.oe?.values().next().value;
+        // STATUS_ERROR + pending sources only coexist via an errored loading
+        // window's park (notifyStatus(STATUS_ERROR) clears pending sources
+        // otherwise): the settled error stays the answer through the settle —
+        // nulling it here would have reads throw `null` until the re-enqueued
+        // retry lands, or lose it entirely if that retry parks again (#2989).
+                const l = u.S & STATUS_ERROR;
+        if (i) {
+            if (!l) setPendingError(u, i);
+            o !== null && o(u);
+        } else {
+            u.S &= ~STATUS_PENDING;
+            if (!l) setPendingError(u);
+            o !== null && o(u);
+            if (u.ue) {
+                enqueueSub(u);
+                n = true;
+            }
+            u.ue = false;
+            // Fully settled with nobody watching: release candidate (#2934). Checked
+            // again at release time — deferred so unobserved() can't unlink subs
+            // lists this walk is still iterating.
+                        if (!u.o && u.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(u);
+        }
+        forEachDependent(u, settle);
+    };
+    forEachDependent(e, settle);
+    // Release before the flush schedule below: unobserved() pulls the node back
+    // out of the heap, so the enqueueSub above never recomputes a released node.
+        if (t) for (const e of t) releaseIfSettledUnobserved(e);
+    if (n) schedule();
+}
+
+// Object-thenable detection (Promises/A+ shape).
+function isThenable(e) {
+    return e != null && typeof e === "object" && typeof e.then === "function";
+}
+
+function handleAsync(e, n, t) {
+    let r = false;
+    let o = false;
+    if (typeof n === "object" && n !== null) {
+        untrack(() => {
+            r = n[Symbol.asyncIterator];
+            o = !r && isThenable(n);
+        });
+    }
+    if (!o && !r) {
+        e.Te = null;
+        // A sync landing is the first real answer for a loadingValue node.
+                e.Ee = false;
+        return n;
+    }
+    e.Te = n;
+    let u;
+    // Settle-time transition re-entry. The loading rail is invisible to
+    // transactions (#2933): a boundary-caught first load never registers as an
+    // async reporter, so its settle — the boundary's fallback -> content
+    // reveal — must flow ambiently. The node can still carry a `_transition`
+    // stamp (pending-node bookkeeping rides through the stamping sites), and
+    // blindly re-entering that stamped, still-incomplete transaction stashed
+    // the reveal with it — a deadlock when the transaction's completion
+    // depended on the reveal (#2937). An ESCAPED first load did register and
+    // keeps transition scheduling; initialized (value-holding) pending settles
+    // are the transaction's reveal machinery and always re-enter.
+        const settleTransition = () => {
+        const n = resolveTransition(e);
+        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ie.has(e)) {
+            // Drop the stale stamp too: the plain settle write (setSignal) and the
+            // stash-path restamp both re-enter the transaction through it.
+            e.Ne = null;
+            return;
+        }
+        globalQueue.initTransition(n);
+    };
+    const handleError = t => {
+        if (e.Te !== n) return;
+        // NotReadyError from rejected promises should be treated as pending, not error
+                let r = t instanceof NotReadyError;
+        if (r && e.Ee) {
+            // Loading window: the flight died waiting on an unready source. Keep
+            // serving commit #0 — same parking as recompute's catch for sync
+            // dependency throws. The dead flight is released so the clock-gated
+            // error-retry pull (updateIfNecessary) can also re-ask.
+            e.Te = null;
+            parkLoadingWindow(e, t);
+            e.de = clock;
+            return;
+        }
+        settleTransition();
+        notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
+        e.de = clock;
+        // A real error settles derivatively-pending dependents (notifyStatus
+        // cleared their pending sources), so stranded lazy ones release here —
+        // the error twin of settlePendingSource's release (#2934).
+                if (!r) releaseSettledDependents(e);
+    };
+    const asyncWrite = (r, o) => {
+        if (e.Te !== 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.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+        settleTransition();
+        const u = !!(e.S & STATUS_UNINITIALIZED);
+        trimStaleDeps(e);
+        clearStatus(e);
+        const i = resolveLane(e);
+        if (i) i.Ae.delete(e);
+        if (t) {
+            t(r);
+            if (u) clearStatus(e, true);
+        } else if (e._e !== 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.De === NOT_PENDING) queuePendingNode(e);
+            e.De = r;
+            // 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.Pe !== null && GlobalQueue.Pe(e, r);
+            if (!hasActiveOverride(e)) insertSubs(e);
+            e.de = clock;
+        } else if (i) {
+            // Route through lane's effect queue for independent flushing
+            const n = e.Re;
+            const t = e.Ue;
+            const o = e.be;
+            try {
+                if (!n && u || !o || !o(r, t)) {
+                    e.Ue = r;
+                    e.de = 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.Pe !== null && GlobalQueue.Pe(e, r);
+                    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, () => r);
+            } 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);
+            }
+        }
+        // First real answer landing: the window closes when the answer becomes
+        // OBSERVABLE. A direct commit is observable now; a transition-held write
+        // (`_pendingValue` set above or inside setSignal) is not — the verdict's
+        // held-value branch is window-gated, and commitPendingNode closes the
+        // window when the hold commits, so no one-frame isPending pulse can leak
+        // to live observers between the landing and its commit (#2990).
+                if (e.De === NOT_PENDING) e.Ee = false;
+        settlePendingSource(e);
+        schedule();
+        flush();
+        o?.();
+    };
+    // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+    // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+    // work (a lazy async memo would otherwise tear down and re-execute — one
+    // fetch per suspended re-read). Settling is that observer's release, so
+    // it runs the same last-one-out check the other release sites run.
+    // Returns whether the node released, so the iterator branch can stop
+    // pulling values instead of pumping an unobserved stream forever (#2935).
+        const settleAutodispose = () => {
+        if (e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.S & STATUS_PENDING)) {
+            unobserved(e);
+            return true;
+        }
+        return false;
+    };
+    if (o) {
+        let t = false, r = false, o, i = true;
+        n.then(e => {
+            if (i) {
+                u = e;
+                t = true;
+            } else {
+                asyncWrite(e);
+                settleAutodispose();
+            }
+        }, e => {
+            if (i) {
+                o = e;
+                r = true;
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
+        });
+        i = false;
+        if (r) {
+            // 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 (!t) {
+            // Loading window: serve commit #0 instead of suspending. No transition
+            // is opened — first-flight work on a loadingValue node is loading-class
+            // (invisible to boundaries and transitions); the flight itself is
+            // already registered in _inFlight and lands through asyncWrite.
+            if (e.Ee) return e.Ue;
+            globalQueue.initTransition(resolveTransition(e));
+            throw new NotReadyError(context);
+        } else {
+            // Synchronously-resolved promise: the first real answer landed.
+            e.Ee = false;
+        }
+    }
+    if (r) {
+        const t = n[Symbol.asyncIterator]();
+        let r = false;
+        let o = false;
+        let i = true;
+        cleanup(() => {
+            if (o) return;
+            o = true;
+            try {
+                const e = t.return?.();
+                if (isThenable(e)) e.then(undefined, () => {});
+            } catch {}
+        });
+        // Release check before each next pull: an unobserved lazy node must tear
+        // down (its cleanup above closes the iterator) instead of pumping the
+        // stream forever with zero subscribers (#2935).
+                const iterateOrRelease = () => {
+            if (!settleAutodispose()) iterate();
+        };
+        const iterate = () => {
+            let l, s, f = false, a = false, c = true;
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const S = t.next();
+            const d = isThenable(S) ? S : {
+                then: e => void e(S)
+            };
+            d.then(t => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (c && i) {
+                    l = t;
+                    f = true;
+                    if (t.done) o = true;
+                } else if (e.Te !== n) {
+                    return;
+                } else if (!t.done) {
+                    r = true;
+                    asyncWrite(t.value, iterateOrRelease);
+                } else {
+                    o = true;
+                    if (r) {
+                        schedule();
+                        flush();
+                    } else {
+                        // Empty completion settles like the immediately-done sync path.
+                        asyncWrite(undefined);
+                    }
+                    settleAutodispose();
+                }
+            }, t => {
+                if (c) {
+                    s = t;
+                    a = true;
+                } else if (e.Te === n) {
+                    o = true;
+                    handleError(t);
+                    settleAutodispose();
+                }
+            });
+            c = false;
+            if (a) {
+                // Match the promise branch, but only rethrow during the initial read.
+                o = true;
+                handleError(s);
+                if (i) throw s;
+                return true;
+            }
+            if (f && !l.done) {
+                u = l.value;
+                r = true;
+                return iterate();
+            }
+            return f && l.done;
+        };
+        const l = iterate();
+        // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
+                i = false;
+        if (!r && !l) {
+            // Loading window: serve commit #0 (see the promise branch above).
+            if (e.Ee) return e.Ue;
+            globalQueue.initTransition(resolveTransition(e));
+            throw new NotReadyError(context);
+        }
+        // A sync first yield (or immediate empty completion) is the first real
+        // answer; async yields clear inside asyncWrite.
+                e.Ee = false;
+    }
+    return u;
+}
+
+function clearStatus(e, n = false) {
+    if (e.oe) clearPendingSources(e);
+    if (e.ue) e.ue = 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.he = false;
+    e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
+    if (e._) setPendingError(e);
+    // Update pending signal for isPending() reactivity (companions only exist
+    // once the verdict layer created them, which installs the hooks).
+        if (e.ge || e.pe) GlobalQueue.Se(e);
+    if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+    if (e.i) e.i();
+}
+
+function notifyStatus(e, n, t, r, o) {
+    // Wrap regular errors to track source node
+    if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
+    const u = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
+    const i = u === e;
+    const l = n === STATUS_PENDING && e._e !== undefined && !i;
+    const s = l && hasActiveOverride(e);
+    if (!r) {
+        if (n === STATUS_PENDING && u) {
+            addPendingSource(e, u);
+            e.S = STATUS_PENDING | e.S & 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, t);
+        } else {
+            clearPendingSources(e);
+            e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
+            e._ = t;
+        }
+        GlobalQueue.Se !== null && GlobalQueue.Se(e);
+        if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+    }
+    if (o && !r) {
+        assignOrMergeLane(e, o);
+    }
+    const f = r || s;
+    const a = r || l ? undefined : o;
+    if (e.i) {
+        if (r && n === STATUS_PENDING) {
+            return;
+        }
+        if (f) {
+            e.i(n, t);
+        } else {
+            e.i();
+        }
+        return;
+    }
+    forEachDependent(e, (e, r) => {
+        e.de = clock;
+        if (n === STATUS_PENDING && u && !e.oe?.has(u) || n !== STATUS_PENDING && (e._ !== t || e.oe)) {
+            // 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 (r.Ge && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+                enqueueSub(e);
+                schedule();
+                return;
+            }
+            if (!f && !e.Ne) queuePendingNode(e);
+            notifyStatus(e, n, t, f, a);
+        }
+    });
+}
+
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };