@solidjs/signals 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/prod/core/optimistic.js

@@ -24,10 +24,10 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.Ae !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.Ae) : e.be;
+    const t = e._e !== NOT_PENDING;
+    const i = t ? unwrapOverride(e._e) : e.Ue;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.he || !e.he(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(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.
@@ -41,21 +41,21 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // No revert target is stashed: while the override is active every reader
     // sees it (A17), so authoritative arrivals commit silently into _value and
     // reverting is just dropping the override — _value is already correct.
-     else globalQueue.m.je.push(e);
+     else globalQueue.m.Me.push(e);
     // Stamp ownership on the node (post-merge, so entangled writers share the
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
         e.sn = activeTransition;
     const r = getOrCreateLane(e);
-    e.Me = r;
+    e.Ke = r;
     // Literal undefined must not land raw: the slot doubles as the optimistic
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
-        e.Ae = n === undefined ? OVERRIDE_UNDEFINED : n;
+        e._e = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.Re !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
-    e.Se = clock;
+        (e.ge !== undefined || e.pe !== undefined) && GlobalQueue.Pe !== null && GlobalQueue.Pe(e, n);
+    e.de = clock;
     insertSubs(e, true);
     schedule();
     return n;
@@ -66,8 +66,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * while one of its optimistic nodes holds an active override that is still
  * pending on real (non-affects-sentinel) async.
  */ function transitionBlocked(e) {
-    for (let n = 0; n < e.je.length; n++) {
-        const t = e.je[n];
+    for (let n = 0; n < e.Me.length; n++) {
+        const t = e.Me[n];
         if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t._ instanceof NotReadyError) {
             return true;
         }
@@ -82,15 +82,15 @@ function resolveOptimisticNodes(e) {
     const n = e.length;
     for (let t = 0; t < n; t++) {
         const n = e[t];
-        n.Me = undefined;
+        n.Ke = undefined;
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const i = n.Ae;
-        n.Ae = NOT_PENDING;
-        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
-        n.Ie = null;
+        const i = n._e;
+        n._e = NOT_PENDING;
+        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        n.Ne = null;
         n.sn = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
@@ -98,9 +98,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.Re || n.pe) GlobalQueue.un(n);
+        if (n.ge || n.pe) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.Re === n || i.pe === n)) GlobalQueue.un(i);
+        if (i && (i.ge === n || i.pe === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -113,7 +113,7 @@ function runQueue(e, n) {
  * Run effects from all lanes that are ready (no pending async).
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
-        if (n.tn || n.Ne.size > 0) continue;
+        if (n.tn || n.Ae.size > 0) continue;
         const t = n.rn[e - 1];
         if (t.length) {
             n.rn[e - 1] = [];
@@ -124,14 +124,14 @@ function runQueue(e, n) {
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
-        const t = e ? n.Ie === e : !n.Ie;
+        const t = e ? n.Ne === e : !n.Ne;
         if (!t) continue;
         if (!n.tn) {
             if (n.rn[0].length) runQueue(n.rn[0], EFFECT_RENDER);
             if (n.rn[1].length) runQueue(n.rn[1], EFFECT_USER);
         }
-        if (n.en.Me === n) n.en.Me = undefined;
-        n.Ne.clear();
+        if (n.en.Ke === n) n.en.Ke = undefined;
+        n.Ae.clear();
         n.rn[0].length = 0;
         n.rn[1].length = 0;
         activeLanes.delete(n);
@@ -143,7 +143,7 @@ function cleanupCompletedLanes(e) {
     // Per-lane suspension: only throw if in same lane as pending async
     // AND the node doesn't have an active override (overrides are the visible value,
     // downstream in the lane should read the override, not throw)
-    const n = e.Me;
+    const n = e.Ke;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
@@ -153,7 +153,7 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, n, t) {
-    if (latestReadActive || e.De === NOT_PENDING || e.ae || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.De === NOT_PENDING || e.ce || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ln.add(t);
@@ -164,7 +164,7 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, n, t) {
-    if (e.Ae !== undefined || !!e.Me || !!(n.S & STATUS_PENDING)) return true;
+    if (e._e !== undefined || !!e.Ke || !!(n.S & STATUS_PENDING)) return true;
     if (n === e && stale && t.nn !== e) {
         // The committed view can hide a same-tick ambient write (a lane member —
         // even just an isPending companion flip — puts the reader "under a lane"
@@ -185,8 +185,8 @@ function cleanupCompletedLanes(e) {
  * can run before its OPT-dirty child propagates).
  */ function recomputeLane(e, n) {
     if (n) return resolveLane(e) ?? null;
-    for (let n = e.et; n; n = n.tt) {
-        const t = n.nt;
+    for (let n = e.tt; n; n = n.nt) {
+        const t = n.it;
         if (t.se & REACTIVE_OPTIMISTIC_DIRTY) {
             const n = resolveLane(t);
             if (n) {
@@ -202,17 +202,17 @@ function cleanupCompletedLanes(e) {
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
     if (n.en !== e) {
-        n.Ne.add(e);
-        e.Me = n;
-        GlobalQueue.ce !== null && GlobalQueue.ce(n.en);
+        n.Ae.add(e);
+        e.Ke = n;
+        GlobalQueue.Se !== null && GlobalQueue.Se(n.en);
     }
 }
 
 /** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
     const n = resolveLane(e);
     if (n) {
-        n.Ne.delete(e);
-        GlobalQueue.ce !== null && GlobalQueue.ce(n.en);
+        n.Ae.delete(e);
+        GlobalQueue.Se !== null && GlobalQueue.Se(n.en);
     }
 }
 
@@ -227,18 +227,18 @@ function trackOptimisticStore(e) {
  * create optimistic state (verdict.ts at module top level, createOptimistic
  * and createOptimisticStore at first call) BEFORE any optimistic node exists.
  */ function installOptimisticEngine() {
-    if (GlobalQueue.ht !== null) return;
-    GlobalQueue.ht = optimisticWrite;
+    if (GlobalQueue.Gt !== null) return;
+    GlobalQueue.Gt = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
     GlobalQueue.Tn = transitionBlocked;
     GlobalQueue.dn = cleanupCompletedLanes;
     GlobalQueue.In = runLaneEffects;
-    GlobalQueue.Ot = gatedRead;
-    GlobalQueue.Ct = laneSuspends;
-    GlobalQueue.Rt = laneReadsCommitted;
-    GlobalQueue.Ze = recomputeLane;
-    GlobalQueue.ze = laneAsyncPending;
-    GlobalQueue.Ke = laneAsyncSettled;
+    GlobalQueue.Rt = gatedRead;
+    GlobalQueue.Ot = laneSuspends;
+    GlobalQueue.Pt = laneReadsCommitted;
+    GlobalQueue.je = recomputeLane;
+    GlobalQueue.$e = laneAsyncPending;
+    GlobalQueue.ze = laneAsyncSettled;
     GlobalQueue.Nn = trackOptimisticStore;
 }
 

package/dist/prod/core/owner.js

@@ -1,4 +1,4 @@
-import { REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
+import { REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
 
 import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
 
@@ -12,7 +12,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.ke;
+    let n = e.Fe;
     while (n) {
         const e = n.se;
         n.se = e | REACTIVE_ZOMBIE;
@@ -26,17 +26,21 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.Fe;
+        n = n.He;
     }
 }
 
 function dispose(e) {
-    let n = e.et;
+    // Leave every scheduler heap on disposal (mirrors `unobserved`): a node
+    // still queued here would be recomputed by the next flush, and recompute()
+    // rewriting `_flags` would clear REACTIVE_DISPOSED — resurrecting it (#2983).
+    deleteFromHeap(e, queueFor(e));
+    let n = e.tt;
     while (n !== null) {
         n = unlinkSubs(n);
     }
-    e.et = null;
-    e.We = null;
+    e.tt = null;
+    e.Ye = null;
     disposeChildren(e, true);
 }
 
@@ -51,54 +55,59 @@ 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.Re || n.pe) GlobalQueue.un(n);
+        if (n.ge || n.pe) GlobalQueue.un(n);
     }
-    if (n && e.ae) e.Te = null;
-    let l = t ? e.Qe : e.ke;
+    if (n && e.ce) e.Te = null;
+    let l = t ? e.We : e.Fe;
     while (l) {
-        const e = l.Fe;
-        if (l.et) {
-            const e = l;
-            deleteFromHeap(e, queueFor(e));
-            let n = e.et;
+        const e = l.He;
+        const n = l;
+        // Heap removal must not be gated on `_deps`: a dependency-free
+        // computation queued by refresh() has a null dep list but still sits in
+        // the dirty heap, and left there the post-disposal flush recomputes it —
+        // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
+        // comes back to life (post-unmount runs, leaked cleanups, #2983).
+                if (n.se & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) deleteFromHeap(n, queueFor(n));
+        if (n.tt) {
+            let e = n.tt;
             do {
-                n = unlinkSubs(n);
-            } while (n !== null);
-            e.et = null;
-            e.We = null;
+                e = unlinkSubs(e);
+            } while (e !== null);
+            n.tt = null;
+            n.Ye = null;
         }
         disposeChildren(l, true);
         l = e;
     }
     if (t) {
-        e.Qe = null;
+        e.We = null;
     } else {
-        e.ke = null;
+        e.Fe = null;
         e.qe = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.ve !== null && !(e.ve.se & REACTIVE_DISPOSED)) {
-        const n = e.rt;
-        const t = e.Fe;
-        if (n !== null) n.Fe = t; else e.ve.ke = t;
-        if (t !== null) t.rt = n;
-        e.rt = null;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.ke !== null && !(e.ke.se & REACTIVE_DISPOSED)) {
+        const n = e.ct;
+        const t = e.He;
+        if (n !== null) n.He = t; else e.ke.Fe = t;
+        if (t !== null) t.ct = n;
+        e.ct = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.Et) {
-        const n = e.Et;
-        e.Et = undefined;
+        if (n && e.Tt) {
+        const n = e.Tt;
+        e.Tt = undefined;
         n();
     }
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.ye : e.Le;
+    let t = n ? e.Qe : e.ye;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -108,12 +117,12 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.ye = null : e.Le = null;
+    n ? e.Qe = null : e.ye = null;
 }
 
 function childId(e, n) {
     let t = e;
-    while (t.T & CONFIG_TRANSPARENT && t.ve) t = t.ve;
+    while (t.T & CONFIG_TRANSPARENT && t.ke) t = t.ke;
     if (t.id != null) return formatId(t.id, n ? t.qe++ : t.qe);
     throw new Error("");
 }
@@ -195,7 +204,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Le) context.Le = e; else if (Array.isArray(context.Le)) context.Le.push(e); else context.Le = [ context.Le, e ];
+    if (!context.ye) context.ye = e; else if (Array.isArray(context.ye)) context.ye.push(e); else context.ye = [ context.ye, e ];
     return e;
 }
 
@@ -236,27 +245,27 @@ function disposeRootSelf(e = true) {
         id: inheritId(e, t, n),
         T: t ? CONFIG_TRANSPARENT : 0,
         Nt: true,
-        Tt: n?.Nt ? n.Tt : n,
-        ke: null,
+        dt: n?.Nt ? n.dt : n,
         Fe: null,
-        rt: null,
-        Le: null,
+        He: null,
+        ct: null,
+        ye: null,
         C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
         qe: 0,
-        ye: null,
         Qe: null,
-        ve: n,
+        We: null,
+        ke: n,
         dispose: disposeRootSelf
     };
     if (n) {
-        const e = n.ke;
+        const e = n.Fe;
         if (e === null) {
-            n.ke = i;
+            n.Fe = i;
         } else {
-            i.Fe = e;
-            e.rt = i;
-            n.ke = i;
+            i.He = e;
+            e.ct = i;
+            n.Fe = i;
         }
     }
     return i;