@solidjs/signals 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/prod/core/effect.js

@@ -14,16 +14,16 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
     const r = !!R?.user;
     const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
     recompute(f, true);
-    !R?.defer && (f.De === EFFECT_USER || R?.schedule ? f.v.enqueue(f.De, runEffect.bind(null, f)) : runEffect(f));
+    !R?.defer && (f.Ae === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Ae, runEffect.bind(null, f)) : runEffect(f));
 }
 
 function notifyEffectStatus(t, E) {
     // Use passed values if provided, otherwise read from node
-    const e = t !== undefined ? t : this.i;
-    const R = E !== undefined ? E : this.k;
+    const e = t !== undefined ? t : this.S;
+    const R = E !== undefined ? E : this._;
     if (e & STATUS_ERROR) {
-        this.v.notify(this, STATUS_PENDING, 0);
-        if (this.De === EFFECT_USER) {
+        this.C.notify(this, STATUS_PENDING, 0);
+        if (this.Ae === 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
@@ -33,23 +33,23 @@ function notifyEffectStatus(t, E) {
             // 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.i & STATUS_ERROR) {
-                this.it = true;
-                this.v.enqueue(this.De, this.lt ??= runEffect.bind(null, this));
+            if (this.S & STATUS_ERROR) {
+                this.$e = true;
+                this.C.enqueue(this.Ae, this.Be ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.v.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(unwrapStatusError(R));
             throw R;
         }
-    } else if (this.De === EFFECT_RENDER) {
-        this.v.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
+    } else if (this.Ae === EFFECT_RENDER) {
+        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
     }
 }
 
 function runEffect(t) {
-    if (!t.it || t.u & REACTIVE_DISPOSED) return;
+    if (!t.$e || t.se & REACTIVE_DISPOSED) 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 +60,46 @@ 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.i & STATUS_ERROR && t.De === EFFECT_USER) {
-        const E = unwrapStatusError(t.k);
-        t.Tt = t.Ue;
-        t.it = false;
+        if (t.S & STATUS_ERROR && t.Ae === EFFECT_USER) {
+        const E = unwrapStatusError(t._);
+        t.rt = t.Pe;
+        t.$e = false;
         try {
-            t.St ? t.St(E, () => {
-                const E = t.dt;
-                t.dt = undefined;
+            t._t ? t._t(E, () => {
+                const E = t.Et;
+                t.Et = undefined;
                 E?.();
             }) : console.error(E);
         } catch (E) {
-            if (!t.v.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(E);
                 throw E;
             }
         }
         return;
     }
-    const E = t.dt;
-    t.dt = undefined;
+    const E = t.Et;
+    t.Et = undefined;
     try {
         E?.();
-        const e = t.It(t.Ue, t.Tt);
+        const e = t.ct(t.Pe, t.rt);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.dt = e;
+                t.Et = e;
     } catch (E) {
-        t.k = new StatusError(t, E);
-        t.i |= STATUS_ERROR;
-        if (!t.v.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        t._ = new StatusError(t, E);
+        t.S |= STATUS_ERROR;
+        if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(E);
             throw E;
         }
     } finally {
-        t.Tt = t.Ue;
-        t.it = false;
+        t.rt = t.Pe;
+        t.$e = false;
     }
 }
 
-GlobalQueue.ut = runEffect;
+GlobalQueue.Je = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -107,39 +107,39 @@ GlobalQueue.ut = runEffect;
  * Uses stale reads.
  */ function trackedEffect(t, E) {
     const run = () => {
-        if (!e.it || e.u & REACTIVE_DISPOSED) return;
+        if (!e.$e || e.se & REACTIVE_DISPOSED) return;
         try {
-            e.it = false;
+            e.$e = false;
             recompute(e);
         } finally {}
     };
     const e = computed(() => {
-        const E = e.dt;
-        e.dt = undefined;
+        const E = e.Et;
+        e.Et = undefined;
         E?.();
         const R = staleValues(t);
-        e.dt = R;
+        e.Et = R;
     }, {
         ...E,
         lazy: true
     });
-    e.dt = undefined;
-    e.U = e.U & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    e.it = true;
-    e.De = EFFECT_TRACKED;
-    e.C = (t, E) => {
-        const R = t !== undefined ? t : e.i;
+    e.Et = undefined;
+    e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    e.$e = true;
+    e.Ae = EFFECT_TRACKED;
+    e.i = (t, E) => {
+        const R = t !== undefined ? t : e.S;
         if (R & STATUS_ERROR) {
-            e.v.notify(e, STATUS_PENDING, 0);
-            const t = E !== undefined ? E : e.k;
-            if (!e.v.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            e.C.notify(e, STATUS_PENDING, 0);
+            const t = E !== undefined ? E : e._;
+            if (!e.C.notify(e, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(t));
                 throw t;
             }
         }
     };
-    e.Ft = run;
-    e.v.enqueue(EFFECT_USER, run);
+    e.ht = run;
+    e.C.enqueue(EFFECT_USER, run);
 }
 
 export { effect, trackedEffect };

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.xe, () => {
+    const r = externalSourceConfig.factory(e.ke, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.xe = e => {
+    e.ke = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Ot = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.Rt = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.Tt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.It = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -1,4 +1,4 @@
-import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, STATUS_PENDING, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
 import { deleteFromHeap, queueFor } from "./heap.js";
 
@@ -7,61 +7,72 @@ import { disposeChildren } from "./owner.js";
 import "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
-function unlinkSubs(n) {
-    const l = n.ot;
-    const e = n.st;
-    const u = n.de;
-    const s = n.nn;
-    if (u !== null) u.nn = s; else l.Et = s;
-    if (s !== null) s.de = u; else {
-        l.p = u;
+function unlinkSubs(l) {
+    const n = l.tt;
+    const e = l.et;
+    const u = l.ue;
+    const s = l.ll;
+    if (u !== null) u.ll = s; else n.ot = s;
+    if (s !== null) s.ue = u; else {
+        n.o = u;
         if (u === null) {
-            l.ct?.();
+            n.it?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
-                        const n = l;
-            n.xe && n.U & CONFIG_AUTO_DISPOSE && !(n.u & REACTIVE_ZOMBIE) && unobserved(n);
+            // A pending node is exempt: its in-flight async work (or the
+            // transition holding it) is an observer — tearing down would orphan
+            // the work and re-execute it on the next read. The settle path runs
+            // this same last-one-out check when that observer releases (the
+            // untracked-read dispose in core.ts guards on pending identically).
+                        const l = n;
+            l.ke && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
         }
     }
     return e;
 }
 
-function trimStaleDeps(n) {
-    const l = n.Ke;
-    let e = l !== null ? l.st : n.S;
+function trimStaleDeps(l) {
+    const n = l.qe;
+    let e = n !== null ? n.et : l.Xe;
     if (e !== null) {
         do {
             e = unlinkSubs(e);
         } while (e !== null);
-        if (l !== null) l.st = null; else n.S = null;
+        if (n !== null) n.et = null; else l.Xe = null;
     }
 }
 
-function unobserved(n) {
-    deleteFromHeap(n, queueFor(n));
-    let l = n.S;
-    while (l !== null) {
-        l = unlinkSubs(l);
+function unobserved(l) {
+    deleteFromHeap(l, queueFor(l));
+    let n = l.Xe;
+    while (n !== null) {
+        n = unlinkSubs(n);
     }
-    n.S = null;
-    n.Ke = null;
-    disposeChildren(n, true);
+    l.Xe = null;
+    l.qe = null;
+    disposeChildren(l, true);
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(n, l, e = false) {
-    const u = l.Ke;
-    if (u !== null && u.ot === n) {
-        u.Qe = e;
+function link(l, n, e = false) {
+    // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
+    // read (`isPending(() => x())`) beside a value read of the same dep must
+    // not relabel the value dependency as probe-only — the value read is what
+    // real-error propagation and affects() coverage key off, regardless of
+    // read order within the computation.
+    const u = n.qe;
+    if (u !== null && u.tt === l) {
+        u.De &&= e;
         return;
     }
     let s = null;
-    const t = l.u & REACTIVE_RECOMPUTING_DEPS;
+    const t = n.se & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = u !== null ? u.st : l.S;
-        if (s !== null && s.ot === n) {
-            s.ln = l.ze;
-            l.Ke = s;
-            s.Qe = e;
+        s = u !== null ? u.et : n.Xe;
+        if (s !== null && s.tt === l) {
+            s.nl = n.Ye;
+            n.qe = s;
+            // First touch of this pass: the previous pass's label is stale.
+                        s.De = e;
             return;
         }
     }
@@ -70,22 +81,24 @@ function link(n, l, e = false) {
     // [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 i = n.Et;
-    if (i !== null && i.Ee === l && (!t || i.ln === l.ze)) {
-        i.Qe = e;
+        const i = l.ot;
+    if (i !== null && i.le === n && (!t || i.nl === n.Ye)) {
+        // Gen-matched during a recompute = repeat touch this pass (AND); outside
+        // a recompute there is no pass boundary, so the latest read labels it.
+        if (t) i.De &&= e; else i.De = e;
         return;
     }
-    const o = l.Ke = n.Et = {
-        ot: n,
-        Ee: l,
-        st: s,
-        nn: i,
-        de: null,
-        ln: l.ze,
-        Qe: e
+    const o = n.qe = l.ot = {
+        tt: l,
+        le: n,
+        et: s,
+        ll: i,
+        ue: null,
+        nl: n.Ye,
+        De: e
     };
-    if (u !== null) u.st = o; else l.S = o;
-    if (i !== null) i.de = o; else n.p = o;
+    if (u !== null) u.et = o; else n.Xe = o;
+    if (i !== null) i.ue = o; else l.o = o;
 }
 
 export { link, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -3,7 +3,7 @@ import { REACTIVE_IN_HEAP, EFFECT_TRACKED, EFFECT_USER, REACTIVE_IN_HEAP_HEIGHT,
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.u & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.se & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -11,40 +11,40 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.De === EFFECT_TRACKED) {
+    if (e.Ae === EFFECT_TRACKED) {
         const E = e;
-        if (!E.it) {
-            E.it = true;
-            E.v.enqueue(EFFECT_USER, E.Ft);
+        if (!E.$e) {
+            E.$e = true;
+            E.C.enqueue(EFFECT_USER, E.ht);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.Le > e.qe) E.Le = e.qe;
+    if (E.Fe > e.He) E.Fe = e.He;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Fe?.At ? e.Fe.Ct?.qe : e.Fe?.qe) ?? -1;
-    if (t >= e.qe) e.qe = t + 1;
-    const n = e.qe;
+    const t = (e.Ge?.ft ? e.Ge.Nt?.He : e.Ge?.He) ?? -1;
+    if (t >= e.He) e.He = t + 1;
+    const n = e.He;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.ft;
-        E._t = e;
-        e.ft = E;
-        I.ft = e;
+        const E = I.ut;
+        E.lt = e;
+        e.ut = E;
+        I.ut = e;
     }
     if (n > E.EE) E.EE = n;
 }
 
 function insertIntoHeap(e, E) {
-    let t = e.u;
+    let t = e.se;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (t & REACTIVE_CHECK) {
-        e.u = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.se = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.u = t | REACTIVE_IN_HEAP;
+        e.se = t | REACTIVE_IN_HEAP;
         // An unmarked node entering a marked heap invalidates the markHeap memo:
         // `_marked` is only reset by runHeap, so a write between two mid-tick
         // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
@@ -56,49 +56,49 @@ function insertIntoHeap(e, E) {
 }
 
 function insertIntoHeapHeight(e, E) {
-    let t = e.u;
+    let t = e.se;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.u = t | REACTIVE_IN_HEAP_HEIGHT;
+    e.se = t | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, E);
 }
 
 function deleteFromHeap(e, E) {
-    const t = e.u;
+    const t = e.se;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.u = t & -25;
-    const n = e.qe;
-    if (e.ft === e) E.eE[n] = undefined; else {
-        const t = e._t;
+    e.se = t & -25;
+    const n = e.He;
+    if (e.ut === e) E.eE[n] = undefined; else {
+        const t = e.lt;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.ft._t = t;
-        o.ft = e.ft;
+        if (e === I) E.eE[n] = t; else e.ut.lt = t;
+        o.ut = e.ut;
     }
-    e.ft = e;
-    e._t = undefined;
+    e.ut = e;
+    e.lt = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t._t) {
-            if (t.u & REACTIVE_IN_HEAP) markNode(t);
+        for (let t = e.eE[E]; t !== undefined; t = t.lt) {
+            if (t.se & REACTIVE_IN_HEAP) markNode(t);
         }
     }
 }
 
 function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.u;
+    const t = e.se;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.u = t & -4 | E;
-    for (let E = e.p; E !== null; E = E.de) {
-        markNode(E.Ee, REACTIVE_CHECK);
+    e.se = t & -4 | E;
+    for (let E = e.o; E !== null; E = E.ue) {
+        markNode(E.le, REACTIVE_CHECK);
     }
-    if (e.G !== null) {
-        for (let E = e.G; E !== null; E = E.Ne) {
-            for (let e = E.p; e !== null; e = e.de) {
-                markNode(e.Ee, REACTIVE_CHECK);
+    if (e.u !== null) {
+        for (let E = e.u; E !== null; E = E.fe) {
+            for (let e = E.o; e !== null; e = e.ue) {
+                markNode(e.le, REACTIVE_CHECK);
             }
         }
     }
@@ -106,11 +106,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Le = 0; e.Le <= e.EE; e.Le++) {
-        let t = e.eE[e.Le];
+    for (e.Fe = 0; e.Fe <= e.EE; e.Fe++) {
+        let t = e.eE[e.Fe];
         while (t !== undefined) {
-            if (t.u & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Le];
+            if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.Fe];
         }
     }
     e.EE = 0;
@@ -118,21 +118,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.qe;
-    for (let E = e.S; E; E = E.st) {
-        const e = E.ot;
-        const n = e.rt || e;
-        if (n.xe && n.qe >= t) t = n.qe + 1;
+    let t = e.He;
+    for (let E = e.Xe; E; E = E.et) {
+        const e = E.tt;
+        const n = e.nt || e;
+        if (n.ke && n.He >= t) t = n.He + 1;
     }
-    if (e.qe !== t) {
-        e.qe = t;
-        for (let E = e.p; E !== null; E = E.de) {
+    if (e.He !== t) {
+        e.He = t;
+        for (let E = e.o; E !== null; E = E.ue) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.Ee, queueFor(E.Ee));
+            insertIntoHeapHeight(E.le, queueFor(E.le));
         }
     }
 }