@solidjs/signals 2.0.0-beta.29 → 2.0.0-beta.31

package/dist/prod/core/heap.js

@@ -1,4 +1,4 @@
-import { REACTIVE_IN_HEAP, EFFECT_TRACKED, EFFECT_USER, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
+import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
 
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 

package/dist/prod/core/optimistic.js

@@ -46,8 +46,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
         e.sn = activeTransition;
-    const o = getOrCreateLane(e);
-    e.Me = o;
+    const r = getOrCreateLane(e);
+    e.Me = 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).
@@ -164,7 +164,19 @@ 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) {
-    return e.Ae !== undefined || !!e.Me || n === e && stale && t.nn !== e || !!(n.S & STATUS_PENDING);
+    if (e.Ae !== undefined || !!e.Me || !!(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"
+        // against unrelated plain writes). With no transaction the write commits
+        // at THIS flush's end with no re-delivery, so record the reader for
+        // replay at commit — the same contract gatedRead provides when a
+        // transaction is active (#2963). If a transaction forms mid-flush,
+        // initTransition carries the recording over to it.
+        if (e.De !== NOT_PENDING && activeTransition === null) globalQueue.m.ln.add(t);
+        return true;
+    }
+    return false;
 }
 
 /**
@@ -218,8 +230,8 @@ function trackOptimisticStore(e) {
     if (GlobalQueue.ht !== null) return;
     GlobalQueue.ht = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.Tn = cleanupCompletedLanes;
+    GlobalQueue.Tn = transitionBlocked;
+    GlobalQueue.dn = cleanupCompletedLanes;
     GlobalQueue.In = runLaneEffects;
     GlobalQueue.Ot = gatedRead;
     GlobalQueue.Ct = laneSuspends;

package/dist/prod/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
 
 import { currentOptimisticLane } from "./core.js";
 
@@ -6,7 +6,7 @@ import { DEV } from "./dev.js";
 
 import { NotReadyError } from "./error.js";
 
-import { runHeap, enqueueSub } from "./heap.js";
+import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
 
 import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
 
@@ -30,6 +30,15 @@ const zombieQueue = {
     EE: 0
 };
 
+/** runHeap callback that discards a queued zombie recompute instead of running
+ * it: unlink pure recompute entries; strip just the recompute bit from dirtied
+ * height-adjust entries so their height work still happens. */ function cancelZombieRecompute(e) {
+    if (e.se & REACTIVE_IN_HEAP_HEIGHT) e.se &= -12; else {
+        deleteFromHeap(e, zombieQueue);
+        e.se &= -4;
+    }
+}
+
 let clock = 0;
 
 let activeTransition = null;
@@ -108,7 +117,7 @@ function setProjectionWriteActive(e) {
         cn: new Set,
         ie: [],
         yt: {
-            gt: [ [], [] ],
+            bt: [ [], [] ],
             vt: []
         },
         fn: false,
@@ -150,7 +159,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.bt && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.gt && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -185,7 +194,7 @@ let queueRunToken = 0;
 
 class Queue {
     ve=null;
-    gt=[ [], [] ];
+    bt=[ [], [] ];
     vt=[];
     kt=0;
     created=clock;
@@ -205,9 +214,9 @@ class Queue {
         return false;
     }
     run(e) {
-        if (this.gt[e - 1].length) {
-            const t = this.gt[e - 1];
-            this.gt[e - 1] = [];
+        if (this.bt[e - 1].length) {
+            const t = this.bt[e - 1];
+            this.bt[e - 1] = [];
             runQueue(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -239,21 +248,21 @@ class Queue {
                 const i = findLane(currentOptimisticLane);
                 i.rn[e - 1].push(t);
             } else {
-                this.gt[e - 1].push(t);
+                this.bt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.gt[0].push(...this.gt[0]);
-        e.gt[1].push(...this.gt[1]);
-        this.gt = [ [], [] ];
+        e.bt[0].push(...this.bt[0]);
+        e.bt[1].push(...this.bt[1]);
+        this.bt = [ [], [] ];
         for (let t = 0; t < this.vt.length; t++) {
             let i = this.vt[t];
             let n = e.vt[t];
             if (!n) {
                 n = {
-                    gt: [ [], [] ],
+                    bt: [ [], [] ],
                     vt: []
                 };
                 e.vt[t] = n;
@@ -262,8 +271,8 @@ class Queue {
         }
     }
     restoreQueues(e) {
-        this.gt[0].push(...e.gt[0]);
-        this.gt[1].push(...e.gt[1]);
+        this.bt[0].push(...e.bt[0]);
+        this.bt[1].push(...e.bt[1]);
         for (let t = 0; t < e.vt.length; t++) {
             const i = e.vt[t];
             let n = this.vt[t];
@@ -273,7 +282,7 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    bt=false;
+    gt=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
@@ -311,7 +320,7 @@ class GlobalQueue extends Queue {
     static Pt=null;
     static $e=null;
     static k=null;
-    static Lt=null;
+    static Gt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -321,8 +330,8 @@ class GlobalQueue extends Queue {
     // once the gate holds.
     static ht=null;
     static En=null;
-    static dn=null;
     static Tn=null;
+    static dn=null;
     static In=null;
     static Ot=null;
     static Ct=null;
@@ -332,8 +341,8 @@ class GlobalQueue extends Queue {
     static Ke=null;
     static Nn=null;
     flush() {
-        if (this.bt) return;
-        this.bt = true;
+        if (this.gt) return;
+        this.gt = true;
         try {
             if (false) ;
             runHeap(dirtyQueue, GlobalQueue.Ce);
@@ -341,7 +350,15 @@ class GlobalQueue extends Queue {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.Ce);
+                    // When the parking batch IS the transition, all of its writes commit
+                    // only with it — every zombie recompute they queued would run against
+                    // a world the zombie never displays (zombies render mainline until
+                    // commit), so cancel them instead of running them. Only an ambient
+                    // batch's mainline writes (the #2916 shape below) legitimately reach
+                    // zombies here. Height-adjust entries still process normally: a
+                    // dirtied one keeps its height flag and falls through to runHeap's
+                    // adjustHeight path on the next pass of the bucket.
+                                        runHeap(zombieQueue, this.m === e ? cancelZombieRecompute : GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
@@ -408,7 +425,7 @@ class GlobalQueue extends Queue {
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.bt = false;
+            this.gt = false;
         }
     }
     notify(e, t, i, n) {
@@ -469,6 +486,12 @@ class GlobalQueue extends Queue {
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.cn) activeTransition.cn.add(e);
+            // Gated readers recorded against the ambient batch move with it: their
+            // replay-at-commit now happens at the transaction's completion.
+                        if (t.ln.size) {
+                for (const e of t.ln) activeTransition.ln.add(e);
+                t.ln.clear();
+            }
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
@@ -562,13 +585,19 @@ function finalizePureQueue(e = null, t = false) {
         // which installed the engine's hooks.
                 if (t.je.length) GlobalQueue.En(t.je);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
-        // so they re-run with the now-committed values visible.
-                if (e && e.ln.size) {
-            for (const t of e.ln) {
-                if (t.se & REACTIVE_DISPOSED) continue;
-                enqueueSub(t);
+        // so they re-run with the now-committed values visible. The ambient batch
+        // replays too — laneReadsCommitted records readers whose committed-view
+        // read hid a same-tick plain write that just committed above (#2963).
+                if (t.ln.size) {
+            for (const e of t.ln) {
+                if (e.se & REACTIVE_DISPOSED) continue;
+                enqueueSub(e);
             }
-            e.ln.clear();
+            t.ln.clear();
+            // A completing transition keeps the outer flush loop alive by itself;
+            // the ambient batch needs the re-arm or the replay sits in the heap
+            // until the next unrelated write.
+                        schedule();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
@@ -587,7 +616,7 @@ function finalizePureQueue(e = null, t = false) {
                 if (t.cn.size) GlobalQueue.Dt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Tn(e);
+                if (activeLanes.size) GlobalQueue.dn(e);
     }
 }
 
@@ -644,7 +673,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.bt) {
+    if (globalQueue.gt) {
         return;
     }
     if (halted) return;
@@ -693,7 +722,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine (absent hook = "no optimistic
     // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
     // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.dn?.(e)) t = false;
+        if (t && GlobalQueue.Tn?.(e)) t = false;
     t && (e.fn = true);
     return t;
 }

package/dist/prod/core/verdict.js

@@ -353,6 +353,6 @@ GlobalQueue.$e = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Lt = witnessAffects;
+GlobalQueue.Gt = witnessAffects;
 
 export { isPending, latest };

package/dist/prod/map.js

@@ -27,12 +27,12 @@ function mapArray(t, s, i) {
         Mt: [],
         Kt: n,
         xt: [],
-        Gt: [],
-        Ut: e,
-        $t: e || i?.keyed === false ? [] : undefined,
-        qt: r && i?.keyed !== false ? [] : undefined,
-        zt: i?.keyed === false,
-        Bt: i?.fallback
+        Ut: [],
+        $t: e,
+        qt: e || i?.keyed === false ? [] : undefined,
+        zt: r && i?.keyed !== false ? [] : undefined,
+        Bt: i?.keyed === false,
+        Ht: i?.fallback
     };
     const o = computed(updateKeyedMap.bind(h));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
@@ -63,14 +63,14 @@ function updateKeyedMap() {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        h = this.$t ? this.zt ? () => {
+        h = this.qt ? this.Bt ? () => {
             r[e] = signal(t[e], pureOptions);
             return this.Kt(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
             return this.Kt(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.qt ? () => {
+        } : this.zt ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
             return this.Kt(s, accessor(n[e]));
@@ -82,26 +82,26 @@ function updateKeyedMap() {
                 if (s === 0) {
             if (this.jt !== 0) {
                 this.wt.dispose(false);
-                this.Gt = [];
+                this.Ut = [];
                 this.Mt = [];
                 this.xt = [];
                 this.jt = 0;
-                this.$t && (this.$t = []);
                 this.qt && (this.qt = []);
+                this.zt && (this.zt = []);
             }
-            if (this.Bt && !this.xt[0]) {
+            if (this.Ht && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Gt[0]?.dispose();
-                this.xt[0] = runWithOwner(this.Gt[0] = createOwner(), this.Bt);
+                this.Ut[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ut[0] = createOwner(), this.Ht);
             }
         }
         // fast path for new create
          else if (this.jt === 0) {
             const o = new Array(s);
             const c = new Array(s);
-            r = this.$t && new Array(s);
-            n = this.qt && new Array(s);
+            r = this.qt && new Array(s);
+            n = this.zt && new Array(s);
             try {
                 for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
             } catch (t) {
@@ -109,23 +109,23 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.Gt[0]) this.Gt[0].dispose();
+                        if (this.Ut[0]) this.Ut[0].dispose();
  // previous fallback
                         this.xt = o;
-            this.Gt = c;
-            r && (this.$t = r);
-            n && (this.qt = n);
+            this.Ut = c;
+            r && (this.qt = r);
+            n && (this.zt = n);
             this.Mt = t.slice(0);
             this.jt = s;
         } else {
             let o, c, a, f, u, p, w, l, d;
             // skip common prefix
-                        for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.$t && compare(this.Ut, this.Mt[o], t[o])); o++) {
-                if (this.$t) setSignal(this.$t[o], t[o]);
+                        for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.qt && compare(this.$t, this.Mt[o], t[o])); o++) {
+                if (this.qt) setSignal(this.qt[o], t[o]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.$t && compare(this.Ut, this.Mt[c], t[a])); c--, 
+                        for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.qt && compare(this.$t, this.Mt[c], t[a])); c--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -137,15 +137,15 @@ function updateKeyedMap() {
             const O = s - this.jt;
             const m = new Array(s);
             const _ = new Array(s);
-            r = this.$t ? new Array(s) : undefined;
-            n = this.qt ? new Array(s) : undefined;
+            r = this.qt ? new Array(s) : undefined;
+            n = this.zt ? new Array(s) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         p = new Map;
             w = new Array(a + 1);
             for (e = a; e >= o; e--) {
                 f = t[e];
-                u = this.Ut ? this.Ut(f) : f;
+                u = this.$t ? this.$t(f) : f;
                 i = p.get(u);
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
@@ -155,16 +155,16 @@ function updateKeyedMap() {
             // queue them for disposal at commit
                         for (i = o; i <= c; i++) {
                 f = this.Mt[i];
-                u = this.Ut ? this.Ut(f) : f;
+                u = this.$t ? this.$t(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
                     m[e] = this.xt[i];
-                    _[e] = this.Gt[i];
-                    r && (r[e] = this.$t[i]);
-                    n && (n[e] = this.qt[i]);
+                    _[e] = this.Ut[i];
+                    r && (r[e] = this.qt[i]);
+                    n && (n[e] = this.zt[i]);
                     e = w[e];
                     p.set(u, e);
-                } else (l ??= []).push(this.Gt[i]);
+                } else (l ??= []).push(this.Ut[i]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -182,9 +182,9 @@ function updateKeyedMap() {
             // change propagation), then dispose exited rows
                         for (i = 0; i < o; i++) {
                 m[i] = this.xt[i];
-                _[i] = this.Gt[i];
-                r && (r[i] = this.$t[i]);
-                n && (n[i] = this.qt[i]);
+                _[i] = this.Ut[i];
+                r && (r[i] = this.qt[i]);
+                n && (n[i] = this.zt[i]);
             }
             for (e = o; e <= a; e++) {
                 if (r) setSignal(r[e], t[e]);
@@ -192,20 +192,20 @@ function updateKeyedMap() {
             }
             for (e = a + 1; e < s; e++) {
                 m[e] = this.xt[e - O];
-                _[e] = this.Gt[e - O];
+                _[e] = this.Ut[e - O];
                 if (r) {
-                    r[e] = this.$t[e - O];
+                    r[e] = this.qt[e - O];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.qt[e - O];
+                    n[e] = this.zt[e - O];
                     if (O !== 0) setSignal(n[e], e);
                 }
             }
             this.xt = m;
-            this.Gt = _;
-            r && (this.$t = r);
-            n && (this.qt = n);
+            this.Ut = _;
+            r && (this.qt = r);
+            n && (this.zt = n);
             this.jt = s;
             // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
@@ -234,13 +234,13 @@ function updateKeyedMap() {
     const r = {
         wt: createOwner(),
         jt: 0,
-        Ht: 0,
-        Jt: t,
+        Jt: 0,
+        Lt: t,
         Kt: e,
-        Gt: [],
+        Ut: [],
         xt: [],
         Vt: i?.from,
-        Bt: i?.fallback
+        Ht: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
@@ -259,37 +259,37 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.Jt();
+    const t = this.Lt();
     const s = this.Vt?.() || 0;
     runWithOwner(this.wt, () => {
         if (t === 0) {
             if (this.jt !== 0) {
                 this.wt.dispose(false);
-                this.Gt = [];
+                this.Ut = [];
                 this.xt = [];
                 this.jt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Ht = 0;
+                                this.Jt = 0;
             }
-            if (this.Bt && !this.xt[0]) {
+            if (this.Ht && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Gt[0]?.dispose();
-                this.xt[0] = runWithOwner(this.Gt[0] = createOwner(), this.Bt);
+                this.Ut[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ut[0] = createOwner(), this.Ht);
             }
             return;
         }
         const i = s + t;
-        const e = this.Ht + this.jt;
+        const e = this.Jt + this.jt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(s, this.Ht);
+                const r = Math.max(s, this.Jt);
         const n = Math.min(i, e);
         const h = new Array(t);
         const o = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.Gt[t - this.Ht];
-            h[t - s] = this.xt[t - this.Ht];
+            o[t - s] = this.Ut[t - this.Jt];
+            h[t - s] = this.xt[t - this.Jt];
         }
         try {
             for (let t = s; t < i; t++) {
@@ -301,10 +301,10 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.jt === 0) this.Gt[0]?.dispose(); else for (let t = this.Ht; t < e; t++) if (t < s || t >= i) this.Gt[t - this.Ht].dispose();
+                if (this.jt === 0) this.Ut[0]?.dispose(); else for (let t = this.Jt; t < e; t++) if (t < s || t >= i) this.Ut[t - this.Jt].dispose();
         this.xt = h;
-        this.Gt = o;
-        this.Ht = s;
+        this.Ut = o;
+        this.Jt = s;
         this.jt = t;
     });
     return this.xt;

package/dist/prod/store/optimistic.js

@@ -33,8 +33,8 @@ function createOptimisticStore(e, t, r) {
         // clobbering instead of composing). Optimistic state clears when truth
         // lands or its transaction ends — never mid-refetch. Wrapped here (engine
         // is already installed above) so store-free apps never carry the check.
-                const e = GlobalQueue.dn;
-        GlobalQueue.dn = t => {
+                const e = GlobalQueue.Tn;
+        GlobalQueue.Tn = t => {
             for (const e of t.cn) {
                 if ((e[$TARGET]?.[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING) return true;
             }

package/dist/prod/store/store.js

@@ -464,11 +464,11 @@ o) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const r = e[STORE_NODE]?.[$AFFECTS];
-    if (r?.t) GlobalQueue.Lt(r);
+    if (r?.t) GlobalQueue.Gt(r);
     if (affectsScopes.size) {
         const n = e[STORE_VALUE];
         for (const [e, o] of affectsScopes) {
-            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Lt(e);
+            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Gt(e);
         }
     }
 }

package/package.json

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