@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/observe/core/dev.js

@@ -0,0 +1,394 @@
+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 ];
+            }
+        };
+    }
+};
+
+// Flight identity → earliest declared start (see `AttributionSlot.markFlight`).
+// Weak: a stamp must not keep a settled promise alive.
+const flightOrigins = new WeakMap;
+
+const attributionSlot = {
+    get installed() {
+        return attrHooks;
+    },
+    withInteraction: withInteraction,
+    withOrigin: withOrigin,
+    currentOrigin: currentOrigin,
+    markFlight(e, n = performance.now()) {
+        // Earliest wins (`undefined <= n` is false: the first mark always lands).
+        if (!(flightOrigins.get(e) <= n)) flightOrigins.set(e, n);
+    },
+    flightOrigin: e => flightOrigins.get(e)
+};
+
+const RECORDS = Symbol.for("@solidjs/signals/observe/records");
+
+function recordsChannel() {
+    const e = globalThis;
+    if (e[RECORDS]) return e[RECORDS];
+    const n = new Map;
+    const t = new Map;
+    return e[RECORDS] = {
+        subscribe(e, i, o) {
+            const r = n.get(e);
+            // Set semantics: one entry per function, however often it is passed —
+            // the first subscription's options stand for it.
+                        if (r === undefined || !r.includes(i)) {
+                n.set(e, r === undefined ? [ i ] : [ ...r, i ]);
+                if (o !== undefined && o.bodies) {
+                    let n = t.get(e);
+                    if (n === undefined) t.set(e, n = new Set);
+                    n.add(i);
+                }
+            }
+            return () => {
+                const o = n.get(e);
+                if (o === undefined || !o.includes(i)) return;
+                const r = o.filter(e => e !== i);
+                if (r.length > 0) n.set(e, r); else n.delete(e);
+                const s = t.get(e);
+                if (s !== undefined && s.delete(i) && s.size === 0) t.delete(e);
+            };
+        },
+        observed(e, i) {
+            return i === "bodies" ? t.has(e) : n.has(e);
+        },
+        emit(e, t, i) {
+            const o = n.get(e);
+            if (o === 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 < o.length; e++) {
+                try {
+                    o[e](t, i);
+                } 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) {
+        markedOwners.set(e, true);
+        hasExclusions = true;
+    },
+    include(e) {
+        // No flag flip: with nothing excluded there is nothing to re-admit,
+        // and the walk stays short-circuited.
+        markedOwners.set(e, false);
+    },
+    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. An
+// observer that WRAPS the app (a toolbar around it) excludes its own root
+// and includes the app's back: one map, `true` excluded / `false` included,
+// and the nearest marker up the chain decides. The flag short-circuits the
+// walk for the common case of no exclusions (an include with nothing
+// excluded changes no verdict, so it does not flip it).
+const markedOwners = new WeakMap;
+
+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.H ?? null;
+    for (;n !== null; n = n._parent) {
+        const e = markedOwners.get(n);
+        if (e !== undefined) return e;
+    }
+    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.H ?? 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;
+}
+
+/**
+ * The innermost source location on the subject's chain: the subject's own
+ * `_loc` (a signal or computation created with `{ loc }`), else the first
+ * `_loc` up the owners — a signal hops to its registering owner, then
+ * `_parent` upward (a component root carries its JSX site). The same walk
+ * `ownerPath` makes; `undefined` when nothing on the chain was located.
+ */ function locationOf(e) {
+    // Owners have a `_parent` key (null on a root); a signal has none and hops
+    // to its registering `_owner` instead.
+    for (let n = e; n; n = n._parent !== undefined ? n._parent : n.H) if (n._loc) return n._loc;
+    return 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` (or `loc`) 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;
+    }
+    if (t.loc === undefined) {
+        const e = locationOf(n);
+        if (e !== undefined) t.loc = e;
+    }
+    const i = n ?? undefined;
+    if (i !== undefined) eventSubjects.set(t, i);
+    for (const e of diagnosticListeners) e(t, i);
+    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
+ * source location (`at src/App.tsx:18:3` — see `locationLine`) when a node on
+ * the chain was compiled with one, 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.H = 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 i = e._name;
+    const o = `[HUGE_FAN_OUT] ${i ? `Signal "${i}"` : "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: o,
+        nodeName: i,
+        ownerId: e.id,
+        ownerName: i,
+        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 i = `[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: i,
+        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,193 @@
+import { NOT_PENDING, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, REACTIVE_DISPOSED, STATUS_ERROR, STATUS_PENDING } from "./constants.js";
+
+import { createEffectNode, recompute, computed, staleValues, ext, setEffectStatusNotify } 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, schedule, heldRunHook, haltReactivity, GlobalQueue } 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, o, r) {
+    const u = !!r?.user;
+    const E = createEffectNode(t, e, o, u ? EFFECT_USER : EFFECT_RENDER, r);
+    recompute(E, true);
+    // A first pass that read a staged value was staged itself (recompute: born
+    // staged); the flush's commit replays this effect. Its first run is not this
+    // creation's (A29). A lane's node likewise: its run is the lane's, queued
+    // by the pass and released at the reveal (lanes.ts).
+        !r?.defer && E.ue === NOT_PENDING && !E.T?.Je?.V && (E.i === EFFECT_USER || r?.schedule ? globalQueue.enqueue(E.i, runEffect.bind(null, E)) : // Type 0: the synchronous first render, not a queued run (D-19).
+    runEffect(E, 0));
+}
+
+function notifyEffectStatus() {
+    const t = this.m;
+    const e = this.T?.U;
+    if (t & STATUS_ERROR) {
+        globalQueue.notify(this, STATUS_PENDING, 0);
+        if (this.i === 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 and throws escalate the same way. 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. (Re-read: the boundary
+            // notify above can run a redraw.)
+            if (this.m & STATUS_ERROR) {
+                this.Qe = true;
+                globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
+            }
+            return;
+        }
+        // Dev locates the halt at the node that threw: the StatusError's
+        // source, upstream of this effect when a computed failed. The rethrow is
+        // the user's error, not the wrapper: the wrapper's `source` is a node, and
+        // a reporter that serializes the throw walks the reactive graph.
+                escalate(this, unwrapStatusError(e), this);
+    } else if (this.i === EFFECT_RENDER) {
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, t, e);
+    }
+}
+
+/** An effect's error no boundary takes halts the system (boundary-or-halt):
+ * halted with `cause` and rethrown; dev locates it at `subject`. */ function escalate(t, e, o = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw e;
+    }
+}
+
+function runEffect(t, e) {
+    if (!t.Qe || t.R & REACTIVE_DISPOSED) return;
+    // A queued run behind a fallback (boundaries.ts) waits for the reveal: a
+    // user effect's, which would read a DOM that is not attached, and a render
+    // effect's update too (maintainer, 2026-10-02: "we held the queue but let
+    // the sync renders through… we definitely shouldn't be showing portals
+    // early") — a Portal's or head-tag's render effect writes outside the
+    // hidden subtree. The synchronous first render on creation (`type` 0) is
+    // not a queued run and goes through, whichever boundary above is on its
+    // fallback then — an outer one about to reveal in this flush included
+    // (#4343). `_modified` stays set; the boundary re-queues the run
+    // (`release`).
+        if (e && heldRunHook?.(t)) 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.m & STATUS_ERROR && t.i === EFFECT_USER) {
+        const e = unwrapStatusError(t.T?.U);
+        t.It = t.le;
+        t.Qe = false;
+        try {
+            t.kt ? t.kt(e, () => {
+                const e = t.Vt;
+                t.Vt = undefined;
+                e?.();
+            }) : console.error(e);
+        } catch (e) {
+            escalate(t, 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 o = t.T?.U == 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 r = t.Vt;
+    t.Vt = undefined;
+    try {
+        r?.();
+        const e = t.Ge(t.le, t.It);
+        if (false && e !== undefined && typeof e !== "function") ;
+        // The final cleanup is invoked by disposeChildren at true disposal.
+                t.Vt = e;
+    } catch (e) {
+        ext(t).U = new StatusError(t, e);
+        t.m |= STATUS_ERROR;
+        escalate(t, e);
+    } finally {
+        t.It = t.le;
+        t.Qe = 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 (o) 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.q = 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 several passes in one flush each enqueue `_run` into the same
+        // user queue, and this gate is what collapses them into one run.
+        if (!o.Qe || o.R & REACTIVE_DISPOSED) return;
+        if (heldRunHook?.(o)) return;
+        try {
+            o.Qe = false;
+            recompute(o);
+        } finally {}
+    };
+    const o = computed(() => {
+        const e = o.Vt;
+        o.Vt = undefined;
+        e?.();
+        const r = staleValues(t);
+        o.Vt = r;
+    }, {
+        ...e,
+        lazy: true
+    });
+    o.Vt = undefined;
+    o.l = o.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    o.Qe = true;
+    o.i = 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) o._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.
+        o.Z = 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(o);
+    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 };