@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.6

package/dist/prod/core/async.js

@@ -28,13 +28,15 @@ function addPendingSource(e, n) {
 }
 
 function removePendingSource(e, n) {
-    if (!e.o?.le?.delete(n)) return false;
-    if (e.o?.le.size === 0) if (e.o !== null) e.o.le = undefined;
+    const t = e.o?.le;
+    if (!t?.delete(n)) return false;
+    if (!t.size) e.o.le = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.o?.le?.clear();
+    // This set is node-owned and never shared; dropping the sole reference
+    // releases the set and every entry without a redundant clear() walk.
     if (e.o !== null) e.o.le = undefined;
 }
 
@@ -140,6 +142,10 @@ function settleErroredDependents(e, n) {
 }
 
 function settlePendingSource(e) {
+    // The normal landing path already cleared the source's own set. Superseded
+    // re-parks arrive here with an abandoned self entry, which must retire in
+    // the same walk as its propagated copies.
+    removePendingSource(e, e);
     let n = false;
     let t;
     const r = new Set;
@@ -253,6 +259,10 @@ function handleAsync(e, n, t) {
         }
         settleTransition();
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
+        // A NotReady rejection is a landing into another pending source. The
+        // rejected flight will never settle its self entry, so transfer ownership
+        // after notifyStatus has propagated the replacement source.
+                if (r) settlePendingSource(e);
         e.Te = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
@@ -267,14 +277,22 @@ function handleAsync(e, n, t) {
                 if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
         const i = !!(e.S & STATUS_UNINITIALIZED);
+        // Captured before clearStatus wipes it: a quiet re-ask's landing may be
+        // transition-held below, and the displayed value keeps answering the same
+        // question until the hold commits — the classification must survive to
+        // that reveal or companion synchronization briefly classifies the held
+        // old value as pending, a one-frame pulse to direct observers (#3178).
+        // A truthy capture implies `_x` exists, so the restore writes it directly.
+                const l = e.o?.De;
         trimStaleDeps(e);
         clearStatus(e);
-        const l = resolveLane(e);
-        if (l) l.De.delete(e);
+        if (l) e.o.De = true;
+        const s = resolveLane(e);
+        if (s) s.Oe.delete(e);
         if (t) {
             t(r);
             if (i) clearStatus(e, true);
-        } else if (e.o?.Oe !== undefined) {
+        } else if (e.o?.Pe !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -284,8 +302,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.Pe === NOT_PENDING) queuePendingNode(e);
-            e.Pe = r;
+            if (e.Re === NOT_PENDING) queuePendingNode(e);
+            e.Re = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -293,7 +311,7 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.Re?.(e, r);
+                        GlobalQueue.Ue?.(e, r);
             if (!hasActiveOverride(e)) {
                 insertSubs(e);
             } else if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) {
@@ -306,14 +324,14 @@ function handleAsync(e, n, t) {
                 // branch in recompute(). Optional call: the bit implies the
                 // optimistic engine WAS consulted, but the hook only installs with
                 // it — a bare-core build must not crash here.
-                GlobalQueue.Ue?.(e);
+                GlobalQueue.he?.(e);
             }
             e.Te = clock;
-        } else if (l) {
+        } else if (s) {
             // Route through lane's effect queue for independent flushing
-            const n = e.he;
+            const n = e.ge;
             const t = e.be;
-            const o = e.ge;
+            const o = e.pe;
             try {
                 if (!n && i || !o || !o(r, t)) {
                     e.be = r;
@@ -321,7 +339,7 @@ function handleAsync(e, n, t) {
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.Re?.(e, r);
+                                        GlobalQueue.Ue?.(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -345,8 +363,12 @@ function handleAsync(e, n, t) {
         // (`_pendingValue` set above or inside setSignal) is not — the verdict's
         // held-value branch is window-gated, and commitPendingNode closes the
         // window when the hold commits, so no one-frame isPending pulse can leak
-        // to live observers between the landing and its commit (#2990).
-                if (e.Pe === NOT_PENDING) e.Ne = false;
+        // to live observers between the landing and its commit (#2990). The
+        // quiet re-ask classification follows the same schedule (#3178).
+                if (e.Re === NOT_PENDING) {
+            e.Ne = false;
+            if (l) e.o.De = false;
+        }
         settlePendingSource(e);
         schedule();
         flush();
@@ -505,7 +527,7 @@ function handleAsync(e, n, t) {
         // becomes disposal-bearing, which is exactly the class a directly
         // returned iterable already occupies.
                 const registerDeferredClose = n => {
-            if (!e.pe) e.pe = n; else if (Array.isArray(e.pe)) e.pe.push(n); else e.pe = [ e.pe, n ];
+            if (!e.Ge) e.Ge = n; else if (Array.isArray(e.Ge)) e.Ge.push(n); else e.Ge = [ e.Ge, n ];
         };
         n.then(r => {
             if (l) {
@@ -568,7 +590,7 @@ 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.)
-        if (e.o !== null) e.o.Ge = false;
+        if (e.o !== null) e.o.De = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e.o?._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
@@ -584,7 +606,7 @@ function notifyStatus(e, n, t, r, o) {
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const i = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
     const l = i === e;
-    const s = n === STATUS_PENDING && e.o?.Oe !== undefined && !l;
+    const s = n === STATUS_PENDING && e.o?.Pe !== undefined && !l;
     const u = s && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && i) {

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
-import { releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settleErroredDependents, settlePendingSource } from "./async.js";
+import { releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settlePendingSource, settleErroredDependents } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, CONFIG_DIRECT_COMMIT, OVERRIDE_UNDEFINED, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_AUTHORITATIVE_READ, CONFIG_HELD_TRUTH, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_FW_CHILDREN, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_MANUAL_WRITE, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, STATUS_PENDING, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, CONFIG_DIRECT_COMMIT, OVERRIDE_UNDEFINED, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_AUTHORITATIVE_READ, CONFIG_HELD_TRUTH, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_FW_CHILDREN, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_MANUAL_WRITE, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -108,7 +108,7 @@ function clearSnapshots() {
 function recompute(e, t = false) {
     // §12d: any recompute can clean a marked subscriber — invalidate skips.
     bumpNotifyEpoch();
-    const n = e.he;
+    const n = e.ge;
     if (!t) {
         if (e.Ae && (!n || activeTransition) && activeTransition !== e.Ae) globalQueue.initTransition(e.Ae);
         deleteFromHeap(e, queueFor(e));
@@ -122,18 +122,18 @@ function recompute(e, t = false) {
                         releaseFlightTeardown(e);
         }
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.Ae || n === EFFECT_TRACKED) disposeChildren(e); else if (e.xe !== null || e.pe !== null) {
+                if (e.Ae || n === EFFECT_TRACKED) disposeChildren(e); else if (e.xe !== null || e.Ge !== null) {
             markDisposal(e);
             const t = ext(e);
-            t.qe = e.pe;
+            t.qe = e.Ge;
             t.Ye = e.xe;
-            e.pe = null;
+            e.Ge = null;
             e.xe = null;
             e.Ze = 0;
         } else ;
     }
     let i = !!(e.ie & REACTIVE_OPTIMISTIC_DIRTY);
-    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.Oe !== NOT_PENDING && e.o?.Oe !== undefined;
+    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.Pe !== NOT_PENDING && e.o?.Pe !== undefined;
     const l = !!(e.S & STATUS_UNINITIALIZED);
     // Outgoing error, captured before the compute clears status: if this run
     // recovers to an unchanged value, dependents still holding this object must
@@ -145,7 +145,7 @@ function recompute(e, t = false) {
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const s = (e.S & STATUS_PENDING) !== 0 && e.o?.le?.has(e) === true;
+        const s = e.o?.le?.has(e);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
         const a = (e.ie & REACTIVE_REASK) !== 0;
@@ -160,7 +160,7 @@ function recompute(e, t = false) {
     e.Ke++;
     e.ie = REACTIVE_RECOMPUTING_DEPS;
     e.Te = clock;
-    let _ = e.Pe === NOT_PENDING ? e.be : e.Pe;
+    let _ = e.Re === NOT_PENDING ? e.be : e.Re;
     let f = e.Me;
     let I = false;
     let E = tracking;
@@ -251,6 +251,9 @@ function recompute(e, t = false) {
                 if (GlobalQueue.et !== null) i = GlobalQueue.et(e, a);
             }
             notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Je : undefined);
+            // The replacement source is fully propagated now. If no new flight
+            // re-owned self, retire the superseded flight and its dependent copies.
+                        if (n && s && !e.o?.Ie) settlePendingSource(e);
             if (i) GlobalQueue.k(e);
         }
     } finally {
@@ -268,10 +271,10 @@ function recompute(e, t = false) {
     }
     if (!e.o?._) {
         trimStaleDeps(e);
-        const a = u ? unwrapOverride(e.o?.Oe) : e.Pe === NOT_PENDING ? e.be : e.Pe;
+        const a = u ? unwrapOverride(e.o?.Pe) : e.Re === NOT_PENDING ? e.be : e.Re;
         let c = false;
         try {
-            c = !n && l || !e.ge || !e.ge(a, _);
+            c = !n && l || !e.pe || !e.pe(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
@@ -291,7 +294,7 @@ function recompute(e, t = false) {
                         if (!t) e.C.enqueue(n, e.nt ??= GlobalQueue.it.bind(null, e));
         }
         if (e.o?._) ; else if (c) {
-            const l = u ? e.o?.Oe : undefined;
+            const l = u ? e.o?.Pe : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
             // values directly — the pending round-trip (queuePendingNode +
@@ -308,11 +311,11 @@ function recompute(e, t = false) {
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
                                 if (u && i) {
-                    ext(e).Oe = _ === undefined ? OVERRIDE_UNDEFINED : _;
-                    e.Pe = NOT_PENDING;
+                    ext(e).Pe = _ === undefined ? OVERRIDE_UNDEFINED : _;
+                    e.Re = NOT_PENDING;
                 }
             } else {
-                e.Pe = _;
+                e.Re = _;
                 // A window landing that gets held re-opens the window until the hold
                 // commits — the verdict's held-value branch is window-gated (#2990).
                                 if (r) e.Ne = true;
@@ -321,17 +324,17 @@ function recompute(e, t = false) {
                 // (#2831). Both companion writes are transition-scoped (optimistic) and
                 // auto-revert/re-derive at commit. Skipped for plain flushes where the
                 // pending value commits before effects run.
-                                if ((activeTransition || e.Ae) && GlobalQueue.Re !== null) GlobalQueue.Re(e, _);
+                                if ((activeTransition || e.Ae) && GlobalQueue.Ue !== null) GlobalQueue.Ue(e, _);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.u !== null && (!u || i || e.o?.Oe !== l)) insertSubs(e, i || u);
+                        if (e.u !== null && (!u || i || e.o?.Pe !== l)) insertSubs(e, i || u);
         } else if (u) {
             // Unchanged value (equals the override) recomputed while the override
             // is active: _value may still be stale, so hold the authoritative value
             // for commit on its own transition's schedule — invisibly (A17/A18).
-            if (e.Pe === NOT_PENDING) queuePendingNode(e);
-            e.Pe = _;
+            if (e.Re === NOT_PENDING) queuePendingNode(e);
+            e.Re = _;
             if (r) e.Ne = true;
  // see the held branch above (#2990)
             // A authoritative-view reader (until()) observed this node past its
@@ -339,7 +342,7 @@ function recompute(e, t = false) {
             // exactly the acknowledgment it waits for. Wake those readers only;
             // A17 silence holds for every ordinary subscriber. (Hook installed by
             // until(), the only setter of the gating bit.)
-                        if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue.Ue(e);
+                        if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue.he(e);
         } else if (e.Me != f) {
             for (let t = e.u; t !== null; t = t.ae) {
                 insertIntoHeapHeight(t.ce, queueFor(t.ce));
@@ -351,20 +354,13 @@ function recompute(e, t = false) {
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
                 if (o !== undefined && !c && !e.o?._) settleErroredDependents(e, o);
-        // Pending twin of the sweep above (#3181): a flight superseded by this
-        // synchronous settle leaves every registered dependent still flagged
-        // STATUS_PENDING with a pending source that will never land — asyncWrite
-        // owns the walk only for flights that actually land. An unchanged value
-        // is the dangerous shape (a projection reconciling in place: a memo over
-        // it re-throws its cached NotReadyError forever, and every reader that
-        // suspended through that memo re-parks on the dead source), but the walk
-        // runs on the changed shape too, exactly as the landing path does —
-        // insertSubs notifies value SUBSCRIBERS, not pending REGISTRANTS, and
-        // the two sets only partially overlap.
-                if (s && !(e.S & STATUS_PENDING)) settlePendingSource(e);
+        // #3181: a synchronous settle supersedes the old landing callback, so
+        // recompute owns its pending-source sweep. An uninitialized node without
+        // a replacement source still has no truth to reveal and must stay parked.
+                if (s && !(e.S & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
     }
     currentOptimisticLane = N;
-    const A = e.Pe !== NOT_PENDING || e.o !== null && (e.o.Ye !== null || e.o.qe !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const A = e.Re !== NOT_PENDING || e.o !== null && (e.o.Ye !== null || e.o.qe !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
     // under the override (A17). Revert no longer commits anything, so an
@@ -418,8 +414,8 @@ function computed(e, t) {
     const u = {
         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?.H ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        ge: t?.equals ?? isEqual,
-        pe: null,
+        pe: t?.equals ?? isEqual,
+        Ge: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Ze: 0,
@@ -441,7 +437,7 @@ function computed(e, t) {
         // A loadingValue node is born committed: commit #0 is already in _value.
         S: i ? 0 : STATUS_UNINITIALIZED,
         Te: clock,
-        Pe: NOT_PENDING,
+        Re: NOT_PENDING,
         Ae: null,
         It: -1,
         Ne: i,
@@ -461,7 +457,7 @@ function computed(e, t) {
  * this; hot paths read `el._x?._field` gated by the _config presence bits.
  * Never call ext() just to store a field's default. */ function ext(e) {
     return e.o ??= {
-        Oe: undefined,
+        Pe: undefined,
         Nt: undefined,
         Je: undefined,
         ye: undefined,
@@ -474,7 +470,7 @@ function computed(e, t) {
         fe: undefined,
         le: undefined,
         h: undefined,
-        Ge: false,
+        De: false,
         i: null,
         Et: undefined,
         We: undefined,
@@ -494,8 +490,8 @@ function computed(e, t) {
     const o = {
         id: inheritId(u, l, context),
         T: (l ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (u?.dt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        ge: false,
-        pe: null,
+        pe: false,
+        Ge: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Ze: 0,
@@ -516,7 +512,7 @@ function computed(e, t) {
         ie: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         Te: clock,
-        Pe: NOT_PENDING,
+        Re: NOT_PENDING,
         Ae: null,
         It: -1,
         Ne: false,
@@ -525,7 +521,7 @@ function computed(e, t) {
         Ot: t,
         Ct: n,
         Rt: undefined,
-        he: i,
+        ge: i,
         o: null
     };
     // Effects dispatch status through the SHARED notifier (statusNotifierOf,
@@ -556,7 +552,7 @@ function setEffectStatusNotify(e) {
  * per-node field did when every effect carried one. */ function statusNotifierOf(e) {
     const t = e.o?.h;
     if (t !== undefined) return t;
-    return e.he ? effectStatusNotify ?? undefined : undefined;
+    return e.ge ? effectStatusNotify ?? undefined : undefined;
 }
 
 const lazyOptions = {
@@ -590,7 +586,7 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        ge: t?.equals ?? isEqual,
+        pe: t?.equals ?? isEqual,
         T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0),
         be: e,
         u: null,
@@ -598,7 +594,7 @@ function signal(e, t, n = null) {
         Te: clock,
         st: n,
         Se: n?.o?.i || null,
-        Pe: NOT_PENDING,
+        Re: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
@@ -623,14 +619,14 @@ function signal(e, t, n = null) {
 
 function optimisticSignal(e, t) {
     const n = signal(e, t);
-    ext(n).Oe = NOT_PENDING;
+    ext(n).Pe = NOT_PENDING;
     n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
 
 function optimisticComputed(e, t) {
     const n = computed(e, t);
-    ext(n).Oe = NOT_PENDING;
+    ext(n).Pe = NOT_PENDING;
     n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
@@ -731,11 +727,11 @@ function isEqual(e, t) {
 /** Installs the until() machinery hook. Idempotent; called by until() before
  * any authoritative-view read happens (same late-binding contract as the
  * optimistic engine). */ function installAuthoritativeRead() {
-    if (GlobalQueue.Ue === null) GlobalQueue.Ue = notifyAuthoritativeObservers;
+    if (GlobalQueue.he === null) GlobalQueue.he = notifyAuthoritativeObservers;
 }
 
 function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.oe || e.st || e.o?.Oe !== undefined || e.o?.We !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.oe || e.st || e.o?.Pe !== undefined || e.o?.We !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
     if (t?.Gt) t = t.Dt;
     if (t && tracking) link(e, t);
@@ -743,7 +739,7 @@ function readNodeFast(e) {
     // committed visibility: like the effect half of createEffect and event
     // handlers, effect-phase code never observes its own unsettled write — the
     // write lands in the same flush's continuation (#3006).
-        return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
+        return !t || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Re;
 }
 
 function read(e) {
@@ -765,10 +761,10 @@ function read(e) {
     } else if (typeof n.oe === "function") {
         prepareComputed(e, false);
     }
-    if (!n.oe && u === e && e.o?.Oe === undefined && e.o?.We === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.oe && u === e && e.o?.Pe === undefined && e.o?.We === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
         // Committed visibility for children-forbidden readers — see readNodeFast.
-                return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
+                return !t || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Re;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -837,12 +833,12 @@ function read(e) {
         const n = e.o?.We;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e.Pe !== NOT_PENDING ? e.Pe : e.be;
+            const u = e.Re !== NOT_PENDING ? e.Re : e.be;
             if (u !== i) t.ie |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
-    if (e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING) {
+    if (e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING) {
         // A17: the override IS the value for every reader — except an authoritative
         // reader (until()'s predicate carries CONFIG_AUTHORITATIVE_READ): it must
         // observe independently-arriving truth, and serving it the caller's own
@@ -853,7 +849,7 @@ function read(e) {
         // authoritative — optimism never lives there); the sticky mark makes the
         // A17-silent "landing equals override" paths notify this node's subs so
         // the reader re-runs when truth arrives.
-        if (!(t && t.T & CONFIG_AUTHORITATIVE_READ)) return unwrapOverride(e.o?.Oe);
+        if (!(t && t.T & CONFIG_AUTHORITATIVE_READ)) return unwrapOverride(e.o?.Pe);
         e.T |= CONFIG_AUTHORITATIVE_OBSERVED;
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
@@ -872,7 +868,7 @@ function read(e) {
     // (The lane-context clause lives with the engine.) Children-forbidden readers
     // (createTrackedEffect / onSettled callbacks) get committed visibility — see
     // readNodeFast (#3006).
-        const l = !t || currentOptimisticLane !== null && GlobalQueue.bt(e, u, t) || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e.Ae && activeTransition !== e.Ae || 
+        const l = !t || currentOptimisticLane !== null && GlobalQueue.bt(e, u, t) || e.Re === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e.Ae && activeTransition !== e.Ae || 
     // A17 for HELD truth (#3164, see CONFIG_HELD_TRUTH): staged confirming
     // truth — fold-staged onto an armed family, or entangle-stolen by an
     // awaited until() — is masked from ordinary readers until its
@@ -881,7 +877,7 @@ function read(e) {
     // compose override + staged truth into a state no timeline contains).
     // Authoritative readers (until()'s predicate) and latest() see the
     // staged truth — the tunnel that keeps the hold deadlock-free.
-    e.T & CONFIG_HELD_TRUTH && !latestReadActive && !(t.T & CONFIG_AUTHORITATIVE_READ) ? e.be : e.Pe;
+    e.T & CONFIG_HELD_TRUTH && !latestReadActive && !(t.T & CONFIG_AUTHORITATIVE_READ) ? e.be : e.Re;
     // 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.kt(e, l);
@@ -906,21 +902,21 @@ function setSignal(e, t) {
     // always-present config instead of a missing-property probe), and every
     // module that installs one installs the engine first.
         if (e.T & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.xt(e, t);
-    const n = e.Pe === NOT_PENDING ? e.be : e.Pe;
+    const n = e.Re === NOT_PENDING ? e.be : e.Re;
     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.ge || !e.ge(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.pe || !e.pe(n, t);
     if (!i) return t;
-    const u = e.Pe !== NOT_PENDING;
+    const u = e.Re !== NOT_PENDING;
     if (!u) queuePendingNode(e);
-    e.Pe = t;
+    e.Re = 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 and
     // sets CONFIG_HAS_COMPANIONS — one masked read replaces two optional-field
     // probes on every write).
-        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Re !== null && GlobalQueue.Re(e, t);
+        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Ue !== null && GlobalQueue.Ue(e, t);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
         if (e.oe !== undefined) e.Te = clock;
@@ -943,7 +939,7 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.ie & REACTIVE_MANUAL_WRITE) && e.Pe === NOT_PENDING) {
+    if (!(e.ie & REACTIVE_MANUAL_WRITE) && e.Re === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }

package/dist/prod/core/effect.js

@@ -14,7 +14,7 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
     const r = !!f?.user;
     const R = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, f);
     recompute(R, true);
-    !f?.defer && (R.he === EFFECT_USER || f?.schedule ? R.C.enqueue(R.he, runEffect.bind(null, R)) : runEffect(R));
+    !f?.defer && (R.ge === EFFECT_USER || f?.schedule ? R.C.enqueue(R.ge, runEffect.bind(null, R)) : runEffect(R));
 }
 
 function notifyEffectStatus(t, e) {
@@ -23,7 +23,7 @@ function notifyEffectStatus(t, e) {
     const f = e !== undefined ? e : this.o?._;
     if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.he === EFFECT_USER) {
+        if (this.ge === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -35,7 +35,7 @@ function notifyEffectStatus(t, e) {
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
                 this.tt = true;
-                this.C.enqueue(this.he, this.nt ??= runEffect.bind(null, this));
+                this.C.enqueue(this.ge, this.nt ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -43,7 +43,7 @@ function notifyEffectStatus(t, e) {
             haltReactivity(unwrapStatusError(f));
             throw f;
         }
-    } else if (this.he === EFFECT_RENDER) {
+    } else if (this.ge === EFFECT_RENDER) {
         this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, f);
     }
 }
@@ -60,7 +60,7 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.he === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.ge === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
         t.At = t.be;
         t.tt = false;
@@ -126,7 +126,7 @@ GlobalQueue.it = runEffect;
     E.Rt = undefined;
     E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     E.tt = true;
-    E.he = EFFECT_TRACKED;
+    E.ge = EFFECT_TRACKED;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.

package/dist/prod/core/heap.js

@@ -13,7 +13,7 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.he === EFFECT_TRACKED) {
+    if (e.ge === EFFECT_TRACKED) {
         const E = e;
         if (!E.tt) {
             E.tt = true;

package/dist/prod/core/lanes.js

@@ -25,7 +25,7 @@ const activeLanes = new Set;
     const r = t ? findLane(t) : null;
     e = {
         nn: n,
-        De: new Set,
+        Oe: new Set,
         tn: [ [], [] ],
         rn: null,
         Ae: activeTransition,
@@ -71,8 +71,8 @@ function adoptCompanionLane(n, e) {
     // Move (not copy) the merged lane's work: after the merge all routing goes
     // through findLane() to the root, so anything left behind here is dead —
     // and anything *added* here later is a routing bug (INV-5).
-        for (const i of e.De) n.De.add(i);
-    e.De.clear();
+        for (const i of e.Oe) n.Oe.add(i);
+    e.Oe.clear();
     n.tn[0].push(...e.tn[0]);
     n.tn[1].push(...e.tn[1]);
     e.tn[0].length = 0;
@@ -109,7 +109,7 @@ function resolveTransition(n) {
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
     const e = n.o;
-    return e !== null && e.Oe !== undefined && e.Oe !== NOT_PENDING;
+    return e !== null && e.Pe !== undefined && e.Pe !== NOT_PENDING;
 }
 
 /**