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

package/dist/prod/map.js

@@ -0,0 +1,317 @@
+import { computed, runWithOwner, signal, setSignal } from "./core/core.js";
+
+import { createOwner } from "./core/owner.js";
+
+import "./core/scheduler.js";
+
+import { CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+import "./core/verdict.js";
+
+import "./core/effect.js";
+
+import { accessor } from "./signals.js";
+
+import { $TRACK } from "./store/store.js";
+
+function mapArray(t, s, i) {
+    const e = typeof i?.keyed === "function" ? i.keyed : undefined;
+    const r = s.length > 1;
+    const n = s;
+    const h = {
+        wt: createOwner(),
+        jt: 0,
+        Wt: t,
+        Mt: [],
+        Kt: n,
+        xt: [],
+        Ut: [],
+        $t: e,
+        qt: e || i?.keyed === false ? [] : undefined,
+        zt: r && i?.keyed !== false ? [] : undefined,
+        Bt: i?.keyed === false,
+        Ht: i?.fallback
+    };
+    const o = computed(updateKeyedMap.bind(h));
+    // Untracked reads inside the internal owner resolve via _parentComputed; routing
+    // them through node lets store-proxy lookups see pending writes (not stale _value).
+        h.wt.dt = o;
+    o.T &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(o);
+}
+
+const pureOptions = {
+    ownedWrite: true
+};
+
+// Exception safety (#2903): a map callback can throw NotReadyError mid-pass
+// (async read), and the computed re-runs the whole pass after settle. Every
+// pass therefore STAGES its work — new rows are created into temp arrays and
+// removals are deferred — and commits to `this` only after every mapper
+// succeeded. An aborted pass disposes just the owners it created and leaves
+// `_items`/`_mappings`/`_nodes`/`_rows`/`_indexes`/`_len` exactly as they
+// were, so the retry diffs against uncorrupted state. Consequence of the
+// strong-abort ordering: removed rows now dispose AFTER the pass's new rows
+// are created (you cannot destroy state before knowing the pass will land).
+function updateKeyedMap() {
+    const t = this.Wt() || [], s = t.length;
+    t[$TRACK];
+ // top level tracking
+        runWithOwner(this.wt, () => {
+        let i, e, r, n, 
+        // Mappers write freshly-created row/index signals into the STAGE
+        // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
+        h = this.qt ? this.Bt ? () => {
+            r[e] = signal(t[e], pureOptions);
+            return this.Kt(accessor(r[e]), e);
+        } : () => {
+            r[e] = signal(t[e], pureOptions);
+            n && (n[e] = signal(e, pureOptions));
+            return this.Kt(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.zt ? () => {
+            const s = t[e];
+            n[e] = signal(e, pureOptions);
+            return this.Kt(s, accessor(n[e]));
+        } : () => {
+            const s = t[e];
+            return this.Kt(s);
+        };
+        // fast path for empty arrays
+                if (s === 0) {
+            if (this.jt !== 0) {
+                this.wt.dispose(false);
+                this.Ut = [];
+                this.Mt = [];
+                this.xt = [];
+                this.jt = 0;
+                this.qt && (this.qt = []);
+                this.zt && (this.zt = []);
+            }
+            if (this.Ht && !this.xt[0]) {
+                // an aborted fallback attempt leaves an owner without a mapping;
+                // dispose it before re-creating
+                this.Ut[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ut[0] = createOwner(), this.Ht);
+            }
+        }
+        // fast path for new create
+         else if (this.jt === 0) {
+            const o = new Array(s);
+            const c = new Array(s);
+            r = this.qt && new Array(s);
+            n = this.zt && new Array(s);
+            try {
+                for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
+            } catch (t) {
+                for (i = 0; i <= e; i++) c[i]?.dispose();
+                throw t;
+            }
+            // commit
+                        if (this.Ut[0]) this.Ut[0].dispose();
+ // previous fallback
+                        this.xt = o;
+            this.Ut = c;
+            r && (this.qt = r);
+            n && (this.zt = n);
+            this.Mt = t.slice(0);
+            this.jt = s;
+        } else {
+            let o, c, a, f, u, p, w, l, d;
+            // skip common prefix
+                        for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.qt && compare(this.$t, this.Mt[o], t[o])); o++) {
+                if (this.qt) setSignal(this.qt[o], t[o]);
+            }
+            // skip common suffix — counted only; retained entries land in one pass
+            // at commit instead of being staged and copied twice
+                        for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.qt && compare(this.$t, this.Mt[c], t[a])); c--, 
+            a--) ;
+            // no structural change (every position matched in place at equal
+            // length — the common post-reconcile shape): keep the same mapped
+            // array identity so downstream consumers don't re-run at all
+                        if (o === s && this.jt === s) {
+                this.Mt = t.slice(0);
+                return;
+            }
+            const O = s - this.jt;
+            const m = new Array(s);
+            const _ = new Array(s);
+            r = this.qt ? new Array(s) : undefined;
+            n = this.zt ? new Array(s) : undefined;
+            // 0) prepare a map of all indices in the changed window of newItems,
+            // scanning backwards so we encounter them in natural order
+                        p = new Map;
+            w = new Array(a + 1);
+            for (e = a; e >= o; e--) {
+                f = t[e];
+                u = this.$t ? this.$t(f) : f;
+                i = p.get(u);
+                w[e] = i === undefined ? -1 : i;
+                p.set(u, e);
+            }
+            // 1) step through the old changed window and see if items can be found
+            // in the new set; if so, stage them at their new positions; if not,
+            // queue them for disposal at commit
+                        for (i = o; i <= c; i++) {
+                f = this.Mt[i];
+                u = this.$t ? this.$t(f) : f;
+                e = p.get(u);
+                if (e !== undefined && e !== -1) {
+                    m[e] = this.xt[i];
+                    _[e] = this.Ut[i];
+                    r && (r[e] = this.qt[i]);
+                    n && (n[e] = this.zt[i]);
+                    e = w[e];
+                    p.set(u, e);
+                } else (l ??= []).push(this.Ut[i]);
+            }
+            // 2) create new rows into the temp arrays; an abort disposes only these
+                        try {
+                for (e = o; e <= a; e++) {
+                    if (_[e] !== undefined) continue;
+                    (d ??= []).push(_[e] = createOwner());
+                    m[e] = runWithOwner(_[e], h);
+                }
+            } catch (t) {
+                if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+                throw t;
+            }
+            // 3) commit: land the retained prefix and suffix plus the staged window
+            // into the fresh arrays, swap them in (new identity for downstream
+            // change propagation), then dispose exited rows
+                        for (i = 0; i < o; i++) {
+                m[i] = this.xt[i];
+                _[i] = this.Ut[i];
+                r && (r[i] = this.qt[i]);
+                n && (n[i] = this.zt[i]);
+            }
+            for (e = o; e <= a; e++) {
+                if (r) setSignal(r[e], t[e]);
+                if (n) setSignal(n[e], e);
+            }
+            for (e = a + 1; e < s; e++) {
+                m[e] = this.xt[e - O];
+                _[e] = this.Ut[e - O];
+                if (r) {
+                    r[e] = this.qt[e - O];
+                    setSignal(r[e], t[e]);
+                }
+                if (n) {
+                    n[e] = this.zt[e - O];
+                    if (O !== 0) setSignal(n[e], e);
+                }
+            }
+            this.xt = m;
+            this.Ut = _;
+            r && (this.qt = r);
+            n && (this.zt = n);
+            this.jt = s;
+            // save a copy of the mapped items for the next update
+                        this.Mt = t.slice(0);
+            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
+        }
+    });
+    return this.xt;
+}
+
+/**
+ * Reactively renders a callback `count` times, reusing previously-rendered
+ * entries when only the count changes. Underlying helper for `<Repeat>`.
+ *
+ * - `options.from` — start index (default `0`); useful for offset/windowed
+ *   rendering.
+ * - `options.fallback` — accessor returning a value to show when count is `0`.
+ *
+ * @example
+ * ```ts
+ * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */ function repeat(t, s, i) {
+    const e = s;
+    const r = {
+        wt: createOwner(),
+        jt: 0,
+        Jt: 0,
+        Vt: t,
+        Kt: e,
+        Ut: [],
+        xt: [],
+        Xt: i?.from,
+        Ht: i?.fallback
+    };
+    const n = computed(updateRepeat.bind(r));
+    // Same as mapArray: untracked reads inside the internal owner resolve via
+    // _parentComputed, so async reads in row callbacks register with the node
+    // (pending tracking + post-settle retry) instead of vanishing.
+        r.wt.dt = n;
+    n.T &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(n);
+}
+
+// Same staged-commit discipline as `updateKeyedMap` (#2903): the retained
+// window overlap is copied into fresh arrays, missing indexes are created
+// into them, and `this` is only touched — including disposal of rows leaving
+// the window — after every `_map` call succeeded. A NotReadyError mid-pass
+// disposes only the owners this pass created and leaves prior state intact
+// for the post-settle retry. The overlap math also subsumes the previous
+// disjoint-window/front-clear/end-clear/shift special cases.
+function updateRepeat() {
+    const t = this.Vt();
+    const s = this.Xt?.() || 0;
+    runWithOwner(this.wt, () => {
+        if (t === 0) {
+            if (this.jt !== 0) {
+                this.wt.dispose(false);
+                this.Ut = [];
+                this.xt = [];
+                this.jt = 0;
+                // Reset offset to match the cleared data (#2767, repro 2).
+                                this.Jt = 0;
+            }
+            if (this.Ht && !this.xt[0]) {
+                // an aborted fallback attempt leaves an owner without a mapping;
+                // dispose it before re-creating
+                this.Ut[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ut[0] = createOwner(), this.Ht);
+            }
+            return;
+        }
+        const i = s + t;
+        const e = this.Jt + this.jt;
+        // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
+        // windows are disjoint or when coming from empty/fallback.
+                const r = Math.max(s, this.Jt);
+        const n = Math.min(i, e);
+        const h = new Array(t);
+        const o = new Array(t);
+        for (let t = r; t < n; t++) {
+            o[t - s] = this.Ut[t - this.Jt];
+            h[t - s] = this.xt[t - this.Jt];
+        }
+        try {
+            for (let t = s; t < i; t++) {
+                if (t >= r && t < n) continue;
+                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.Kt(t));
+            }
+        } catch (t) {
+            for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
+            throw t;
+        }
+        // commit: dispose the previous fallback or the rows leaving the window
+                if (this.jt === 0) this.Ut[0]?.dispose(); else for (let t = this.Jt; t < e; t++) if (t < s || t >= i) this.Ut[t - this.Jt].dispose();
+        this.xt = h;
+        this.Ut = o;
+        this.Jt = s;
+        this.jt = t;
+    });
+    return this.xt;
+}
+
+function compare(t, s, i) {
+    return t ? t(s) === t(i) : true;
+}
+
+export { mapArray, repeat };

package/dist/prod/signals.js

@@ -0,0 +1,375 @@
+import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner, setMemo, signal, read, untrack } from "./core/core.js";
+
+import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
+
+import { globalQueue, Queue } from "./core/scheduler.js";
+
+import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+import "./core/verdict.js";
+
+import { effect, trackedEffect } from "./core/effect.js";
+
+import { installOptimisticEngine } from "./core/optimistic.js";
+
+/**
+ * Low-level reactive-cleanup primitive. Registers a callback that runs when
+ * the surrounding owner is disposed.
+ *
+ * **In 2.0 user code this is rare.** The two cases where you might reach for
+ * it have better-shaped tools:
+ *
+ * - **Component lifecycle (mount/unmount, listeners, intervals):** use
+ *   {@link onSettled} and **return** a cleanup function. Setup and teardown
+ *   stay paired in one block. This replaces the 1.x `onMount` + `onCleanup`
+ *   pairing.
+ * - **Cleanup tied to an effect run:** `onCleanup` does not belong in
+ *   `createEffect`'s apply phase. If a compute phase genuinely needs per-run
+ *   teardown, that's usually a sign the work should be a memo/projection
+ *   instead, or moved to `onSettled` if it's lifecycle-shaped.
+ *
+ * Where `onCleanup` is the right tool is **library / custom-primitive
+ * internals** — coordinating disposal inside a `createRoot` body, or wiring
+ * cleanup to a captured owner via `runWithOwner` from a custom factory.
+ * Application code rarely needs to write any of those shapes directly.
+ *
+ * Must be called inside an owner. Calling outside an owner is a no-op (with a
+ * dev-mode warning).
+ *
+ * Cannot be used inside `createTrackedEffect` or `onSettled` — return a
+ * cleanup function from the callback body instead.
+ *
+ * @example
+ * ```ts
+ * // Library shape: thread a resource's disposal into a *captured* owner
+ * // from a factory that has no settle-phase setup of its own. `onSettled`
+ * // would queue a callback we don't need; `onCleanup` is the leaner
+ * // primitive when the only job is "register disposal on this owner".
+ * function bindToOwner<T extends { dispose(): void }>(owner: Owner, resource: T): T {
+ *   runWithOwner(owner, () => onCleanup(() => resource.dispose()));
+ *   return resource;
+ * }
+ * ```
+ */ function onCleanup(e) {
+    return cleanup(e);
+}
+
+function accessor(e) {
+    const t = read.bind(null, e);
+    t[$REFRESH] = e;
+    return t;
+}
+
+function createSignal(e, t) {
+    if (typeof e === "function") {
+        const n = computed(e, t);
+        n.T &= ~CONFIG_AUTO_DISPOSE;
+        return [ accessor(n), setMemo.bind(null, n) ];
+    }
+    const n = signal(e, t);
+    return [ accessor(n), setSignal.bind(null, n) ];
+}
+
+function createMemo(e, t) {
+    return accessor(computed(e, t));
+}
+
+function createEffect(e, t, n) {
+    effect(e, t.effect || t, t.error, {
+        user: true,
+        ...n
+    });
+}
+
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements
+ * are created and updated but not necessarily connected.
+ *
+ * Same compute / effect split as `createEffect`, but scheduled inside the render
+ * queue rather than after it. Reach for this only when authoring renderer
+ * plumbing (custom DOM bindings, JSX-generated `insert()` / `spread()` calls).
+ * App code should use `createEffect`.
+ *
+ * ```typescript
+ * createRenderEffect<T>(compute, effectFn, options?: EffectOptions);
+ * ```
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
+ * @param effectFn a function that receives the new value and is used to perform side effects
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
+ *
+ * @example
+ * ```ts
+ * // Custom directive: bind an element's textContent to a reactive source.
+ * function bindText(el: HTMLElement, source: () => string) {
+ *   createRenderEffect(
+ *     () => source(),
+ *     value => { el.textContent = value; }
+ *   );
+ * }
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */ function createRenderEffect(e, t, n) {
+    effect(e, t, undefined, n);
+}
+
+/**
+ * Creates a tracked reactive effect where dependency tracking and side effects happen
+ * in the same scope.
+ *
+ * WARNING: Because tracking and effects happen in the same scope, this primitive
+ * may run multiple times for a single change or show tearing (reading inconsistent
+ * state). Use only when dynamic subscription patterns require same-scope tracking.
+ *
+ * ```typescript
+ * createTrackedEffect(compute, options?: { name?: string });
+ * ```
+ * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
+ * @param options -- name
+ *
+ * @example
+ * ```ts
+ * createTrackedEffect(() => {
+ *   const target = focusedNode();
+ *   if (!target) return;
+ *
+ *   const handler = () => log(target.value());
+ *   target.on("change", handler);
+ *
+ *   return () => target.off("change", handler);
+ * });
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ */ function createTrackedEffect(e, t) {
+    trackedEffect(e, t);
+}
+
+/**
+ * Creates a reactive computation that runs after the render phase with flexible tracking.
+ *
+ * ```typescript
+ * const track = createReaction(effectFn, options?: EffectOptions);
+ * track(() => { // reactive reads });
+ * ```
+ * @param effectFn a function (or `EffectBundle`) that is called when tracked function is invalidated
+ * @param options `EffectOptions` -- name, defer
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * const track = createReaction(() => {
+ *   console.log("count changed once, re-arm to listen again");
+ *   track(() => count()); // re-arm
+ * });
+ *
+ * track(() => count()); // initial arm
+ *
+ * setCount(1); // logs once, reaction re-armed for next change
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ */ function createReaction(e, t) {
+    let n = undefined;
+    cleanup(() => n?.());
+    const c = getOwner();
+    // The currently armed effect node. `track()` replaces the previous
+    // subscription (1.x semantics): without disposing the superseded arm, its
+    // sources stayed live (firing the callback for replaced dependencies), each
+    // accumulated arm delivered its own fire, and un-fired arms leaked as live
+    // effect nodes until the owner disposed (#2861).
+        let r;
+    return o => {
+        if (r) {
+            dispose(r);
+            r = undefined;
+        }
+        runWithOwner(c, () => {
+            effect(() => (o(), r = getOwner()), t => {
+                r = undefined;
+                n?.();
+                const c = (e.effect || e)?.();
+                if (false && c !== undefined && typeof c !== "function") ;
+                n = c;
+                dispose(t);
+            }, e.error, {
+                ...false ? {
+                    ...t,
+                    name: t?.name ?? "effect"
+                } : t,
+                user: true,
+                defer: true
+            });
+        });
+    };
+}
+
+/** Delivers effect applies on a microtask instead of queueing them (#2930). */ class MicrotaskQueue extends Queue {
+    enqueue(e, t) {
+        queueMicrotask(() => t(e));
+    }
+}
+
+/**
+ * Awaits a reactive expression and returns its first fully-settled value as a
+ * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
+ * waited on; once the expression returns synchronously without `NotReadyError`
+ * the promise resolves with that value. If the expression settles with an
+ * error instead — including an async source that rejects — the promise
+ * rejects with it.
+ *
+ * Must be called *outside* a tracking scope — it doesn't subscribe, it just
+ * resolves the current value once.
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(() => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // outside any reactive scope
+ * const initial = await resolve(() => user());
+ * ```
+ *
+ * @param fn a reactive expression to resolve
+ */ function resolve(e) {
+    return new Promise((t, n) => {
+        createRoot(c => {
+            // Deliver effect applies on a microtask instead of the owner queue: an
+            // incomplete transition stashes its effect queues until it settles, but
+            // an action yielding this promise is itself what keeps the transition
+            // open — the stashed res() deadlocked the action (#2930). The compute
+            // still runs in place (under the transaction's view when created inside
+            // an action step), and status/boundary notifications keep their normal
+            // route through the inherited queue.
+            const r = getOwner();
+            const o = new MicrotaskQueue;
+            o.ke = r.C;
+ // notify() forwards up the normal chain
+                        r.C = o;
+            // A user effect rather than a bare computed: computeds are pull-based and
+            // are only re-enqueued when a pending source *resolves* — a rejection just
+            // marks them errored, so nothing would re-run and the promise would never
+            // settle (#2842). The effect's error channel is notified on rejection.
+                        effect(e, e => {
+                t(e);
+                c();
+            }, e => {
+                // The error arm already unwraps StatusError (#2840) — `err` is the
+                // user's original error, matching what error boundaries expose.
+                n(e);
+                c();
+            }, {
+                user: true
+            });
+        });
+    });
+}
+
+function createOptimistic(e, t) {
+    // Install before the node exists: only engine-installed programs can carry
+    // an _overrideValue slot (same runtime-install pattern as
+    // GlobalQueue._clearOptimisticStore in createOptimisticStore).
+    installOptimisticEngine();
+    if (typeof e === "function") {
+        const n = optimisticComputed(e, t);
+        n.T &= ~CONFIG_AUTO_DISPOSE;
+        return [ accessor(n), setSignal.bind(null, n) ];
+    }
+    const n = optimisticSignal(e, t);
+    return [ accessor(n), setSignal.bind(null, n) ];
+}
+
+/**
+ * Schedules `callback` to run **once** after the reactive graph has fully
+ * settled — i.e. once every pending async read inside the current owner has
+ * resolved and the queue has flushed. Each call registers a single fire; it
+ * does not create an ongoing subscription.
+ *
+ * The canonical lifecycle primitive in 2.0. Three main usages:
+ *
+ * - **Component-level setup-and-teardown** *(the most common shape)*: run
+ *   setup after the component's first stable render and **return a cleanup
+ *   function** to dispose it on owner disposal. This is the replacement for
+ *   the 1.x `onMount` + `onCleanup` pairing — setup and teardown live in one
+ *   block, and `onCleanup` is no longer the right tool for component
+ *   bodies. (`onMount` no longer exists in 2.0.)
+ * - **Post-settle "ready" hook:** run once after a component's first stable
+ *   render — analytics ping, focus, scroll-into-view, etc. No cleanup needed.
+ * - **Inside an event handler:** schedule work to run after the action /
+ *   transition triggered by the event has completed.
+ *
+ * Reactive reads inside the callback are *not* tracked — to react to
+ * subsequent settles, register a new `onSettled` each time.
+ *
+ * `onCleanup` is **not** allowed inside the callback — return a cleanup
+ * function instead. The returned cleanup runs on owner disposal.
+ *
+ * A cleanup return is only honored when `onSettled` is called from an **owned**
+ * scope (e.g. a component body). When it fires out of band from an *unowned*
+ * scope — an event handler, a tracked effect, or another `onSettled` — there is
+ * no owner lifecycle to bind a cleanup to; returning one is a dev-mode error
+ * (and is dropped in production). Use the post-settle/event-handler forms below
+ * for one-shot work, and keep setup-with-teardown in an owned scope.
+ *
+ * @example
+ * ```tsx
+ * // Component-level setup + teardown — replaces onMount + onCleanup.
+ * // Subscribe to an external source on mount, unsubscribe on dispose.
+ * function useViewportWidth() {
+ *   const [width, setWidth] = createSignal(window.innerWidth);
+ *   onSettled(() => {
+ *     const onResize = () => setWidth(window.innerWidth);
+ *     window.addEventListener("resize", onResize);
+ *     return () => window.removeEventListener("resize", onResize);
+ *   });
+ *   return width;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Post-settle "ready" hook — no cleanup needed.
+ * function Dashboard() {
+ *   const data = createMemo(async () => fetchData());
+ *
+ *   onSettled(() => {
+ *     analytics.track("dashboard.ready");
+ *   });
+ *
+ *   return <Loading fallback={<Spinner />}><pre>{data()}</pre></Loading>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Event-handler — runs after the action settles.
+ * function SaveButton() {
+ *   const save = action(function* () {
+ *     yield api.save();
+ *   });
+ *
+ *   const handleClick = () => {
+ *     save();
+ *     onSettled(() => toast("Saved!"));
+ *   };
+ *
+ *   return <button onClick={handleClick}>Save</button>;
+ * }
+ * ```
+ *
+ * @param callback Function to run; may return a cleanup function that fires
+ *   on owner disposal
+ */ function onSettled(e) {
+    const t = getOwner();
+    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+        // Unowned, out-of-band fire (no owner, or a children-forbidden one this
+        // one-shot must not bind to): a returned cleanup has no lifecycle to
+        // attach to. Reject it in dev; in production the return is simply
+        // dropped — never bound to an unrelated owner or run eagerly.
+        e();
+    });
+}
+
+export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, resolve };