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

package/dist/prod/core/dev.js

@@ -1,4 +1,10 @@
-import "./core.js";
+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
@@ -11,10 +17,109 @@ import "./core.js";
  * @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(o) {
+ */ 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, setConsoleFooter };
+/**
+ * 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

@@ -22,7 +22,8 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
     // 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.ie === NOT_PENDING && !f.T?.Re?.P && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : runEffect(f, f.i));
+        !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() {
@@ -44,18 +45,20 @@ function notifyEffectStatus() {
             return;
         }
         // Dev locates the halt at the node that threw: the StatusError's
-        // source, upstream of this effect when a computed failed.
-                escalate(this, unwrapStatusError(e), e, this);
+        // 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`, `thrown` rethrown; dev locates it at `subject`. */ function escalate(t, e, E = e, u = t) {
+ * 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;
+        throw e;
     }
 }
 
@@ -66,10 +69,12 @@ function runEffect(t, e) {
     // 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 is not a queued
-    // run and goes through. `_modified` stays set; the boundary re-queues the
-    // run (`release`).
-        if (heldRunHook?.(t)) return;
+    // 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
@@ -82,12 +87,12 @@ function runEffect(t, e) {
     // 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.ke = t.le;
+        t.ge = t.le;
         t.Ae = false;
         try {
-            t.qe ? t.qe(e, () => {
-                const e = t.Je;
-                t.Je = undefined;
+            t.Je ? t.Je(e, () => {
+                const e = t.ze;
+                t.ze = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
@@ -98,20 +103,20 @@ function runEffect(t, e) {
     // 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.Je;
-    t.Je = undefined;
+    const u = t.ze;
+    t.ze = undefined;
     try {
         u?.();
-        const e = t.Ke(t.le, t.ke);
+        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.Je = e;
+                t.ze = e;
     } catch (e) {
         ext(t).U = new StatusError(t, e);
         t.m |= STATUS_ERROR;
         escalate(t, e);
     } finally {
-        t.ke = t.le;
+        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
@@ -122,7 +127,7 @@ function runEffect(t, e) {
     }
 }
 
-GlobalQueue.K = runEffect;
+GlobalQueue.q = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -141,16 +146,16 @@ GlobalQueue.K = runEffect;
         } finally {}
     };
     const E = computed(() => {
-        const e = E.Je;
-        E.Je = undefined;
+        const e = E.ze;
+        E.ze = undefined;
         e?.();
         const u = staleValues(t);
-        E.Je = u;
+        E.ze = u;
     }, {
         ...e,
         lazy: true
     });
-    E.Je = undefined;
+    E.ze = undefined;
     E.l = E.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     E.Ae = true;
     E.i = EFFECT_TRACKED;

package/dist/prod/core/graph.js

@@ -20,8 +20,8 @@ function unlinkSubs(e) {
     const n = e.S;
     const l = e.G;
     const o = e.t;
-    const s = e.Xe;
-    if (o !== null) o.Xe = s; else n.ve = s;
+    const s = e.$e;
+    if (o !== null) o.$e = s; else n.Ze = s;
     if (s !== null) s.t = o; else {
         n.o = o;
         if (o === null) {
@@ -29,7 +29,7 @@ function unlinkSubs(e) {
             // unobserved closure, no NodeExtension to hold it.
             // A user hook that throws is collected like a cleanup (owner.ts): the
             // unlink and the teardown around it carry on.
-            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.we) runCleanup(n.T.we);
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.Ye) runCleanup(n.T.Ye);
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work is an observer —
             // tearing down would orphan the work and re-execute it on the next
@@ -133,7 +133,7 @@ function link(e, n) {
     if (s) {
         o = l !== null ? l.G : n.C;
         if (o !== null && o.S === e) {
-            o.de = n.Ne;
+            o.Ne = n.de;
             n._ = o;
             return;
         }
@@ -143,15 +143,15 @@ function link(e, n) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const r = e.ve;
-    if (r !== null && r.u === n && (!s || r.de === n.Ne)) return;
-    const t = n._ = e.ve = {
+        const r = e.Ze;
+    if (r !== null && r.u === n && (!s || r.Ne === n.de)) return;
+    const t = n._ = e.Ze = {
         S: e,
         u: n,
         G: o,
-        Xe: r,
+        $e: r,
         t: null,
-        de: n.Ne
+        Ne: n.de
     };
     if (l !== null) l.G = t; else n.C = t;
     if (r !== null) r.t = t; else e.o = t;

package/dist/prod/core/heap.js

@@ -16,17 +16,17 @@ import { dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Qe ? e._parent.Ye?.he : e._parent?.he) ?? -1;
+    const E = (e._parent?.Qe ? e._parent.Ke?.he : e._parent?.he) ?? -1;
     if (E >= e.he) e.he = E + 1;
     const n = e.he;
-    const I = t.$e[n];
-    if (I === undefined) t.$e[n] = e; else {
+    const I = t.et[n];
+    if (I === undefined) t.et[n] = e; else {
         const t = I.We;
-        t.be = e;
+        t.ve = e;
         e.We = t;
         I.We = e;
     }
-    if (n > t.et) t.et = n;
+    if (n > t.Et) t.Et = n;
 }
 
 function insertIntoHeap(e, t) {
@@ -66,22 +66,22 @@ function deleteFromHeap(e, t) {
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
     const n = e.he;
-    if (e.We === e) t.$e[n] = undefined; else {
-        const E = e.be;
-        const I = t.$e[n];
+    if (e.We === e) t.et[n] = undefined; else {
+        const E = e.ve;
+        const I = t.et[n];
         const i = E ?? I;
-        if (e === I) t.$e[n] = E; else e.We.be = E;
+        if (e === I) t.et[n] = E; else e.We.ve = E;
         i.We = e.We;
     }
     e.We = e;
-    e.be = undefined;
+    e.ve = undefined;
 }
 
 function markHeap(e) {
     if (e.p) return;
     e.p = true;
-    for (let t = 0; t <= e.et; t++) {
-        for (let E = e.$e[t]; E !== undefined; E = E.be) {
+    for (let t = 0; t <= e.Et; t++) {
+        for (let E = e.et[t]; E !== undefined; E = E.ve) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
@@ -98,14 +98,14 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.p = false;
-    for (e.Fe = 0; e.Fe <= e.et; e.Fe++) {
-        let E = e.$e[e.Fe];
+    for (e.Fe = 0; e.Fe <= e.Et; e.Fe++) {
+        let E = e.et[e.Fe];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.$e[e.Fe];
+            E = e.et[e.Fe];
         }
     }
-    e.et = 0;
+    e.Et = 0;
 }
 
 function adjustHeight(e, t) {

package/dist/prod/core/identities.js

@@ -31,7 +31,7 @@ function identify(n) {
     if (!e) return;
     while (e.l & CONFIG_TRANSPARENT && e._parent) e = e._parent;
     if (e.id == null) return;
-    const t = e.Ne;
+    const t = e.de;
     let i = counts.get(e);
     if (i === undefined || i[0] !== t) counts.set(e, i = [ t, 0 ]);
     const s = e.id + "~" + i[1]++;