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

package/dist/dev.js

@@ -2083,9 +2083,22 @@ function handleAsync(el, result, setter) {
         resolved = false,
         rejected = false,
         isSync = true;
-      it.next().then(
+      // Protocol tolerance, matching `for await`: `await` unwraps whatever
+      // next() returns — a thenable OR a bare IteratorResult. Real producers
+      // use the bare form as a promise-free fast path when a value is already
+      // buffered (seroval's deserialized streams do), so a bare result is
+      // assimilated as an already-settled step instead of crashing on `.then`.
+      const step = it.next();
+      const settled = isThenable(step) ? step : { then: onSettle => void onSettle(step) };
+      settled.then(
         r => {
-          if (isSync) {
+          // The sync stash only serves the INITIAL drain (handleAsync's caller
+          // consumes syncValue / throws NotReady from it). A sync-settled step
+          // after an async gap — seroval buffering values between pulls, a
+          // sync-thenable producer mid-stream — has no caller reading the
+          // stash: it must write through the async path or the value is
+          // silently dropped.
+          if (isSync && initialRead) {
             syncResult = r;
             resolved = true;
             if (r.done) completed = true;

package/dist/node.cjs

@@ -1909,8 +1909,23 @@ function handleAsync(e, t, n) {
         };
         const iterate = () => {
             let u, l, a = false, c = false, f = true;
-            n.next().then(n => {
-                if (f) {
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const E = n.next();
+            const d = isThenable(E) ? E : {
+                then: e => void e(E)
+            };
+            d.then(n => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (f && s) {
                     u = n;
                     a = true;
                     if (n.done) i = true;

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, 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, REACTIVE_ZOMBIE } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { unobserved, trimStaleDeps } from "./graph.js";
+import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
@@ -14,7 +14,7 @@ import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane }
 
 import { cleanup } from "./owner.js";
 
-import { globalQueue, GlobalQueue, clock, currentTransition, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
+import { globalQueue, GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -133,9 +133,9 @@ function settlePendingSource(e) {
         if (r.has(u) || !removePendingSource(u, e)) return;
         r.add(u);
         u.Se = clock;
-        const l = u.oe?.values().next().value;
-        if (l) {
-            setPendingError(u, l);
+        const s = u.oe?.values().next().value;
+        if (s) {
+            setPendingError(u, s);
             o !== null && o(u);
         } else {
             u.S &= ~STATUS_PENDING;
@@ -222,8 +222,8 @@ function handleAsync(e, n, t) {
         const u = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const l = resolveLane(e);
-        if (l) l.Ne.delete(e);
+        const s = resolveLane(e);
+        if (s) s.Ne.delete(e);
         if (t) {
             t(r);
             if (u) clearStatus(e, true);
@@ -249,14 +249,14 @@ function handleAsync(e, n, t) {
                         GlobalQueue._e !== null && GlobalQueue._e(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.Se = clock;
-        } else if (l) {
+        } else if (s) {
             // Route through lane's effect queue for independent flushing
             const n = e.Pe;
-            const t = e.Ue;
-            const o = e.be;
+            const t = e.be;
+            const o = e.he;
             try {
                 if (!n && u || !o || !o(r, t)) {
-                    e.Ue = r;
+                    e.be = r;
                     e.Se = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
@@ -300,9 +300,9 @@ function handleAsync(e, n, t) {
         return false;
     };
     if (o) {
-        let t = false, r = false, o, l = true;
+        let t = false, r = false, o, s = true;
         n.then(e => {
-            if (l) {
+            if (s) {
                 u = e;
                 t = true;
             } else {
@@ -310,7 +310,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         }, e => {
-            if (l) {
+            if (s) {
                 o = e;
                 r = true;
             } else {
@@ -318,7 +318,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        l = false;
+        s = false;
         if (r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
@@ -334,7 +334,7 @@ function handleAsync(e, n, t) {
         const t = n[Symbol.asyncIterator]();
         let r = false;
         let o = false;
-        let l = true;
+        let s = true;
         cleanup(() => {
             if (o) return;
             o = true;
@@ -350,10 +350,25 @@ function handleAsync(e, n, t) {
             if (!settleAutodispose()) iterate();
         };
         const iterate = () => {
-            let s, i, f = false, a = false, c = true;
-            t.next().then(t => {
-                if (c) {
-                    s = t;
+            let l, i, f = false, a = false, c = true;
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const S = t.next();
+            const d = isThenable(S) ? S : {
+                then: e => void e(S)
+            };
+            d.then(t => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (c && s) {
+                    l = t;
                     f = true;
                     if (t.done) o = true;
                 } else if (e.Te !== n) {
@@ -387,20 +402,20 @@ function handleAsync(e, n, t) {
                 // Match the promise branch, but only rethrow during the initial read.
                 o = true;
                 handleError(i);
-                if (l) throw i;
+                if (s) throw i;
                 return true;
             }
-            if (f && !s.done) {
-                u = s.value;
+            if (f && !l.done) {
+                u = l.value;
                 r = true;
                 return iterate();
             }
-            return f && s.done;
+            return f && l.done;
         };
-        const s = iterate();
+        const l = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
-                l = false;
-        if (!r && !s) {
+                s = false;
+        if (!r && !l) {
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
@@ -414,12 +429,12 @@ 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.Re = false;
+        e.Ue = 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.he || e.pe) GlobalQueue.ce(e);
+        if (e.Re || e.pe) GlobalQueue.ce(e);
     if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     if (e.i) e.i();
 }
@@ -428,9 +443,9 @@ function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const u = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const l = u === e;
-    const s = n === STATUS_PENDING && e.Ae !== undefined && !l;
-    const i = s && hasActiveOverride(e);
+    const s = u === e;
+    const l = n === STATUS_PENDING && e.Ae !== undefined && !s;
+    const i = l && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && u) {
             addPendingSource(e, u);
@@ -450,7 +465,7 @@ function notifyStatus(e, n, t, r, o) {
         assignOrMergeLane(e, o);
     }
     const f = r || i;
-    const a = r || s ? undefined : o;
+    const a = r || l ? undefined : o;
     if (e.i) {
         if (r && n === STATUS_PENDING) {
             return;

package/dist/prod/core/core.js

@@ -137,7 +137,7 @@ function recompute(e, t = false) {
     e.Ye++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.Se = clock;
-    let r = e.De === NOT_PENDING ? e.Ue : e.De;
+    let r = e.De === NOT_PENDING ? e.be : e.De;
     let c = e.Ve;
     let _ = tracking;
     let f = currentOptimisticLane;
@@ -189,7 +189,7 @@ function recompute(e, t = false) {
         // On a status-free node clearStatus is a guaranteed no-op: every branch
         // in its body is gated on one of these fields, and with _statusFlags === 0
         // the flags write (create or not) stores the 0 already there.
-                if (e.S !== 0 || e.i !== undefined || e._ || e.Re || e.de || e.oe !== undefined || e.he !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
+                if (e.S !== 0 || e.i !== undefined || e._ || e.Ue || e.de || e.oe !== undefined || e.Re !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.Me) GlobalQueue.Ke(e);
     } catch (t) {
@@ -212,10 +212,10 @@ function recompute(e, t = false) {
     }
     if (!e._) {
         trimStaleDeps(e);
-        const s = u ? unwrapOverride(e.Ae) : e.De === NOT_PENDING ? e.Ue : e.De;
+        const s = u ? unwrapOverride(e.Ae) : e.De === NOT_PENDING ? e.be : e.De;
         let a = false;
         try {
-            a = !n && l || !e.be || !e.be(s, r);
+            a = !n && l || !e.he || !e.he(s, r);
         } 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
@@ -242,7 +242,7 @@ function recompute(e, t = false) {
             // commitPendingNodes) exists to sequence transition reveals, and
             // paying it per effect on the plain path is pure overhead.
             n && (activeTransition !== e.Ie || activeTransition === null) || i) {
-                e.Ue = r;
+                e.be = r;
                 // 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
@@ -316,14 +316,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),
-        be: t?.equals != null ? t.equals : isEqual,
+        he: t?.equals != null ? t.equals : isEqual,
         ut: t?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ae: e,
-        Ue: undefined,
+        be: undefined,
         Ve: 0,
         u: null,
         lt: undefined,
@@ -345,7 +345,7 @@ function computed(e, t) {
         Qe: null,
         Te: null,
         Ie: null,
-        Re: false
+        Ue: false
     };
     setupComputedNode(i, t);
     return i;
@@ -361,14 +361,14 @@ function computed(e, t) {
     const s = {
         id: inheritId(l, o, context),
         T: (o ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        be: false,
+        he: false,
         ut: l?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ae: e,
-        Ue: undefined,
+        be: undefined,
         Ve: 0,
         u: null,
         lt: undefined,
@@ -390,7 +390,7 @@ function computed(e, t) {
         Qe: null,
         Te: null,
         Ie: null,
-        Re: false,
+        Ue: false,
         Be: false,
         ct: undefined,
         _t: t,
@@ -425,7 +425,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.xe = e.Ue === undefined ? NO_SNAPSHOT : e.Ue;
+            e.xe = e.be === undefined ? NO_SNAPSHOT : e.be;
             snapshotSources.add(e);
         }
     }
@@ -433,10 +433,10 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        be: t?.equals != null ? t.equals : isEqual,
+        he: t?.equals != null ? t.equals : isEqual,
         T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
         ut: t?.unobserved,
-        Ue: e,
+        be: e,
         o: null,
         st: null,
         Se: clock,
@@ -534,7 +534,7 @@ function isEqual(e, t) {
     let t = context;
     if (t?.Nt) t = t.Tt;
     if (t && tracking) link(e, t);
-    return !t || e.De === NOT_PENDING ? e.Ue : e.De;
+    return !t || e.De === NOT_PENDING ? e.be : e.De;
 }
 
 function read(e) {
@@ -558,7 +558,7 @@ function read(e) {
     }
     if (!n.ae && u === e && e.Ae === undefined && e.xe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.De === NOT_PENDING ? e.Ue : e.De;
+        return !t || e.De === NOT_PENDING ? e.be : e.De;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -610,7 +610,7 @@ function read(e) {
         const n = e.xe;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e.De !== NOT_PENDING ? e.De : e.Ue;
+            const u = e.De !== NOT_PENDING ? e.De : e.be;
             if (u !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
@@ -627,13 +627,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.Ot(e, u, t)) {
-        return e.Ue;
+        return e.be;
     }
     // 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 l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e.De === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.Ue : e.De;
+        const l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e.De === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.be : e.De;
     // 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.Pt(e, l);
@@ -650,18 +650,18 @@ function setSignal(e, t) {
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
         if (e.Ae !== undefined && !projectionWriteActive) return GlobalQueue.ht(e, t);
-    const n = e.De === NOT_PENDING ? e.Ue : e.De;
+    const n = e.De === NOT_PENDING ? e.be : e.De;
     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.be || !e.be(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.he || !e.he(n, t);
     if (!i) return t;
     if (e.De === NOT_PENDING) queuePendingNode(e);
     e.De = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook).
-        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, t);
+        (e.Re !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, t);
     e.Se = clock;
     insertSubs(e);
     schedule();

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.Pe === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t.ct = t.Ue;
+        t.ct = t.be;
         t.Be = false;
         try {
             t.ft ? t.ft(E, () => {
@@ -82,7 +82,7 @@ function runEffect(t) {
     t.Et = undefined;
     try {
         E?.();
-        const e = t._t(t.Ue, t.ct);
+        const e = t._t(t.be, t.ct);
         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.ct = t.Ue;
+        t.ct = t.be;
         t.Be = false;
     }
 }

package/dist/prod/core/lanes.js

@@ -36,7 +36,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(n.he, e);
+        adoptCompanionLane(n.Re, e);
     adoptCompanionLane(n.pe, 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.Ae !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.Ae) : e.Ue;
+    const i = t ? unwrapOverride(e.Ae) : e.be;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.he || !e.he(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.
@@ -54,7 +54,7 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
         e.Ae = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
+        (e.Re !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
     e.Se = clock;
     insertSubs(e, true);
     schedule();
@@ -89,7 +89,7 @@ function resolveOptimisticNodes(e) {
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
         const i = n.Ae;
         n.Ae = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n.Ie = null;
         n.sn = null;
     }
@@ -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.he || n.pe) GlobalQueue.un(n);
+        if (n.Re || n.pe) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.he === n || i.pe === n)) GlobalQueue.un(i);
+        if (i && (i.Re === n || i.pe === 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.he || n.pe) GlobalQueue.un(n);
+        if (n.Re || n.pe) GlobalQueue.un(n);
     }
     if (n && e.ae) e.Te = null;
     let l = t ? e.Qe : e.ke;

package/dist/prod/core/scheduler.js

@@ -543,14 +543,14 @@ function commitPendingNode(e) {
     const t = e;
     if (!t.ae) {
         if (e.De !== NOT_PENDING) {
-            e.Ue = e.De;
+            e.be = e.De;
             e.De = NOT_PENDING;
         }
-        if (e.he || e.pe) GlobalQueue.un(e);
+        if (e.Re || e.pe) GlobalQueue.un(e);
         return;
     }
     if (e.De !== NOT_PENDING) {
-        e.Ue = e.De;
+        e.be = e.De;
         e.De = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
@@ -558,7 +558,7 @@ function commitPendingNode(e) {
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
     if (t.Qe !== null || t.ye !== null) GlobalQueue.me(t, false, true);
-    if (e.he || e.pe) GlobalQueue.un(e);
+    if (e.Re || e.pe) 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.he) {
+    if (!e.Re) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.he = optimisticSignal(false, {
+        e.Re = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.he.nn = e;
-        if (computePendingState(e)) setSignal(e.he, true);
+        e.Re.nn = e;
+        if (computePendingState(e)) setSignal(e.Re, true);
     }
-    return e.he;
+    return e.Re;
 }
 
 function collectPendingSources(e) {
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.Re) return false;
+        for (const t of e.oe) if (!t.Ue) return false;
         return true;
     }
-    return e.Re;
+    return e.Ue;
 }
 
 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.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.be || !e.be(e.De, unwrapOverride(e.Ae));
+        if (hasActiveOverride(e)) return !e.he || !e.he(e.De, unwrapOverride(e.Ae));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.he) updatePendingSignal(e);
+    if (e.Re) updatePendingSignal(e);
     if (e.pe) setSignal(e.pe, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.he) {
-        setSignal(e.he, computePendingState(e));
+    if (e.Re) {
+        setSignal(e.Re, computePendingState(e));
     }
     if (e.pe) updatePendingSignal(e.pe);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.fe) {
-        if (t.he || t.pe) updatePendingSignal(t);
+        if (t.Re || t.pe) updatePendingSignal(t);
     }
 }
 
@@ -167,7 +167,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.he || e.pe) n(e);
+        if (e.Re || e.pe) 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,11 +177,11 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.he;
+    const t = e.Re;
     if (t && (t.Ae === undefined || t.Ae === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Ue !== n || t.De !== NOT_PENDING) {
-            t.Ue = n;
+        if (t.be !== n || t.De !== NOT_PENDING) {
+            t.be = n;
             t.De = NOT_PENDING;
             t.Se = clock;
             insertSubs(t);
@@ -190,7 +190,7 @@ function snapCompanionsToState(e) {
     }
     const n = e.pe;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.be, e.be) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -223,7 +223,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.Ue;
+    const i = e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.be;
     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.Re);
-    const r = n && e.Re !== i;
-    e.Re = i;
+    const i = t && !(n && !e.Ue);
+    const r = n && e.Ue !== i;
+    e.Ue = i;
     return r;
 }
 

package/dist/prod/store/optimistic.js

@@ -121,8 +121,8 @@ function clearOptimisticStores(e, t) {
                 T.Ae = NOT_PENDING;
                 T.sn = null;
                 T.De = NOT_PENDING;
-                T.Ue = o;
-                if (!T.be || !T.be(n, o)) {
+                T.be = o;
+                if (!T.he || !T.he(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }

package/dist/prod/store/store.js

@@ -291,7 +291,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.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.De !== NOT_PENDING ? e.De : e.Ue;
+    return e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.De !== NOT_PENDING ? e.De : e.be;
 }
 
 function hasOwnStoreProperty(e, t) {

package/package.json

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