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

package/dist/observe/core/effect.js

@@ -26,12 +26,13 @@ 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).
-        !r?.defer && E.ie === NOT_PENDING && !E.T?.Je?.V && (E.i === EFFECT_USER || r?.schedule ? globalQueue.enqueue(E.i, runEffect.bind(null, E)) : runEffect(E, E.i));
+        !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?.F;
+    const e = this.T?.U;
     if (t & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
@@ -48,18 +49,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, o = e, r = t) {
+ * 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 o;
+        throw e;
     }
 }
 
@@ -70,10 +73,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
@@ -85,13 +90,13 @@ function runEffect(t, e) {
     // 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?.F);
-        t._t = t.le;
+        const e = unwrapStatusError(t.T?.U);
+        t.It = t.le;
         t.Qe = false;
         try {
-            t.Ht ? t.Ht(e, () => {
-                const e = t.kt;
-                t.kt = undefined;
+            t.kt ? t.kt(e, () => {
+                const e = t.Vt;
+                t.Vt = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
@@ -101,26 +106,26 @@ 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 o = t.T?.F == null;
+        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.kt;
-    t.kt = undefined;
+    const r = t.Vt;
+    t.Vt = undefined;
     try {
         r?.();
-        const e = t.Ge(t.le, t._t);
+        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.kt = e;
+                t.Vt = e;
     } catch (e) {
-        ext(t).F = new StatusError(t, e);
+        ext(t).U = new StatusError(t, e);
         t.m |= STATUS_ERROR;
         escalate(t, e);
     } finally {
-        t._t = t.le;
+        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
@@ -134,7 +139,7 @@ function runEffect(t, e) {
         if (attrHooks !== null) attrHooks.effectRunEnd(t);
 }
 
-GlobalQueue.K = runEffect;
+GlobalQueue.q = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -153,16 +158,16 @@ GlobalQueue.K = runEffect;
         } finally {}
     };
     const o = computed(() => {
-        const e = o.kt;
-        o.kt = undefined;
+        const e = o.Vt;
+        o.Vt = undefined;
         e?.();
         const r = staleValues(t);
-        o.kt = r;
+        o.Vt = r;
     }, {
         ...e,
         lazy: true
     });
-    o.kt = undefined;
+    o.Vt = undefined;
     o.l = o.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     o.Qe = true;
     o.i = EFFECT_TRACKED;

package/dist/observe/core/graph.js

@@ -21,7 +21,7 @@ function unlinkSubs(e) {
     const l = e.G;
     const o = e.t;
     const s = e.en;
-    if (o !== null) o.en = s; else n.Ct = s;
+    if (o !== null) o.en = s; else n.Ot = 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?.Dt) runCleanup(n.T.Dt);
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.Gt) runCleanup(n.T.Gt);
             // 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.Ie = n.Ne;
+            o.de = n.Ne;
             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.Ct;
-    if (r !== null && r.u === n && (!s || r.Ie === n.Ne)) return;
-    const t = n._ = e.Ct = {
+        const r = e.Ot;
+    if (r !== null && r.u === n && (!s || r.de === n.Ne)) return;
+    const t = n._ = e.Ot = {
         S: e,
         u: n,
         G: o,
         en: r,
         t: null,
-        Ie: n.Ne
+        de: n.Ne
     };
     if (l !== null) l.G = t; else n.C = t;
     if (r !== null) r.t = t; else e.o = t;

package/dist/observe/core/heap.js

@@ -11,22 +11,22 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.lt > e.Et) dirtyQueue.lt = e.Et;
+    if (dirtyQueue.Et > e.lt) dirtyQueue.Et = e.lt;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Pt ? e._parent.ht?.Et : e._parent?.Et) ?? -1;
-    if (E >= e.Et) e.Et = E + 1;
-    const n = e.Et;
-    const I = t.gt[n];
-    if (I === undefined) t.gt[n] = e; else {
-        const t = I.Rt;
-        t.At = e;
-        e.Rt = t;
-        I.Rt = e;
+    const E = (e._parent?.Pt ? e._parent.Ht?.lt : e._parent?.lt) ?? -1;
+    if (E >= e.lt) e.lt = E + 1;
+    const n = e.lt;
+    const I = t.jt[n];
+    if (I === undefined) t.jt[n] = e; else {
+        const t = I.Ct;
+        t.Rt = e;
+        e.Ct = t;
+        I.Ct = e;
     }
-    if (n > t.jt) t.jt = n;
+    if (n > t.yt) t.yt = n;
 }
 
 function insertIntoHeap(e, t) {
@@ -65,23 +65,23 @@ function deleteFromHeap(e, t) {
     const E = e.R;
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
-    const n = e.Et;
-    if (e.Rt === e) t.gt[n] = undefined; else {
-        const E = e.At;
-        const I = t.gt[n];
+    const n = e.lt;
+    if (e.Ct === e) t.jt[n] = undefined; else {
+        const E = e.Rt;
+        const I = t.jt[n];
         const i = E ?? I;
-        if (e === I) t.gt[n] = E; else e.Rt.At = E;
-        i.Rt = e.Rt;
+        if (e === I) t.jt[n] = E; else e.Ct.Rt = E;
+        i.Ct = e.Ct;
     }
-    e.Rt = e;
-    e.At = undefined;
+    e.Ct = e;
+    e.Rt = undefined;
 }
 
 function markHeap(e) {
     if (e.p) return;
     e.p = true;
-    for (let t = 0; t <= e.jt; t++) {
-        for (let E = e.gt[t]; E !== undefined; E = E.At) {
+    for (let t = 0; t <= e.yt; t++) {
+        for (let E = e.jt[t]; E !== undefined; E = E.Rt) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
@@ -98,25 +98,25 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.p = false;
-    for (e.lt = 0; e.lt <= e.jt; e.lt++) {
-        let E = e.gt[e.lt];
+    for (e.Et = 0; e.Et <= e.yt; e.Et++) {
+        let E = e.jt[e.Et];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.gt[e.lt];
+            E = e.jt[e.Et];
         }
     }
-    e.jt = 0;
+    e.yt = 0;
 }
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.Et;
+    let E = e.lt;
     for (let t = e.C; t; t = t.G) {
         const e = t.S;
-        if (e.X && e.Et >= E) E = e.Et + 1;
+        if (e.X && e.lt >= E) E = e.lt + 1;
     }
-    if (e.Et !== E) {
-        e.Et = E;
+    if (e.lt !== E) {
+        e.lt = E;
         for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }