@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/observe/core/dev.js

@@ -0,0 +1,343 @@
+import { currentOrigin, withOrigin, withInteraction, attrHooks } from "./attribution-hooks.js";
+
+import { context } from "./core.js";
+
+/** First warning when a change reaches (or a pass tracks) this many edges. */ const GRAPH_SIZE_WARN_AT = 2e3;
+
+/** Re-warn once the count has grown by this much since the last warning. */ const GRAPH_SIZE_WARN_EVERY = 500;
+
+const diagnosticListeners = new Set;
+
+const diagnosticCaptures = new Set;
+
+let diagnosticSequence = 0;
+
+/**
+ * Registers the console footer appended to the first console report of
+ * each diagnostic code — a discovery pointer to deeper guidance. Reported
+ * events carry it as trailing lines of the same console entry; events that
+ * surface as a thrown error instead get it as a follow-up line. Returning
+ * undefined for an event suppresses the footer. Passing undefined
+ * unregisters and resets the once-per-code memory.
+ *
+ * @internal A seam for `solid-js`, which owns the repair skill the footer
+ * names and installs it from both of its entries; not part of `DEV`. No-op
+ * outside dev builds, where nothing reports to the console.
+ */ function setConsoleFooter(e) {
+    return;
+}
+
+const diagnostics = {
+    subscribe(e) {
+        diagnosticListeners.add(e);
+        return () => diagnosticListeners.delete(e);
+    },
+    emit(e, n = null) {
+        return emitDiagnostic(e, n);
+    },
+    capture() {
+        const e = [];
+        diagnosticCaptures.add(e);
+        return {
+            get events() {
+                return e;
+            },
+            clear() {
+                e.length = 0;
+            },
+            stop() {
+                diagnosticCaptures.delete(e);
+                return [ ...e ];
+            }
+        };
+    }
+};
+
+const attributionSlot = {
+    get installed() {
+        return attrHooks;
+    },
+    withInteraction: withInteraction,
+    withOrigin: withOrigin,
+    currentOrigin: currentOrigin
+};
+
+const RECORDS = Symbol.for("@solidjs/signals/observe/records");
+
+function recordsChannel() {
+    const e = globalThis;
+    if (e[RECORDS]) return e[RECORDS];
+    const n = new Map;
+    return e[RECORDS] = {
+        subscribe(e, t) {
+            const o = n.get(e);
+            // Set semantics: one entry per function, however often it is passed.
+                        if (o === undefined) n.set(e, [ t ]); else if (!o.includes(t)) n.set(e, [ ...o, t ]);
+            return () => {
+                const o = n.get(e);
+                if (o === undefined) return;
+                const r = o.filter(e => e !== t);
+                if (r.length > 0) n.set(e, r); else n.delete(e);
+            };
+        },
+        observed(e) {
+            return n.has(e);
+        },
+        emit(e, t, o) {
+            const r = n.get(e);
+            if (r === undefined) return;
+            // A throwing listener is reported and the rest still hear the record.
+            // The try/catch per call allocates nothing unless something throws.
+                        for (let e = 0; e < r.length; e++) {
+                try {
+                    r[e](t, o);
+                } catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+    };
+}
+
+const OBSERVE = {
+    diagnostics: diagnostics,
+    records: recordsChannel(),
+    attribution: attributionSlot,
+    // Replaced by solid-js's server entry (see `ServerObserve`); on the
+    // client the slot stays this placeholder. The cast: the interface is
+    // empty HERE and gains its members by augmentation downstream.
+    server: {},
+    exclude(e) {
+        excludedOwners.add(e);
+        hasExclusions = true;
+    },
+    isExcluded: isExcluded,
+    ownerPath: ownerPath
+};
+
+// --- Excluded owners ---------------------------------------------------------------
+
+// An observer that lives inside the observed app (an adapter's panel,
+// devtools) marks its root; both channels check the subject's owner chain —
+// the same walk `ownerPath` already makes — and stay silent under it. The
+// flag short-circuits the walk for the common case of no exclusions.
+const excludedOwners = new WeakSet;
+
+let hasExclusions = false;
+
+/** Events built for an excluded subject: never delivered, never reported. */ const suppressedEvents = new WeakSet;
+
+function isExcluded(e) {
+    if (!hasExclusions || !e) return false;
+    let n = "_parent" in e ? e : e.ie ?? null;
+    for (;n !== null; n = n._parent) if (excludedOwners.has(n)) return true;
+    return false;
+}
+
+/** For engines that cache the verdict per node: is anything excluded at all? */ function anyExcluded() {
+    return hasExclusions;
+}
+
+/** Was `entry` built for an excluded subject? Once-per-key reporters must not spend their slot on it. */ function isSuppressed(e) {
+    return suppressedEvents.has(e);
+}
+
+const DEV = undefined;
+
+/**
+ * Root-first names of the owners enclosing `subject` (inclusive when the
+ * subject is itself a named owner). Signals hop to their registering owner
+ * (`_owner`, set by registerGraph). Unnamed owners are skipped so the path
+ * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
+ * Public as `OBSERVE.ownerPath`; the core's own sites import it directly.
+ */ function ownerPath(e) {
+    if (!e) return undefined;
+    let n = "_parent" in e ? e : e.ie ?? null;
+    const t = [];
+    for (;n !== null; n = n._parent) {
+        const e = n._name;
+        if (typeof e === "string" && e.length) t.push(e);
+    }
+    return t.length ? t.reverse() : undefined;
+}
+
+/**
+ * Records a diagnostic on the structured channel (listeners, captures) and
+ * returns the entry. `subject` locates it: the current reactive `context` by
+ * default (right for the synchronous rule checks — they fire inside the
+ * scope that misbehaved); pass the node for scheduler-time findings whose
+ * ambient context is the flush, or `null` for events that have no location
+ * by nature. An `ownerPath` already on the event wins over the subject walk
+ * (hosts whose owners are not signals' owners compute their own). Console
+ * output is a separate, dev-tier step — see `reportDiagnostic`.
+ */ function emitDiagnostic(e, n = context) {
+    const t = {
+        sequence: ++diagnosticSequence,
+        ...e
+    };
+    // The observer's own subtree: build the entry (the caller may throw its
+    // message) but tell nobody.
+        if (isExcluded(n)) {
+        suppressedEvents.add(t);
+        return t;
+    }
+    if (t.ownerPath === undefined) {
+        const e = ownerPath(n);
+        if (e) t.ownerPath = e;
+    }
+    const o = n ?? undefined;
+    if (o !== undefined) eventSubjects.set(t, o);
+    for (const e of diagnosticListeners) e(t, o);
+    for (const e of diagnosticCaptures) e.push(t);
+    return t;
+}
+
+/**
+ * The subject each emitted event was about, for the console step, which
+ * runs after `emitDiagnostic` returned and can show what the node knows: a
+ * rendering runtime may stamp a binding effect with the DOM element it
+ * writes (`_devElement`), and a live element reference beside the message
+ * is the most addressable pointer a console can print. Listeners get the
+ * subject as their second argument instead; the map exists only to carry
+ * it from `emitDiagnostic` to `reportDiagnostic` across the call site's
+ * `reportDiagnostic(emitDiagnostic(…))`. Weak, keyed by the entry.
+ */ const eventSubjects = new WeakMap;
+
+/**
+ * The console face of a diagnostic — ONE entry per finding: the message, the
+ * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
+ * once-per-code footer as trailing lines, and — when the subject is a
+ * binding effect the rendering runtime tagged — the element it writes, as a
+ * second console argument (hover highlights it, click jumps to Elements).
+ * Severity picks the console method. Call sites report the entry
+ * `emitDiagnostic` returned so the structured and console channels never
+ * disagree. Dev-tier: in an observe build this is a no-op, so wiring paths
+ * that both emit and report (graph-size warnings) reach the channel only —
+ * production observability never writes to the console.
+ */ function reportDiagnostic(e) {
+    return;
+}
+
+/**
+ * Observe-tier: stamp a signal with its creating owner so `ownerPath` can
+ * locate signal subjects. The per-owner `_signals` list and the devtools
+ * `onGraph` hook are dev-tier — the observe build pays one property write.
+ */ function registerGraph(e, n) {
+    e.ie = n;
+}
+
+/**
+ * Observe-tier: the live top-level roots — owners created with no parent
+ * (`render()`'s root, a `createRoot()` at module scope, a devtools panel).
+ * Held weakly so an undisposed root nothing references still collects; a
+ * root a subscription keeps alive is exactly the leak `graphSize()` exists
+ * to count. Registered by `createOwner` and released by its disposal, so
+ * the cost is one Set write per top-level root, never per node.
+ */ const liveRoots = new Set;
+
+const rootRefs = new WeakMap;
+
+const rootReaper = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(e => liveRoots.delete(e)) : null;
+
+function registerRoot(e) {
+    // Observe-tier bodies: folded to a bare return in prod so the mangler and
+    // the bundle never see the walk.
+    if (typeof WeakRef !== "function") return;
+    const n = new WeakRef(e);
+    rootRefs.set(e, n);
+    liveRoots.add(n);
+    rootReaper?.register(e, n, n);
+}
+
+function unregisterRoot(e) {
+    const n = rootRefs.get(e);
+    if (n === undefined) return;
+    rootRefs.delete(e);
+    liveRoots.delete(n);
+    rootReaper?.unregister(n);
+}
+
+/**
+ * The live top-level roots, for a walk of the owner tree (the engine's
+ * `graphSize`): dead refs are dropped as they are met. Empty in prod.
+ */ function liveRootOwners() {
+    const e = [];
+    for (const n of liveRoots) {
+        const t = n.deref();
+        if (t === undefined) liveRoots.delete(n); else e.push(t);
+    }
+    return e;
+}
+
+/**
+ * Graph-size warnings are once per node, re-warning only when the count has
+ * grown by GRAPH_SIZE_WARN_EVERY since the last one — off-node, so the
+ * pathological handful of nodes that ever reach the threshold are the only
+ * ones that cost anything, and no node carries a bookkeeping field for it.
+ */ const graphSizeWarnedAt = new WeakMap;
+
+function shouldWarnGraphSize(e, n) {
+    const t = graphSizeWarnedAt.get(e);
+    if (t !== undefined && n < t + GRAPH_SIZE_WARN_EVERY) return false;
+    graphSizeWarnedAt.set(e, n);
+    return true;
+}
+
+/**
+ * Observe-tier: a committed change on `node` is about to re-run `count`
+ * subscribers. Two reporters, one finding, one dedupe: the core counts the
+ * notify walk in `insertSubs` as it goes (fan-out costs exactly one local
+ * increment in a loop that already visits every edge, and nothing at link
+ * time) and fires from GRAPH_SIZE_WARN_AT up, always-on wherever the
+ * channel exists — a graph-size pathology should surface without asking.
+ * The attribution engine, while enabled, reports the same code from its
+ * lower `fanOut` threshold (default 250) on the root writes it stamps, with
+ * the write kind it knows, and hands over to the core at
+ * GRAPH_SIZE_WARN_AT so one change never carries two findings. Both fire on
+ * the write rather than the link: a fan-out that is never written costs
+ * nothing, and one that is re-runs every subscriber this flush. Once per
+ * node, re-warning only once the count has grown by GRAPH_SIZE_WARN_EVERY.
+ */ function noteFanOut(e, n, t) {
+    if (!shouldWarnGraphSize(e, n)) return;
+    const o = e._name;
+    const r = `[HUGE_FAN_OUT] ${o ? `Signal "${o}"` : "A signal"} changed with ${n} subscribers — ` + `every one re-runs this flush. If many independent computations read the same value ` + `(for example every row of a list comparing against one selected id), prefer a per-key ` + `store or projection so only the items whose result flipped update.`;
+    reportDiagnostic(emitDiagnostic({
+        code: "HUGE_FAN_OUT",
+        kind: "graph",
+        severity: "warn",
+        message: r,
+        nodeName: o,
+        ownerId: e.id,
+        ownerName: o,
+        data: t === undefined ? {
+            count: n
+        } : {
+            count: n,
+            write: t
+        }
+    }, e));
+}
+
+/**
+ * Observe-tier: a recompute pass of `node` tracked `count` distinct sources
+ * (its trimmed dep list, walked once at the end of the pass — see recompute;
+ * no per-link work, no pass bracket). Fires from GRAPH_SIZE_WARN_AT up.
+ */ function noteFanIn(e, n) {
+    if (!shouldWarnGraphSize(e, n)) return;
+    const t = e._name;
+    const o = `[HUGE_FAN_IN] ${t ? `Computation "${t}"` : "A computation"} tracked ${n} sources. ` + `It will re-run when any of them change. Narrow the read or split the derivation so each ` + `computation tracks only what it needs.`;
+    reportDiagnostic(emitDiagnostic({
+        code: "HUGE_FAN_IN",
+        kind: "graph",
+        severity: "warn",
+        message: o,
+        nodeName: t,
+        ownerId: e.id,
+        ownerName: t,
+        data: {
+            count: n
+        }
+    }, e));
+}
+
+export { DEV, GRAPH_SIZE_WARN_AT, GRAPH_SIZE_WARN_EVERY, OBSERVE, anyExcluded, emitDiagnostic, isExcluded, isSuppressed, liveRootOwners, noteFanIn, noteFanOut, ownerPath, registerGraph, registerRoot, reportDiagnostic, setConsoleFooter, unregisterRoot };

package/dist/observe/core/effect.js

@@ -0,0 +1,200 @@
+import { REACTIVE_DISPOSED, LANE_RUN, STATUS_ERROR, EFFECT_USER, NOT_PENDING, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
+
+import { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
+
+import { attrHooks } from "./attribution-hooks.js";
+
+import "./dev.js";
+
+import { unwrapStatusError, StatusError } from "./error.js";
+
+import { trimStaleDeps } from "./graph.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { GlobalQueue, currentTransition, activeTransition, haltReactivity, schedule } 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, r, E) {
+    const i = !!E?.user;
+    const n = createEffectNode(t, e, r, i ? EFFECT_USER : EFFECT_RENDER, E);
+    recompute(n, true);
+    // A first pass that derived from a live transaction's staged world was
+    // staged into that transaction (recompute: born held); the transaction's
+    // commit replays this effect. Its first run is not this creation's (A29).
+        !E?.defer && n._e === NOT_PENDING && (n.He === EFFECT_USER || E?.schedule ? n.T.enqueue(n.He, runEffect.bind(null, n)) : runEffect(n, LANE_RUN));
+}
+
+function notifyEffectStatus(t, e) {
+    // Use passed values if provided, otherwise read from node
+    const r = t !== undefined ? t : this.S;
+    const E = e !== undefined ? e : this.o?._;
+    if (r & STATUS_ERROR) {
+        this.T.notify(this, STATUS_PENDING, 0);
+        if (this.He === 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.it = true;
+                this.T.enqueue(this.He, this.Ct ??= runEffect.bind(null, this));
+            }
+            return;
+        }
+        if (!this.T.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(unwrapStatusError(E));
+            throw E;
+        }
+    } else if (this.He === EFFECT_RENDER) {
+        this.T.notify(this, STATUS_PENDING | STATUS_ERROR, r, E);
+    }
+}
+
+function runEffect(t, e) {
+    if (!t.it || t.oe & REACTIVE_DISPOSED) return;
+    // Ownership (#3319): a value computed under a transaction is applied by that
+    // transaction's commit. The ordinary effect phase runs with a transaction
+    // active only when the flush's finalize ENTERED one (every other path parks
+    // or settles first): leave a run owned by a still-held transaction queued —
+    // `_modified` stays set — and the next gate stashes it with the owner.
+    // Mainline-owned runs (null) apply now. Lanes are exempt by design (they
+    // apply their own effects ahead of their transaction — the optimistic view)
+    // and mark their runs with LANE_RUN.
+    
+    // Lane exemption has one exception (#3331): a lane runner for an effect that
+    // no longer rides a lane — its optimistic source was superseded, so the lane
+    // has no optimistic view left to apply, and the value this effect now
+    // carries (or will, once its plain recompute lands) belongs to the still-held
+    // transaction. Hand the run to the regular queue, where the transaction's
+    // gate stashes it with the owner. Lane-less runners with no live owner
+    // (reverts, wake-only lanes) apply now.
+        if (t.Gt !== null && !currentTransition(t.Gt).Dt && (e & LANE_RUN ? !t.o?.Ce : activeTransition !== null)) {
+        t.T.enqueue(t.He, t.Ct);
+        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.He === EFFECT_USER) {
+        const e = unwrapStatusError(t.o?._);
+        t.Mt = t.ce;
+        t.it = false;
+        try {
+            t.Wt ? t.Wt(e, () => {
+                const e = t.qt;
+                t.qt = undefined;
+                e?.();
+            }) : console.error(e);
+        } catch (e) {
+            if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+                haltReactivity(e);
+                throw e;
+            }
+        }
+        return;
+    }
+    // Captured before the callback: its own throw errors the node below, but
+    // the compute pass that produced `_value` was clean, so its tail still goes.
+        const r = t.o?._ == null;
+    // Observe tier, like its `effectRunEnd` twin below: the frame the engine
+    // opens here is what stamps the callback's writes as the effect's (the
+    // cascade an observer reports) and what times the callback (the `effect`
+    // record) — facts a production observer needs, not only a dev console.
+        if (attrHooks !== null) attrHooks.effectRunStart(t);
+    const E = t.qt;
+    t.qt = undefined;
+    try {
+        E?.();
+        const e = t.wt(t.ce, t.Mt);
+        if (false && e !== undefined && typeof e !== "function") ;
+        // The final cleanup is invoked by disposeChildren at true disposal.
+                t.qt = e;
+    } catch (e) {
+        ext(t)._ = new StatusError(t, e);
+        t.S |= STATUS_ERROR;
+        if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(e);
+            throw e;
+        }
+    } finally {
+        t.Mt = t.ce;
+        t.it = false;
+        // The run applied: this is the frame now, so the dependency tail the
+        // compute pass left linked goes (A30, #3438 — `recompute` defers an
+        // effect's trim while a run is owed; the twin of `commitPendingNode`'s
+        // trim for a staged pass). An errored compute kept its full list with
+        // `_depsTail` marking where it stopped; leave it, as the commit does.
+                if (r) trimStaleDeps(t);
+    }
+    // Outside the try (see the rule in attribution-hooks.ts). Reached whether or
+    // not the callback threw — a throw that escapes the catch above halts.
+        if (attrHooks !== null) attrHooks.effectRunEnd(t);
+}
+
+GlobalQueue.Rt = 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 = () => {
+        // `_modified` is NOT redundant with the heap: the heap dedups within a
+        // pass, but a held transition's passes each enqueue `_run` into the same
+        // user queue, and this gate is what collapses them into one run at commit.
+        if (!r.it || r.oe & REACTIVE_DISPOSED) return;
+        try {
+            r.it = false;
+            recompute(r);
+        } finally {}
+    };
+    const r = computed(() => {
+        const e = r.qt;
+        r.qt = undefined;
+        e?.();
+        const E = staleValues(t);
+        r.qt = E;
+    }, {
+        ...e,
+        lazy: true
+    });
+    r.qt = undefined;
+    r.C = r.C & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    r.it = true;
+    r.He = EFFECT_TRACKED;
+    // Observe-tier label: the computed literal defaulted its `_name` slot to
+    // "computed"; relabel by kind (a store into the slot, not a new field).
+        if (e?.name === undefined) r._name = "trackedEffect";
+    // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
+    // _type): its error arm is behavior-identical to the closure that used to
+    // live here, without the per-node NodeExtension allocation.
+        r.lt = run;
+    // The first run rides the heap like every wake (GlobalQueue._update), so a
+    // tracked effect created inside a render-effect callback runs after that
+    // pass's staged writes commit, not before.
+        enqueueSub(r);
+    schedule();
+}
+
+// Install the shared effect status notifier (statusNotifierOf serves it to
+// every effect node) — module-scope: any bundle that creates effects
+// evaluates this module.
+setEffectStatusNotify(notifyEffectStatus);
+
+export { effect, trackedEffect };

package/dist/observe/core/error-hooks.js

@@ -0,0 +1,71 @@
+import { ROOT_ERROR_HOOK } from "./scheduler.js";
+
+let ambientHook;
+
+const reported = new WeakSet;
+
+/**
+ * Registers the ambient client error hook — the one call a browser `init()`
+ * makes to see every failure a boundary renders a fallback for, in
+ * production. (Uncaught errors reach `reportError` / `window.onerror`.)
+ *
+ * ```ts
+ * configureClientErrors({
+ *   onError: (error, { ownerPath }) =>
+ *     Sentry.captureException(error, {
+ *       mechanism: { type: "solid.error_boundary", handled: true }
+ *     })
+ * });
+ * ```
+ */ function configureClientErrors(e) {
+    if (e && e.onError !== undefined && typeof e.onError !== "function") {
+        throw new TypeError(`Invalid onError: expected a function, received ${typeof e.onError}.`);
+    }
+    ambientHook = e ? e.onError : undefined;
+}
+
+/** The nearest root's hook above `owner` (parked under `ROOT_ERROR_HOOK`), else the ambient one. */ function hookFor(e) {
+    for (let n = e; n; n = n._parent) {
+        const e = n[ROOT_ERROR_HOOK];
+        if (e !== undefined) return e;
+    }
+    return ambientHook;
+}
+
+/** Component labels up the owner chain, root first — `_name` where the runtime keeps it. */ function labels(e) {
+    const n = [];
+    for (let o = e; o; o = o._parent) {
+        const e = o._name;
+        if (typeof e === "string" && e.length) n.push(e);
+    }
+    return n.length ? n.reverse() : undefined;
+}
+
+/**
+ * Tells the client error hook about `error`, caught by the boundary whose
+ * owner is `owner`, thrown by `thrower` (the computation the engine's status
+ * wrapper named; unknown for a value that never crossed one) — once per
+ * error object. A throwing hook is reported on the console and otherwise
+ * ignored — a monitor must never take the app down.
+ * @internal
+ */ function reportClientError(e, n, o) {
+    const r = e !== null && (typeof e === "object" || typeof e === "function");
+    if (r) {
+        if (reported.has(e)) return;
+        reported.add(e);
+    }
+    const t = hookFor(n);
+    if (t === undefined) return;
+    const i = {};
+    const f = labels(n);
+    const c = labels(o) ?? f;
+    if (c !== undefined) i.ownerPath = c;
+    if (f !== undefined) i.boundaryPath = f;
+    try {
+        t(e, i);
+    } catch (e) {
+        console.error(e);
+    }
+}
+
+export { configureClientErrors, reportClientError };

package/dist/observe/core/error.js

@@ -0,0 +1,80 @@
+/**
+ * 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;
+}
+
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */ class TimeoutError extends Error {
+    constructor(r = "Timed out waiting for condition") {
+        super(r);
+        this.name = "TimeoutError";
+    }
+}
+
+class NoOwnerError extends Error {
+    constructor() {
+        super("");
+    }
+}
+
+class ContextNotFoundError extends Error {
+    constructor() {
+        super("");
+    }
+}
+
+export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, TimeoutError, unwrapStatusError };