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

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

@@ -82,7 +82,7 @@ function releaseSubtree(e) {
             if (e.se & REACTIVE_SNAPSHOT_STALE) {
                 e.se &= ~REACTIVE_SNAPSHOT_STALE;
                 e.se |= REACTIVE_DIRTY;
-                if (dirtyQueue.Fe > e.He) dirtyQueue.Fe = e.He;
+                if (dirtyQueue.He > e.Fe) dirtyQueue.He = e.Fe;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
@@ -95,7 +95,10 @@ function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
             delete e.Ve;
-            delete e[STORE_SNAPSHOT_PROPS];
+            // StoreNode targets share one pre-initialized hidden class (see
+            // createStoreProxy) — assign undefined instead of deleting, and only
+            // when present so signal-node sources don't grow the field.
+                        if (e[STORE_SNAPSHOT_PROPS] !== undefined) e[STORE_SNAPSHOT_PROPS] = undefined;
         }
         snapshotSources = null;
     }
@@ -130,8 +133,8 @@ 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 r = e.He;
+    let a = e.Ne === NOT_PENDING ? e.Pe : e.Ne;
+    let r = e.Fe;
     let c = tracking;
     let _ = currentOptimisticLane;
     tracking = true;
@@ -202,10 +205,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 +230,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
@@ -252,7 +255,7 @@ function recompute(e, t = false) {
             // for commit on its own transition's schedule — invisibly (A17/A18).
             if (e.Ne === NOT_PENDING) queuePendingNode(e);
             e.Ne = a;
-        } else if (e.He != r) {
+        } else if (e.Fe != r) {
             for (let t = e.o; t !== null; t = t.ue) {
                 insertIntoHeapHeight(t.le, queueFor(t.le));
             }
@@ -293,15 +296,15 @@ 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,
-        He: 0,
+        Pe: undefined,
+        Fe: 0,
         u: null,
         lt: undefined,
         ut: null,
@@ -322,7 +325,7 @@ function computed(e, t) {
         Le: null,
         Te: null,
         Ue: null,
-        be: false
+        _e: false
     };
     setupComputedNode(i, t);
     return i;
@@ -338,15 +341,15 @@ 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,
-        He: 0,
+        Pe: undefined,
+        Fe: 0,
         u: null,
         lt: undefined,
         ut: null,
@@ -367,7 +370,7 @@ function computed(e, t) {
         Le: null,
         Te: null,
         Ue: null,
-        be: false,
+        _e: false,
         $e: false,
         rt: undefined,
         ct: t,
@@ -397,12 +400,12 @@ function setupComputedNode(e, t) {
             context.me = e;
         }
     }
-    if (n) e.He = n.He + 1;
+    if (n) e.Fe = n.Fe + 1;
     if (GlobalQueue.Tt !== null) GlobalQueue.Tt(e);
     !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 +413,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,21 +517,21 @@ 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);
         if (l.ke) {
             const n = queueFor(e);
-            if (l.He >= n.Fe) {
+            if (l.Fe >= n.He) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(l);
             }
-            const i = l.He;
+            const i = l.Fe;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.He && e.Ge !== t) {
-                t.He = i + 1;
+                        if (i >= t.Fe && e.Ge !== t) {
+                t.Fe = i + 1;
             }
         }
     }
@@ -562,7 +565,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 +582,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 +605,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/error.js

@@ -25,7 +25,16 @@
 class NotReadyError extends Error {
     source;
     constructor(r) {
+        // Control-flow throw: it happens on every read of a pending source, so in
+        // production skip V8's eager stack capture (proportional to stack depth —
+        // real cost under SSR) by zeroing the V8-specific stackTraceLimit around
+        // super(). Dev keeps the stack for debuggability; non-V8 engines (no
+        // stackTraceLimit) take the plain path.
+        const o = Error;
+        const t = o.stackTraceLimit;
+        if (t !== undefined) o.stackTraceLimit = 0;
         super();
+        if (t !== undefined) o.stackTraceLimit = t;
         this.source = r;
     }
 }

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/heap.js

@@ -20,14 +20,14 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
         return;
     }
     const E = queueFor(e);
-    if (E.Fe > e.He) E.Fe = e.He;
+    if (E.He > e.Fe) E.He = e.Fe;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    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 t = (e.Ge?.ft ? e.Ge.Nt?.Fe : e.Ge?.Fe) ?? -1;
+    if (t >= e.Fe) e.Fe = t + 1;
+    const n = e.Fe;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
         const E = I.ut;
@@ -66,7 +66,7 @@ function deleteFromHeap(e, E) {
     const t = e.se;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.se = t & -25;
-    const n = e.He;
+    const n = e.Fe;
     if (e.ut === e) E.eE[n] = undefined; else {
         const t = e.lt;
         const I = E.eE[n];
@@ -106,11 +106,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Fe = 0; e.Fe <= e.EE; e.Fe++) {
-        let t = e.eE[e.Fe];
+    for (e.He = 0; e.He <= e.EE; e.He++) {
+        let t = e.eE[e.He];
         while (t !== undefined) {
             if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Fe];
+            t = e.eE[e.He];
         }
     }
     e.EE = 0;
@@ -118,14 +118,14 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.He;
+    let t = e.Fe;
     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 (n.ke && n.Fe >= t) t = n.Fe + 1;
     }
-    if (e.He !== t) {
-        e.He = t;
+    if (e.Fe !== t) {
+        e.Fe = 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`

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

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
@@ -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;
@@ -334,7 +334,7 @@ class GlobalQueue extends Queue {
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe || this.m.Qt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.He || this.m.Qt.length > 0;
                     reassignPendingTransition(e.Qt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
@@ -362,7 +362,7 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Fe) {
+                    if (dirtyQueue.EE >= dirtyQueue.He) {
                         runHeap(dirtyQueue, GlobalQueue.pe);
                         commitPendingNodes();
                     }
@@ -373,7 +373,7 @@ class GlobalQueue extends Queue {
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.He;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -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() {
@@ -527,7 +527,7 @@ function finalizePureQueue(e = null, t = false) {
     const i = !t;
     if (i) commitPendingNodes();
     if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.Fe;
+    const n = dirtyQueue.EE >= dirtyQueue.He;
     if (n) runHeap(dirtyQueue, GlobalQueue.pe);
     if (i) {
         if (n) commitPendingNodes();