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

package/dist/dev.js

@@ -1569,8 +1569,17 @@ function unlinkSubs(link) {
     if (nextSub === null) {
       dep._unobserved?.();
       // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+      // 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 c = dep;
-      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
+      c._fn &&
+        c._config & CONFIG_AUTO_DISPOSE &&
+        !(c._flags & REACTIVE_ZOMBIE) &&
+        !(c._statusFlags & STATUS_PENDING) &&
+        unobserved(c);
     }
   }
   return nextDep;
@@ -1847,6 +1856,16 @@ function handleAsync(el, result, setter) {
     flush();
     then?.();
   };
+  // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+  // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+  // work (a lazy async memo would otherwise tear down and re-execute — one
+  // fetch per suspended re-read). Settling is that observer's release, so
+  // it runs the same last-one-out check the other release sites run.
+  const settleAutodispose = () => {
+    if (el._config & CONFIG_AUTO_DISPOSE && !el._subs && !(el._statusFlags & STATUS_PENDING)) {
+      unobserved(el);
+    }
+  };
   if (thenable) {
     let resolved = false,
       rejected = false,
@@ -1857,13 +1876,19 @@ function handleAsync(el, result, setter) {
         if (isSync) {
           syncValue = v;
           resolved = true;
-        } else asyncWrite(v);
+        } else {
+          asyncWrite(v);
+          settleAutodispose();
+        }
       },
       e => {
         if (isSync) {
           syncError = e;
           rejected = true;
-        } else handleError(e);
+        } else {
+          handleError(e);
+          settleAutodispose();
+        }
       }
     );
     isSync = false;

package/dist/node.cjs

@@ -214,7 +214,7 @@ const activeLanes = new Set;
         l: [ [], [] ],
         S: null,
         T: activeTransition,
-        p: r
+        _: r
     };
     signalLanes.set(e, t);
     activeLanes.add(t);
@@ -224,7 +224,7 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(e._, t);
+        adoptCompanionLane(e.p, t);
     adoptCompanionLane(e.O, t);
     return t;
 }
@@ -236,7 +236,7 @@ function adoptCompanionLane(e, t) {
     const r = findLane(n);
     // Only the companion's own unmerged root is safely re-parentable: a root
     // that absorbed other lanes carries work that is not a child of this owner.
-        if (r !== t && r.o === e && !r.p) r.p = t;
+        if (r !== t && r.o === e && !r._) r._ = t;
 }
 
 /**
@@ -315,9 +315,9 @@ function resolveTransition(e) {
             if (i !== n && !hasActiveOverride(e)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (n.p && findLane(n.p) === i) {
+                if (n._ && findLane(n._) === i) {
                     e.i = t;
-                } else if (i.p && findLane(i.p) === n) ; else mergeLanes(n, i);
+                } else if (i._ && findLane(i._) === n) ; else mergeLanes(n, i);
             }
             return;
         }
@@ -596,8 +596,8 @@ class GlobalQueue extends Queue {
     static Se=null;
     static de=null;
     static Te=null;
-    static pe=null;
     static _e=null;
+    static pe=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -809,7 +809,7 @@ function commitPendingNode(e) {
             e.xe = e.V;
             e.V = NOT_PENDING;
         }
-        if (e._ || e.O) GlobalQueue.fe(e);
+        if (e.p || e.O) GlobalQueue.fe(e);
         return;
     }
     if (e.V !== NOT_PENDING) {
@@ -821,7 +821,7 @@ function commitPendingNode(e) {
     t.Le &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.We & STATUS_PENDING)) t.We &= ~STATUS_UNINITIALIZED;
     if (t.Me !== null || t.He !== null) GlobalQueue.J(t, false, true);
-    if (e._ || e.O) GlobalQueue.fe(e);
+    if (e.p || e.O) GlobalQueue.fe(e);
 }
 
 function commitPendingNodes() {
@@ -1181,7 +1181,7 @@ function disposeChildren(e, t = false, n) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t._ || t.O) GlobalQueue.fe(t);
+        if (t.p || t.O) GlobalQueue.fe(t);
     }
     if (t && e.Ve) e.lt = null;
     let i = n ? e.Me : e.ot;
@@ -1432,8 +1432,13 @@ function unlinkSubs(e) {
         if (r === null) {
             t.W?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+            // 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 e = t;
-            e.Ve && e.ke & CONFIG_AUTO_DISPOSE && !(e.Le & REACTIVE_ZOMBIE) && unobserved(e);
+            e.Ve && e.ke & CONFIG_AUTO_DISPOSE && !(e.Le & REACTIVE_ZOMBIE) && !(e.We & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
@@ -1687,18 +1692,34 @@ function handleAsync(e, t, n) {
         flush();
         i?.();
     };
+    // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+    // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+    // work (a lazy async memo would otherwise tear down and re-execute — one
+    // fetch per suspended re-read). Settling is that observer's release, so
+    // it runs the same last-one-out check the other release sites run.
+        const settleAutodispose = () => {
+        if (e.ke & CONFIG_AUTO_DISPOSE && !e.k && !(e.We & STATUS_PENDING)) {
+            unobserved(e);
+        }
+    };
     if (i) {
         let n = false, r = false, i, s = true;
         t.then(e => {
             if (s) {
                 o = e;
                 n = true;
-            } else asyncWrite(e);
+            } else {
+                asyncWrite(e);
+                settleAutodispose();
+            }
         }, e => {
             if (s) {
                 i = e;
                 r = true;
-            } else handleError(e);
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
         });
         s = false;
         if (r) {
@@ -1793,7 +1814,7 @@ function clearStatus(e, t = false) {
     if (e.me) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e._ || e.O) GlobalQueue.ce(e);
+        if (e.p || e.O) GlobalQueue.ce(e);
     if (e.rt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
     if (e.yt) e.yt();
 }
@@ -2033,7 +2054,7 @@ function recompute(e, t = false) {
             if (GlobalQueue.Te !== null) n = GlobalQueue.Te(e, s);
         }
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
-        if (n) GlobalQueue.pe(e);
+        if (n) GlobalQueue._e(e);
     } finally {
         tracking = a;
         latestReadActive = E;
@@ -2806,9 +2827,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let n = 0; n < t; n++) {
         const t = e[n];
-        if (t._ || t.O) GlobalQueue.fe(t);
+        if (t.p || t.O) GlobalQueue.fe(t);
         const r = t.t;
-        if (r && (r._ === t || r.O === t)) GlobalQueue.fe(r);
+        if (r && (r.p === t || r.O === t)) GlobalQueue.fe(r);
     }
     e.splice(0, t);
 }
@@ -2954,15 +2975,15 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e._) {
+    if (!e.p) {
         // Start false, write true if pending - ensures reversion returns to false
-        e._ = optimisticSignal(false, {
+        e.p = optimisticSignal(false, {
             ownedWrite: true
         });
-        e._.t = e;
-        if (computePendingState(e)) setSignal(e._, true);
+        e.p.t = e;
+        if (computePendingState(e)) setSignal(e.p, true);
     }
-    return e._;
+    return e.p;
 }
 
 function collectPendingSources(e) {
@@ -3058,20 +3079,20 @@ function computePendingState(e) {
 }
 
 function syncCompanions(e, t) {
-    if (e._) updatePendingSignal(e);
+    if (e.p) updatePendingSignal(e);
     if (e.O) setSignal(e.O, t);
 }
 
 function updatePendingSignal(e) {
-    if (e._) {
-        setSignal(e._, computePendingState(e));
+    if (e.p) {
+        setSignal(e.p, computePendingState(e));
     }
     if (e.O) updatePendingSignal(e.O);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.rt; t !== null; t = t.it) {
-        if (t._ || t.O) updatePendingSignal(t);
+        if (t.p || t.O) updatePendingSignal(t);
     }
 }
 
@@ -3089,7 +3110,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e._ || e.O) n(e);
+        if (e.p || e.O) n(e);
         for (let t = e.k; t !== null; t = t.Ge) visit(t.Ue);
         for (let t = e.rt ?? null; t !== null; t = t.it) {
             visit(t);
@@ -3099,7 +3120,7 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e._;
+    const t = e.p;
     if (t && (t.A === undefined || t.A === NOT_PENDING)) {
         const n = computePendingState(e);
         if (t.xe !== n || t.V !== NOT_PENDING) {
@@ -3273,9 +3294,9 @@ GlobalQueue.de = recordFreshRead;
 
 GlobalQueue.Te = applyReask;
 
-GlobalQueue.pe = repollDownstreamVerdicts;
+GlobalQueue._e = repollDownstreamVerdicts;
 
-GlobalQueue._e = witnessAffects;
+GlobalQueue.pe = witnessAffects;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -4115,7 +4136,7 @@ function applyStateFast(e, t, n) {
             for (c = 0, a = Math.min(s, e.length); c < a && keyedMatch(E = r[c], e[c], n); c++) {
                 isWrappable(E) && isWrappable(e[c]) && applyState(e[c], wrap(E, t), n);
             }
-            const T = new Array(e.length), p = new Map;
+            const T = new Array(e.length), _ = new Map;
             for (a = s - 1, f = e.length - 1; a >= c && f >= c && keyedMatch(E = r[a], e[f], n); a--, 
             f--) {
                 T[f] = E;
@@ -4138,18 +4159,18 @@ function applyStateFast(e, t, n) {
             for (l = f; l >= c; l--) {
                 E = e[l];
                 d = itemKey(E, n);
-                u = p.get(d);
+                u = _.get(d);
                 S[l] = u === undefined ? -1 : u;
-                p.set(d, l);
+                _.set(d, l);
             }
             for (u = c; u <= a; u++) {
                 E = r[u];
                 d = itemKey(E, n);
-                l = p.get(d);
+                l = _.get(d);
                 if (l !== undefined && l !== -1) {
                     T[l] = E;
                     l = S[l];
-                    p.set(d, l);
+                    _.set(d, l);
                 }
             }
             for (l = c; l < e.length; l++) {
@@ -4218,14 +4239,14 @@ function applyStateSlow(e, t, n) {
         let u = false;
         const l = getOverrideValue(r, i, "length", o);
         if (e.length && l && isWrappable(e[0]) && n(e[0]) != null) {
-            let c, a, f, E, S, d, T, p;
+            let c, a, f, E, S, d, T, _;
             for (f = 0, E = Math.min(l, e.length); f < E && keyedMatch(d = getOverrideValue(r, i, f, o), e[f], n); f++) {
                 isWrappable(d) && isWrappable(e[f]) && applyState(e[f], wrap(d, t), n);
             }
-            const _ = new Array(e.length), O = new Map;
+            const p = new Array(e.length), O = new Map;
             for (E = l - 1, S = e.length - 1; E >= f && S >= f && keyedMatch(d = getOverrideValue(r, i, E, o), e[S], n); E--, 
             S--) {
-                _[S] = d;
+                p[S] = d;
             }
             if (f > S || f > E) {
                 for (a = f; a <= S; a++) {
@@ -4234,7 +4255,7 @@ function applyStateSlow(e, t, n) {
                 }
                 for (;a < e.length; a++) {
                     u = true;
-                    applyArrayItem(e[a], _[a], t, s?.[a], n);
+                    applyArrayItem(e[a], p[a], t, s?.[a], n);
                 }
                 const r = e.length;
                 syncArrayNodeMembership(t, e);
@@ -4245,24 +4266,24 @@ function applyStateSlow(e, t, n) {
             T = new Array(S + 1);
             for (a = S; a >= f; a--) {
                 d = e[a];
-                p = itemKey(d, n);
-                c = O.get(p);
+                _ = itemKey(d, n);
+                c = O.get(_);
                 T[a] = c === undefined ? -1 : c;
-                O.set(p, a);
+                O.set(_, a);
             }
             for (c = f; c <= E; c++) {
                 d = getOverrideValue(r, i, c, o);
-                p = itemKey(d, n);
-                a = O.get(p);
+                _ = itemKey(d, n);
+                a = O.get(_);
                 if (a !== undefined && a !== -1) {
-                    _[a] = d;
+                    p[a] = d;
                     a = T[a];
-                    O.set(p, a);
+                    O.set(_, a);
                 }
             }
             for (a = f; a < e.length; a++) {
-                if (a in _) {
-                    applyArrayItem(e[a], _[a], t, s?.[a], n);
+                if (a in p) {
+                    applyArrayItem(e[a], p[a], t, s?.[a], n);
                 } else s?.[a] && setSignal(s[a], wrapValue(e[a], t));
             }
             if (f < e.length) u = true;
@@ -4817,11 +4838,11 @@ i) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const n = e[STORE_NODE]?.[$AFFECTS];
-    if (n?.F) GlobalQueue._e(n);
+    if (n?.F) GlobalQueue.pe(n);
     if (affectsScopes.size) {
         const r = e[STORE_VALUE];
         for (const [e, i] of affectsScopes) {
-            if (e !== n && e.F && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue._e(e);
+            if (e !== n && e.F && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue.pe(e);
         }
     }
 }
@@ -5412,7 +5433,7 @@ function createStore(e, t, n) {
     globalQueue.D.L.push(e);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to poke.
-        GlobalQueue.pe !== null && GlobalQueue.pe(e);
+        GlobalQueue._e !== null && GlobalQueue._e(e);
     notifyMarkBoundaries(e);
     schedule();
 }
@@ -5426,7 +5447,7 @@ function createStore(e, t, n) {
     shiftAffectsMarks(-1);
     e.F--;
     if (!e.F) {
-        GlobalQueue.pe !== null && GlobalQueue.pe(e, true);
+        GlobalQueue._e !== null && GlobalQueue._e(e, true);
         GlobalQueue.ne?.(e);
     }
 }
@@ -6130,7 +6151,7 @@ function updateKeyedMap() {
             this.Ut = e.slice(0);
             this.Gt = t;
         } else {
-            let u, l, c, a, f, E, S, d, T, p = new Array(t), _ = new Array(t);
+            let u, l, c, a, f, E, S, d, T, _ = new Array(t), p = new Array(t);
             i = this.Ft ? new Array(t) : undefined;
             o = this.Wt ? new Array(t) : undefined;
             // skip common prefix
@@ -6140,8 +6161,8 @@ function updateKeyedMap() {
             // common suffix
                         for (l = this.Gt - 1, c = t - 1; l >= u && c >= u && (this.Ut[l] === e[c] || this.Ft && compare(this.Qt, this.Ut[l], e[c])); l--, 
             c--) {
-                p[c] = this.Vt[l];
-                _[c] = this.xt[l];
+                _[c] = this.Vt[l];
+                p[c] = this.xt[l];
                 i && (i[c] = this.Ft[l]);
                 o && (o[c] = this.Wt[l]);
             }
@@ -6161,8 +6182,8 @@ function updateKeyedMap() {
                 f = this.Qt ? this.Qt(a) : a;
                 r = E.get(f);
                 if (r !== undefined && r !== -1) {
-                    p[r] = this.Vt[n];
-                    _[r] = this.xt[n];
+                    _[r] = this.Vt[n];
+                    p[r] = this.xt[n];
                     i && (i[r] = this.Ft[n]);
                     o && (o[r] = this.Wt[n]);
                     r = S[r];
@@ -6172,9 +6193,9 @@ function updateKeyedMap() {
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
                 for (r = u; r < t; r++) {
-                    if (r in p) continue;
-                    (T ??= []).push(_[r] = createOwner());
-                    p[r] = runWithOwner(_[r], s);
+                    if (r in _) continue;
+                    (T ??= []).push(p[r] = createOwner());
+                    _[r] = runWithOwner(p[r], s);
                 }
             } catch (e) {
                 if (T) for (n = 0; n < T.length; n++) T[n].dispose();
@@ -6182,8 +6203,8 @@ function updateKeyedMap() {
             }
             // 3) commit: land positions, then dispose exited rows
                         for (r = u; r < t; r++) {
-                this.Vt[r] = p[r];
-                this.xt[r] = _[r];
+                this.Vt[r] = _[r];
+                this.xt[r] = p[r];
                 if (i) {
                     this.Ft[r] = i[r];
                     setSignal(this.Ft[r], e[r]);
@@ -6519,7 +6540,7 @@ class RevealController {
 class CollectionQueue extends Queue {
     Tn;
     Bt=new Set;
-    pn;
+    _n;
     Zt=true;
     zt=signal(false, {
         ownedWrite: true,
@@ -6532,7 +6553,7 @@ class CollectionQueue extends Queue {
     });
     nn;
     rn=false;
-    _n;
+    pn;
     On=ON_INIT;
     constructor(e) {
         super();
@@ -6544,10 +6565,10 @@ class CollectionQueue extends Queue {
     }
     notify(e, t, n, r) {
         if (!(t & this.Tn)) return super.notify(e, t, n, r);
-        if (this.rn && this._n) {
+        if (this.rn && this.pn) {
             const e = untrack(() => {
                 try {
-                    return this._n();
+                    return this.pn();
                 } catch {
                     return ON_INIT;
                 }
@@ -6593,16 +6614,16 @@ class CollectionQueue extends Queue {
             if (e.Le & REACTIVE_DISPOSED || !e.F && !(e.We & this.Tn) && !(this.Tn & STATUS_ERROR && e.We & STATUS_PENDING)) this.Bt.delete(e);
         }
         if (!this.Bt.size) {
-            if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.pn) {
-                this.Zt = !!(this.pn.We & this.Tn);
+            if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this._n) {
+                this.Zt = !!(this._n.We & this.Tn);
             } else {
                 this.Zt = false;
             }
             if (!this.Zt) {
                 setSignal(this.zt, false);
-                if (this._n) {
+                if (this.pn) {
                     try {
-                        this.On = untrack(() => this._n());
+                        this.On = untrack(() => this.pn());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
@@ -6620,8 +6641,8 @@ function createCollectionBoundary(e, t, n, r) {
         ownedWrite: true,
         gt: true
     });
-    if (r) o._n = r;
-    const s = o.pn = createBoundChildren(i, t, o, e);
+    if (r) o.pn = r;
+    const s = o._n = createBoundChildren(i, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { trimStaleDeps } from "./graph.js";
+import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
@@ -160,11 +160,11 @@ function handleAsync(e, n, r) {
         } else if (l) {
             // Route through lane's effect queue for independent flushing
             const n = e.Ae;
-            const r = e.Re;
-            const o = e.Pe;
+            const r = e.Pe;
+            const o = e.Re;
             try {
                 if (!n && u || !o || !o(t, r)) {
-                    e.Re = t;
+                    e.Pe = t;
                     e.ce = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
@@ -193,18 +193,34 @@ function handleAsync(e, n, r) {
         flush();
         o?.();
     };
+    // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+    // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+    // work (a lazy async memo would otherwise tear down and re-execute — one
+    // fetch per suspended re-read). Settling is that observer's release, so
+    // it runs the same last-one-out check the other release sites run.
+        const settleAutodispose = () => {
+        if (e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.S & STATUS_PENDING)) {
+            unobserved(e);
+        }
+    };
     if (o) {
         let r = false, t = false, o, l = true;
         n.then(e => {
             if (l) {
                 u = e;
                 r = true;
-            } else asyncWrite(e);
+            } else {
+                asyncWrite(e);
+                settleAutodispose();
+            }
         }, e => {
             if (l) {
                 o = e;
                 t = true;
-            } else handleError(e);
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
         });
         l = false;
         if (t) {
@@ -294,13 +310,13 @@ function clearStatus(e, n = false) {
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.be = false;
+        e._e = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.ge || e.he) GlobalQueue.ae(e);
-    if (e.u && GlobalQueue._e !== null) GlobalQueue._e(e);
+        if (e.be || e.ge) GlobalQueue.ae(e);
+    if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
     if (e.i) e.i();
 }
 
@@ -324,7 +340,7 @@ function notifyStatus(e, n, r, t, o) {
             e._ = r;
         }
         GlobalQueue.ae !== null && GlobalQueue.ae(e);
-        if (e.u && GlobalQueue._e !== null) GlobalQueue._e(e);
+        if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
     }
     if (o && !t) {
         assignOrMergeLane(e, o);

package/dist/prod/core/core.js

@@ -130,7 +130,7 @@ function recompute(e, t = false) {
     e.Ye++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.ce = clock;
-    let a = e.Ne === NOT_PENDING ? e.Re : e.Ne;
+    let a = e.Ne === NOT_PENDING ? e.Pe : e.Ne;
     let r = e.He;
     let c = tracking;
     let _ = currentOptimisticLane;
@@ -202,10 +202,10 @@ function recompute(e, t = false) {
     }
     if (!e._) {
         trimStaleDeps(e);
-        const o = l ? unwrapOverride(e.Ee) : e.Ne === NOT_PENDING ? e.Re : e.Ne;
+        const o = l ? unwrapOverride(e.Ee) : e.Ne === NOT_PENDING ? e.Pe : e.Ne;
         let s = false;
         try {
-            s = !n && u || !e.Pe || !e.Pe(o, a);
+            s = !n && u || !e.Re || !e.Re(o, a);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -227,7 +227,7 @@ function recompute(e, t = false) {
         if (e._) ; else if (s) {
             const u = l ? e.Ee : undefined;
             if (t || n && activeTransition !== e.Ue || i) {
-                e.Re = a;
+                e.Pe = a;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
@@ -293,14 +293,14 @@ function computed(e, t) {
     const i = {
         id: inheritId(t, n, context),
         T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Pe: t?.equals != null ? t.equals : isEqual,
+        Re: t?.equals != null ? t.equals : isEqual,
         it: t?.unobserved,
         xe: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Qe: 0,
         ke: e,
-        Re: undefined,
+        Pe: undefined,
         He: 0,
         u: null,
         lt: undefined,
@@ -322,7 +322,7 @@ function computed(e, t) {
         Le: null,
         Te: null,
         Ue: null,
-        be: false
+        _e: false
     };
     setupComputedNode(i, t);
     return i;
@@ -338,14 +338,14 @@ function computed(e, t) {
     const s = {
         id: inheritId(u, o, context),
         T: (o ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Pe: false,
+        Re: false,
         it: u?.unobserved,
         xe: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Qe: 0,
         ke: e,
-        Re: undefined,
+        Pe: undefined,
         He: 0,
         u: null,
         lt: undefined,
@@ -367,7 +367,7 @@ function computed(e, t) {
         Le: null,
         Te: null,
         Ue: null,
-        be: false,
+        _e: false,
         $e: false,
         rt: undefined,
         ct: t,
@@ -402,7 +402,7 @@ function setupComputedNode(e, t) {
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
         if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
-            e.Ve = e.Re === undefined ? NO_SNAPSHOT : e.Re;
+            e.Ve = e.Pe === undefined ? NO_SNAPSHOT : e.Pe;
             snapshotSources.add(e);
         }
     }
@@ -410,10 +410,10 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        Pe: t?.equals != null ? t.equals : isEqual,
+        Re: t?.equals != null ? t.equals : isEqual,
         T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
         it: t?.unobserved,
-        Re: e,
+        Pe: e,
         o: null,
         ot: null,
         ce: clock,
@@ -514,7 +514,7 @@ function read(e) {
     }
     if (!n.ke && l === e && e.Ee === undefined && e.Ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.Ne === NOT_PENDING ? e.Re : e.Ne;
+        return !t || e.Ne === NOT_PENDING ? e.Pe : e.Ne;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -562,7 +562,7 @@ function read(e) {
         const n = e.Ve;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const l = e.Ne !== NOT_PENDING ? e.Ne : e.Re;
+            const l = e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
             if (l !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
@@ -579,13 +579,13 @@ function read(e) {
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
         if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ct(e, l, t)) {
-        return e.Re;
+        return e.Pe;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
     // and for regular signals in stale mode (render effects). Non-stale readers (user
     // effects) see _pendingValue so that latest() and direct reads stay consistent.
     // (The lane-context clause lives with the engine.)
-        const u = !t || currentOptimisticLane !== null && GlobalQueue.Ot(e, l, t) || e.Ne === NOT_PENDING || stale && e.Ue && activeTransition !== e.Ue ? e.Re : e.Ne;
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.Ot(e, l, t) || e.Ne === NOT_PENDING || stale && e.Ue && activeTransition !== e.Ue ? e.Pe : e.Ne;
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
         if (pendingCheckActive) GlobalQueue.Rt(e, u);
@@ -602,11 +602,11 @@ function setSignal(e, t) {
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
         if (e.Ee !== undefined && !projectionWriteActive) return GlobalQueue.Pt(e, t);
-    const n = e.Ne === NOT_PENDING ? e.Re : e.Ne;
+    const n = e.Ne === NOT_PENDING ? e.Pe : e.Ne;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.Pe || !e.Pe(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.Re || !e.Re(n, t);
     if (!i) return t;
     if (e.Ne === NOT_PENDING) queuePendingNode(e);
     e.Ne = t;

package/dist/prod/core/effect.js

@@ -62,7 +62,7 @@ function runEffect(t) {
     // same flush must not be hijacked by a later-arriving error status.
         if (t.S & STATUS_ERROR && t.Ae === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t.rt = t.Re;
+        t.rt = t.Pe;
         t.$e = false;
         try {
             t._t ? t._t(E, () => {
@@ -82,7 +82,7 @@ function runEffect(t) {
     t.Et = undefined;
     try {
         E?.();
-        const e = t.ct(t.Re, t.rt);
+        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.Et = e;
@@ -94,7 +94,7 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t.rt = t.Re;
+        t.rt = t.Pe;
         t.$e = false;
     }
 }

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";
 
@@ -18,8 +18,13 @@ function unlinkSubs(l) {
         if (u === null) {
             n.it?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+            // 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) && unobserved(l);
+            l.ke && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
         }
     }
     return e;

package/dist/prod/core/lanes.js

@@ -36,8 +36,8 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.ge, e);
-    adoptCompanionLane(n.he, e);
+        adoptCompanionLane(n.be, e);
+    adoptCompanionLane(n.ge, e);
     return e;
 }
 

package/dist/prod/core/optimistic.js

@@ -25,9 +25,9 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
     const t = e.Ee !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.Ee) : e.Re;
+    const i = t ? unwrapOverride(e.Ee) : e.Pe;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Pe || !e.Pe(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Re || !e.Re(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -87,7 +87,7 @@ function resolveOptimisticNodes(e) {
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
         const i = n.Ee;
         n.Ee = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Re !== unwrapOverride(i)) insertSubs(n, true);
+        if (i !== NOT_PENDING && n.Pe !== unwrapOverride(i)) insertSubs(n, true);
         n.Ue = null;
         n.sn = null;
     }
@@ -96,9 +96,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let t = 0; t < n; t++) {
         const n = e[t];
-        if (n.ge || n.he) GlobalQueue.un(n);
+        if (n.be || n.ge) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.ge === n || i.he === n)) GlobalQueue.un(i);
+        if (i && (i.be === n || i.ge === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }

package/dist/prod/core/owner.js

@@ -51,7 +51,7 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.ge || n.he) GlobalQueue.un(n);
+        if (n.be || n.ge) GlobalQueue.un(n);
     }
     if (n && e.ke) e.Te = null;
     let l = t ? e.Le : e.me;

package/dist/prod/core/scheduler.js

@@ -279,7 +279,7 @@ class GlobalQueue extends Queue {
     // isPending()/latest()).
     static Ie=null;
     static ae=null;
-    static _e=null;
+    static he=null;
     static un=null;
     static St=null;
     static dt=null;
@@ -495,14 +495,14 @@ function commitPendingNode(e) {
     const t = e;
     if (!t.ke) {
         if (e.Ne !== NOT_PENDING) {
-            e.Re = e.Ne;
+            e.Pe = e.Ne;
             e.Ne = NOT_PENDING;
         }
-        if (e.ge || e.he) GlobalQueue.un(e);
+        if (e.be || e.ge) GlobalQueue.un(e);
         return;
     }
     if (e.Ne !== NOT_PENDING) {
-        e.Re = e.Ne;
+        e.Pe = e.Ne;
         e.Ne = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Ae && e.Ae !== EFFECT_TRACKED) e.$e = true;
@@ -510,7 +510,7 @@ function commitPendingNode(e) {
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
     if (t.Le !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
-    if (e.ge || e.he) GlobalQueue.un(e);
+    if (e.be || e.ge) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {

package/dist/prod/core/verdict.js

@@ -32,15 +32,15 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.ge) {
+    if (!e.be) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.ge = optimisticSignal(false, {
+        e.be = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.ge.nn = e;
-        if (computePendingState(e)) setSignal(e.ge, true);
+        e.be.nn = e;
+        if (computePendingState(e)) setSignal(e.be, true);
     }
-    return e.ge;
+    return e.be;
 }
 
 function collectPendingSources(e) {
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.be) return false;
+        for (const t of e.oe) if (!t._e) return false;
         return true;
     }
-    return e.be;
+    return e._e;
 }
 
 function newQuestionInFlight(e) {
@@ -129,27 +129,27 @@ function computePendingState(e) {
         return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     if (e.Ne !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Pe || !e.Pe(e.Ne, unwrapOverride(e.Ee));
+        if (hasActiveOverride(e)) return !e.Re || !e.Re(e.Ne, unwrapOverride(e.Ee));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.ge) updatePendingSignal(e);
-    if (e.he) setSignal(e.he, t);
+    if (e.be) updatePendingSignal(e);
+    if (e.ge) setSignal(e.ge, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.ge) {
-        setSignal(e.ge, computePendingState(e));
+    if (e.be) {
+        setSignal(e.be, computePendingState(e));
     }
-    if (e.he) updatePendingSignal(e.he);
+    if (e.ge) updatePendingSignal(e.ge);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.fe) {
-        if (t.ge || t.he) updatePendingSignal(t);
+        if (t.be || t.ge) updatePendingSignal(t);
     }
 }
 
@@ -167,7 +167,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.ge || e.he) n(e);
+        if (e.be || e.ge) n(e);
         for (let t = e.o; t !== null; t = t.ue) visit(t.le);
         for (let t = e.u ?? null; t !== null; t = t.fe) {
             visit(t);
@@ -177,20 +177,20 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.ge;
+    const t = e.be;
     if (t && (t.Ee === undefined || t.Ee === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Re !== n || t.Ne !== NOT_PENDING) {
-            t.Re = n;
+        if (t.Pe !== n || t.Ne !== NOT_PENDING) {
+            t.Pe = n;
             t.Ne = NOT_PENDING;
             t.ce = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.he;
+    const n = e.ge;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Re, e.Re) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Pe, e.Pe) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -201,7 +201,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.he) {
+    if (!e.ge) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -209,21 +209,21 @@ function getLatestValueComputed(e) {
         const i = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.he = optimisticComputed(() => read(e));
-        e.he.nn = e;
+                e.ge = optimisticComputed(() => read(e));
+        e.ge.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.he;
+    return e.ge;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Re;
+    const i = e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Pe;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -279,9 +279,9 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.be);
-    const r = n && e.be !== i;
-    e.be = i;
+    const i = t && !(n && !e._e);
+    const r = n && e._e !== i;
+    e._e = i;
     return r;
 }
 
@@ -339,7 +339,7 @@ GlobalQueue.Ie = syncCompanions;
 
 GlobalQueue.ae = updatePendingSignal;
 
-GlobalQueue._e = updateChildCompanions;
+GlobalQueue.he = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 

package/dist/prod/store/optimistic.js

@@ -100,8 +100,8 @@ function clearOptimisticStores(e, t) {
                 T.Ee = NOT_PENDING;
                 T.sn = null;
                 T.Ne = NOT_PENDING;
-                T.Re = o;
-                if (!T.Pe || !T.Pe(n, o)) {
+                T.Pe = o;
+                if (!T.Re || !T.Re(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }

package/dist/prod/store/store.js

@@ -154,7 +154,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Ne !== NOT_PENDING ? e.Ne : e.Re;
+    return e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
 }
 
 function hasOwnStoreProperty(e, t) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.22",
+  "version": "2.0.0-beta.23",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",