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

package/dist/prod/core/dev.js

@@ -1,3 +1,125 @@
+import { context } from "./core.js";
+
+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;
+}
+
+/** Events built for an excluded subject: never delivered, never reported. */ const suppressedEvents = new WeakSet;
+
+function isExcluded(e) {
+    return false;
+}
+
 const DEV = undefined;
 
-export { DEV };
+/**
+ * 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()) {
+        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 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
+ * 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;
+}
+
+export { DEV, emitDiagnostic, isExcluded, ownerPath, reportDiagnostic, setConsoleFooter };

package/dist/prod/core/effect.js

@@ -1,55 +1,80 @@
-import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
+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 { ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
+import { createEffectNode, recompute, computed, staleValues, ext, setEffectStatusNotify } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
-import { GlobalQueue, haltReactivity } from "./scheduler.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, E, R) {
-    const r = !!R?.user;
-    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
+ */ function effect(t, e, E, u) {
+    const r = !!u?.user;
+    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, u);
     recompute(f, true);
-    !R?.defer && (f.Re === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f));
+    // 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).
+        !u?.defer && f.ue === NOT_PENDING && !f.T?.Re?.P && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : // Type 0: the synchronous first render, not a queued run (D-19).
+    runEffect(f, 0));
 }
 
-function notifyEffectStatus(t, e) {
-    // Use passed values if provided, otherwise read from node
-    const E = t !== undefined ? t : this.S;
-    const R = e !== undefined ? e : this.o?._;
-    if (E & STATUS_ERROR) {
-        this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Re === EFFECT_USER) {
+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, 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`,
+            // 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. 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.Xe = true;
-                this.C.enqueue(this.Re, this.et ??= runEffect.bind(null, this));
+            // phase takes the success arm instead. (Re-read: the boundary
+            // notify above can run a redraw.)
+            if (this.m & STATUS_ERROR) {
+                this.Ae = true;
+                globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(R));
-            throw R;
-        }
-    } else if (this.Re === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, R);
+        // 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);
     }
 }
 
-function runEffect(t) {
-    if (!t.Xe || t.ie & REACTIVE_DISPOSED) return;
+/** 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, E = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw e;
+    }
+}
+
+function runEffect(t, e) {
+    if (!t.Ae || 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
@@ -60,46 +85,49 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
-        const e = unwrapStatusError(t.o?._);
-        t.Tt = t.be;
-        t.Xe = false;
+        if (t.m & STATUS_ERROR && t.i === EFFECT_USER) {
+        const e = unwrapStatusError(t.T?.U);
+        t.ge = t.le;
+        t.Ae = false;
         try {
-            t.St ? t.St(e, () => {
-                const e = t.At;
-                t.At = undefined;
+            t.Je ? t.Je(e, () => {
+                const e = t.ze;
+                t.ze = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(e);
-                throw e;
-            }
+            escalate(t, e);
         }
         return;
     }
-    const e = t.At;
-    t.At = undefined;
+    // 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 E = t.T?.U == null;
+    const u = t.ze;
+    t.ze = undefined;
     try {
-        e?.();
-        const E = t.dt(t.be, t.Tt);
-        if (false && E !== undefined && typeof E !== "function") ;
+        u?.();
+        const e = t.qe(t.le, t.ge);
+        if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.At = E;
+                t.ze = e;
     } catch (e) {
-        ext(t)._ = new StatusError(t, e);
-        t.S |= STATUS_ERROR;
-        if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(e);
-            throw e;
-        }
+        ext(t).U = new StatusError(t, e);
+        t.m |= STATUS_ERROR;
+        escalate(t, e);
     } finally {
-        t.Tt = t.be;
-        t.Xe = false;
+        t.ge = t.le;
+        t.Ae = 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 (E) trimStaleDeps(t);
     }
 }
 
-GlobalQueue.tt = runEffect;
+GlobalQueue.q = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -107,39 +135,44 @@ GlobalQueue.tt = runEffect;
  * Uses stale reads.
  */ function trackedEffect(t, e) {
     const run = () => {
-        if (!E.Xe || E.ie & REACTIVE_DISPOSED) return;
+        // `_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 (!E.Ae || E.R & REACTIVE_DISPOSED) return;
+        if (heldRunHook?.(E)) return;
         try {
-            E.Xe = false;
+            E.Ae = false;
             recompute(E);
         } finally {}
     };
     const E = computed(() => {
-        const e = E.At;
-        E.At = undefined;
+        const e = E.ze;
+        E.ze = undefined;
         e?.();
-        const R = staleValues(t);
-        E.At = R;
+        const u = staleValues(t);
+        E.ze = u;
     }, {
         ...e,
         lazy: true
     });
-    E.At = undefined;
-    E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    E.Xe = true;
-    E.Re = EFFECT_TRACKED;
-    ext(E).A = (t, e) => {
-        const R = t !== undefined ? t : E.S;
-        if (R & STATUS_ERROR) {
-            E.C.notify(E, STATUS_PENDING, 0);
-            const t = e !== undefined ? e : E.o?._;
-            if (!E.C.notify(E, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(unwrapStatusError(t));
-                throw t;
-            }
-        }
-    };
-    E.Ut = run;
-    E.C.enqueue(EFFECT_USER, run);
+    E.ze = undefined;
+    E.l = E.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    E.Ae = true;
+    E.i = EFFECT_TRACKED;
+    // 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.
+        E.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(E);
+    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/prod/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/prod/core/error.js

@@ -23,7 +23,6 @@
  * ```
  */
 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 —
@@ -40,9 +39,12 @@ class NotReadyError extends Error {
 }
 
 class StatusError extends Error {
-    source;
     constructor(r, o) {
-        super(o instanceof Error ? o.message : String(o), {
+        // Best-effort message: formatting must never replace the original (#4112).
+        try {
+            var t = String(o instanceof Error ? o.message : o);
+        } catch {}
+        super(t, {
             cause: o
         });
         this.source = r;
@@ -53,6 +55,18 @@ class StatusError extends Error {
     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("");
@@ -65,4 +79,4 @@ class ContextNotFoundError extends Error {
     }
 }
 
-export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, unwrapStatusError };
+export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, TimeoutError, unwrapStatusError };

package/dist/prod/core/external.js

@@ -2,7 +2,7 @@ import { signal, setSignal, read } from "./core.js";
 
 import { cleanup } from "./owner.js";
 
-import { GlobalQueue } from "./scheduler.js";
+import { setExternalHooks } from "./scheduler.js";
 
 let externalSourceConfig = null;
 
@@ -37,7 +37,7 @@ let externalSourceConfig = null;
  * ```
  */
 // Wires a freshly created computed through the active external-source bridge.
-// Lives here (installed on GlobalQueue while a config is active) rather than
+// Lives here (installed as a scheduler hook while a config is active) rather than
 // inline in core: esbuild cannot literal-track the mutable config binding the
 // way rollup does, so an inline `if (externalSourceConfig)` block ships in
 // every bundle even though only enableExternalSource() can make it reachable.
@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.Se, () => {
+    const r = externalSourceConfig.factory(e.X, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.Se = e => {
+    e.X = e => {
         read(n);
         return r.track(e);
     };
@@ -61,11 +61,10 @@ function externalUntrack(e) {
 }
 
 // The hooks mirror the config's liveness exactly (installed on enable,
-// removed on reset) so core's null checks stay equivalent to the old
+// removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Rt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.Gt = externalSourceConfig ? externalUntrack : null;
+    if (externalSourceConfig) setExternalHooks(wireExternalSource, externalUntrack); else setExternalHooks(undefined, undefined);
 }
 
 function enableExternalSource(e) {