@solidjs/signals 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/prod/core/core.js

@@ -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;
     }
@@ -111,23 +114,23 @@ function recompute(e, t = false) {
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
                 if (e.Ue || n === EFFECT_TRACKED) disposeChildren(e); else if (e.me !== null || e.xe !== null) {
             markDisposal(e);
-            e.ye = e.xe;
-            e.Le = e.me;
+            e.Le = e.xe;
+            e.ye = e.me;
             e.xe = null;
             e.me = null;
             e.Qe = 0;
         } else ;
     }
     let i = !!(e.se & REACTIVE_OPTIMISTIC_DIRTY);
-    const l = e.Ee !== undefined && e.Ee !== NOT_PENDING;
-    const u = !!(e.S & STATUS_UNINITIALIZED);
+    const u = e.Ee !== undefined && e.Ee !== NOT_PENDING;
+    const l = !!(e.S & STATUS_UNINITIALIZED);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
         const o = (e.se & REACTIVE_REASK) !== 0;
     const s = context;
     context = e;
     e.qe = null;
-    e.Ye++;
+    e.We++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.ce = clock;
     let a = e.Ne === NOT_PENDING ? e.Pe : e.Ne;
@@ -141,27 +144,27 @@ function recompute(e, t = false) {
     // computed) inside latest(fn) came out permanently dependency-less (#2926).
     // latestRead() already suspends the flag for its pull-recomputes; this
     // covers creation-time computes and flushes that run inside the window.
-        const E = latestReadActive;
+        const f = latestReadActive;
     latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (i) {
-        const t = GlobalQueue.We(e, true);
+        const t = GlobalQueue.Ye(e, true);
         if (t) currentOptimisticLane = t;
     } else if (activeTransition && !t && activeTransition.Ze.length) {
         // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
         // child propagates. Walk deps once and inherit the OPT lane so this node
         // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.We(e, false);
+        const t = GlobalQueue.Ye(e, false);
         if (t) {
             i = true;
             currentOptimisticLane = t;
         }
     }
-    const f = n && n !== EFFECT_USER;
+    const E = n && n !== EFFECT_USER;
     const N = stale;
-    if (f) stale = true;
+    if (E) stale = true;
     try {
         if (!false && e.T & CONFIG_SYNC) {
             a = e.ke(a);
@@ -175,11 +178,14 @@ function recompute(e, t = false) {
             const t = e.Te;
             const n = e.ke(a);
             const i = typeof n === "object" && n !== null;
-            const l = e.Te !== t;
-            a = l || !i ? n : handleAsync(e, n);
-            if (!l && !i) e.Te = null;
+            const u = e.Te !== t;
+            a = u || !i ? n : handleAsync(e, n);
+            if (!u && !i) e.Te = null;
         }
-        clearStatus(e, t);
+        // 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._e || e.Se || e.oe !== undefined || e.be !== undefined || e.ge !== undefined || e.u !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.je) GlobalQueue.Me(e);
     } catch (t) {
@@ -195,17 +201,17 @@ function recompute(e, t = false) {
         if (n) GlobalQueue.k(e);
     } finally {
         tracking = c;
-        latestReadActive = E;
-        if (f) stale = N;
+        latestReadActive = f;
+        if (E) stale = N;
         e.se = REACTIVE_NONE | (t ? e.se & REACTIVE_SNAPSHOT_STALE : 0);
         context = s;
     }
     if (!e._) {
         trimStaleDeps(e);
-        const o = l ? unwrapOverride(e.Ee) : e.Ne === NOT_PENDING ? e.Pe : e.Ne;
+        const o = u ? unwrapOverride(e.Ee) : e.Ne === NOT_PENDING ? e.Pe : e.Ne;
         let s = false;
         try {
-            s = !n && u || !e.Re || !e.Re(o, a);
+            s = !n && l || !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
@@ -225,14 +231,19 @@ function recompute(e, t = false) {
                         if (!t) e.C.enqueue(n, e.Be ??= GlobalQueue.Je.bind(null, e));
         }
         if (e._) ; else if (s) {
-            const u = l ? e.Ee : undefined;
-            if (t || n && activeTransition !== e.Ue || i) {
+            const l = u ? e.Ee : undefined;
+            if (t || 
+            // Plain sync flush (no transition on either side) commits effect
+            // values directly — the pending round-trip (queuePendingNode +
+            // commitPendingNodes) exists to sequence transition reveals, and
+            // paying it per effect on the plain path is pure overhead.
+            n && (activeTransition !== e.Ue || activeTransition === null) || i) {
                 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
                 // commit can't clobber the fresh value.
-                                if (l && i) {
+                                if (u && i) {
                     e.Ee = a === undefined ? OVERRIDE_UNDEFINED : a;
                     e.Ne = NOT_PENDING;
                 }
@@ -245,8 +256,10 @@ function recompute(e, t = false) {
                 // pending value commits before effects run.
                                 if ((activeTransition || e.Ue) && GlobalQueue.Ie !== null) GlobalQueue.Ie(e, a);
             }
-            if (!l || i || e.Ee !== u) insertSubs(e, i || l);
-        } else if (l) {
+            // insertSubs only walks _subs (no scheduling of its own), so a
+            // subscriber-less node has nothing to notify.
+                        if (e.o !== null && (!u || i || e.Ee !== 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).
@@ -259,13 +272,13 @@ function recompute(e, t = false) {
         }
     }
     currentOptimisticLane = _;
-    const T = e.Ne !== NOT_PENDING || e.Le !== null || e.ye !== null || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const T = e.Ne !== NOT_PENDING || e.ye !== null || e.Le !== 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
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        T && (!t || e.S & STATUS_PENDING) && (!e.Ue || l) && queuePendingNode(e);
+        T && (!t || e.S & STATUS_PENDING) && (!e.Ue || u) && queuePendingNode(e);
     e.Ue && n && activeTransition !== e.Ue && runInTransition(e.Ue, () => recompute(e));
 }
 
@@ -303,11 +316,11 @@ function computed(e, t) {
         Pe: undefined,
         He: 0,
         u: null,
-        lt: undefined,
-        ut: null,
+        ut: undefined,
+        lt: null,
         Xe: null,
         qe: null,
-        Ye: 0,
+        We: 0,
         o: null,
         ot: null,
         Ge: context,
@@ -318,8 +331,8 @@ function computed(e, t) {
         S: STATUS_UNINITIALIZED,
         ce: clock,
         Ne: NOT_PENDING,
-        ye: null,
         Le: null,
+        ye: null,
         Te: null,
         Ue: null,
         _e: false
@@ -333,13 +346,13 @@ function computed(e, t) {
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
- */ function createEffectNode(e, t, n, i, l, u) {
-    const o = u?.transparent ?? false;
+ */ function createEffectNode(e, t, n, i, u, l) {
+    const o = l?.transparent ?? false;
     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),
+        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),
         Re: false,
-        it: u?.unobserved,
+        it: l?.unobserved,
         xe: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
@@ -348,11 +361,11 @@ function computed(e, t) {
         Pe: undefined,
         He: 0,
         u: null,
-        lt: undefined,
-        ut: null,
+        ut: undefined,
+        lt: null,
         Xe: null,
         qe: null,
-        Ye: 0,
+        We: 0,
         o: null,
         ot: null,
         Ge: context,
@@ -363,8 +376,8 @@ function computed(e, t) {
         S: STATUS_UNINITIALIZED,
         ce: clock,
         Ne: NOT_PENDING,
-        ye: null,
         Le: null,
+        ye: null,
         Te: null,
         Ue: null,
         _e: false,
@@ -372,9 +385,9 @@ function computed(e, t) {
         rt: undefined,
         ct: t,
         _t: n,
-        Et: undefined,
+        ft: undefined,
         Ae: i,
-        i: l
+        i: u
     };
     setupComputedNode(s, lazyOptions);
     return s;
@@ -385,8 +398,8 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.ut = e;
-    const n = context?.ft ? context.Nt : context;
+    e.lt = e;
+    const n = context?.Et ? context.Nt : context;
     if (context) {
         const t = context.me;
         if (t === null) {
@@ -493,59 +506,80 @@ function isEqual(e, t) {
     }
 }
 
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */ const READ_SLOW = Symbol("read-slow");
+
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * snapshot / transition / lane / dev-strictRead state all take the full
+ * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ */ function readNodeFast(e) {
+    if (latestReadActive || pendingCheckActive || e.ke || e.nt || e.Ee !== undefined || e.Ve !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    let t = context;
+    if (t?.Et) t = t.Nt;
+    if (t && tracking) link(e, t);
+    return !t || e.Ne === NOT_PENDING ? e.Pe : e.Ne;
+}
+
 function read(e) {
     // Handle latest() mode: read from _latestValueComputed
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.St(e);
+    if (latestReadActive) return GlobalQueue.dt(e);
     let t = context;
-    if (t?.ft) t = t.Nt;
+    if (t?.Et) t = t.Nt;
     const n = e;
     const i = e.nt;
-    const l = i || e;
+    const u = i || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.dt(e, t, l, i);
+        GlobalQueue.St(e, t, u, i);
     } else if (typeof n.ke === "function") {
         prepareComputed(e, false);
     }
-    if (!n.ke && l === e && e.Ee === undefined && e.Ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.ke && u === 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.Pe : e.Ne;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (l.ke) {
+        if (u.ke) {
             const n = queueFor(e);
-            if (l.He >= n.Fe) {
+            if (u.He >= n.Fe) {
                 markNode(t);
                 markHeap(n);
-                updateIfNecessary(l);
+                updateIfNecessary(u);
             }
-            const i = l.He;
+            const i = u.He;
             // parent check is shallow, might need to be recursive
                         if (i >= t.He && e.Ge !== t) {
                 t.He = i + 1;
             }
         }
     }
-    if (l.S & STATUS_PENDING) {
-        if (t && !(stale && l.Ue && activeTransition !== l.Ue)) {
+    if (u.S & STATUS_PENDING) {
+        if (t && !(stale && u.Ue && activeTransition !== u.Ue)) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.At(l)) {
+            if (currentOptimisticLane === null || GlobalQueue.At(u)) {
                 if (!tracking && e !== t) link(e, t);
-                throw l._;
+                throw u._;
             }
-        } else if (t && l !== e && l.S & STATUS_UNINITIALIZED) {
+        } else if (t && u !== e && u.S & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
-            throw l._;
-        } else if (!t && l.S & STATUS_UNINITIALIZED) {
-            throw l._;
+            throw u._;
+        } else if (!t && u.S & STATUS_UNINITIALIZED) {
+            throw u._;
         }
     }
     if (e.ke && e.S & STATUS_ERROR) {
@@ -562,8 +596,8 @@ 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.Pe;
-            if (l !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
+            const u = e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
+            if (u !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
@@ -578,21 +612,21 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // 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)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ct(e, u, t)) {
         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.Pe : e.Ne;
+        const l = !t || currentOptimisticLane !== null && GlobalQueue.Ot(e, u, 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);
-    if (!t && l === e && typeof n.ke === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.o) {
+        if (pendingCheckActive) GlobalQueue.Rt(e, l);
+    if (!t && u === e && typeof n.ke === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.o) {
         unobserved(e);
     }
-    return u;
+    return l;
 }
 
 function setSignal(e, t) {
@@ -610,7 +644,10 @@ function setSignal(e, t) {
     if (!i) return t;
     if (e.Ne === NOT_PENDING) queuePendingNode(e);
     e.Ne = t;
-    GlobalQueue.Ie !== null && GlobalQueue.Ie(e, 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.be !== undefined || e.ge !== undefined) && GlobalQueue.Ie !== null && GlobalQueue.Ie(e, t);
     e.ce = clock;
     insertSubs(e);
     schedule();
@@ -726,4 +763,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, suppressComputedRecompute, tracking, untrack };
+export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, suppressComputedRecompute, tracking, untrack };

package/dist/prod/core/effect.js

@@ -66,8 +66,8 @@ function runEffect(t) {
         t.$e = false;
         try {
             t._t ? t._t(E, () => {
-                const E = t.Et;
-                t.Et = undefined;
+                const E = t.ft;
+                t.ft = undefined;
                 E?.();
             }) : console.error(E);
         } catch (E) {
@@ -78,14 +78,14 @@ function runEffect(t) {
         }
         return;
     }
-    const E = t.Et;
-    t.Et = undefined;
+    const E = t.ft;
+    t.ft = undefined;
     try {
         E?.();
         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;
+                t.ft = e;
     } catch (E) {
         t._ = new StatusError(t, E);
         t.S |= STATUS_ERROR;
@@ -114,16 +114,16 @@ GlobalQueue.Je = runEffect;
         } finally {}
     };
     const e = computed(() => {
-        const E = e.Et;
-        e.Et = undefined;
+        const E = e.ft;
+        e.ft = undefined;
         E?.();
         const R = staleValues(t);
-        e.Et = R;
+        e.ft = R;
     }, {
         ...E,
         lazy: true
     });
-    e.Et = undefined;
+    e.ft = undefined;
     e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     e.$e = true;
     e.Ae = EFFECT_TRACKED;

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

@@ -69,7 +69,7 @@ function link(l, n, e = false) {
     if (t) {
         s = u !== null ? u.et : n.Xe;
         if (s !== null && s.tt === l) {
-            s.nl = n.Ye;
+            s.nl = n.We;
             n.qe = s;
             // First touch of this pass: the previous pass's label is stale.
                         s.De = e;
@@ -82,7 +82,7 @@ function link(l, n, e = false) {
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
         const i = l.ot;
-    if (i !== null && i.le === n && (!t || i.nl === n.Ye)) {
+    if (i !== null && i.le === n && (!t || i.nl === n.We)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
         if (t) i.De &&= e; else i.De = e;
@@ -94,7 +94,7 @@ function link(l, n, e = false) {
         et: s,
         ll: i,
         ue: null,
-        nl: n.Ye,
+        nl: n.We,
         De: e
     };
     if (u !== null) u.et = o; else n.Xe = o;

package/dist/prod/core/heap.js

@@ -25,15 +25,15 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Ge?.ft ? e.Ge.Nt?.He : e.Ge?.He) ?? -1;
+    const t = (e.Ge?.Et ? e.Ge.Nt?.He : e.Ge?.He) ?? -1;
     if (t >= e.He) e.He = t + 1;
     const n = e.He;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.ut;
-        E.lt = e;
-        e.ut = E;
-        I.ut = e;
+        const E = I.lt;
+        E.ut = e;
+        e.lt = E;
+        I.lt = e;
     }
     if (n > E.EE) E.EE = n;
 }
@@ -67,22 +67,22 @@ function deleteFromHeap(e, E) {
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.se = t & -25;
     const n = e.He;
-    if (e.ut === e) E.eE[n] = undefined; else {
-        const t = e.lt;
+    if (e.lt === e) E.eE[n] = undefined; else {
+        const t = e.ut;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.ut.lt = t;
-        o.ut = e.ut;
+        if (e === I) E.eE[n] = t; else e.lt.ut = t;
+        o.lt = e.lt;
     }
-    e.ut = e;
-    e.lt = undefined;
+    e.lt = e;
+    e.ut = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.lt) {
+        for (let t = e.eE[E]; t !== undefined; t = t.ut) {
             if (t.se & REACTIVE_IN_HEAP) markNode(t);
         }
     }

package/dist/prod/core/optimistic.js

@@ -52,7 +52,9 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
         e.Ee = n === undefined ? OVERRIDE_UNDEFINED : n;
-    GlobalQueue.Ie !== null && GlobalQueue.Ie(e, n);
+    // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
+    // neither companion present the call is a guaranteed no-op.
+        (e.be !== undefined || e.ge !== undefined) && GlobalQueue.Ie !== null && GlobalQueue.Ie(e, n);
     e.ce = clock;
     insertSubs(e, true);
     schedule();
@@ -216,13 +218,13 @@ function trackOptimisticStore(e) {
     if (GlobalQueue.Pt !== null) return;
     GlobalQueue.Pt = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.Tn = transitionBlocked;
-    GlobalQueue.dn = cleanupCompletedLanes;
+    GlobalQueue.dn = transitionBlocked;
+    GlobalQueue.Tn = cleanupCompletedLanes;
     GlobalQueue.In = runLaneEffects;
     GlobalQueue.Ct = gatedRead;
     GlobalQueue.At = laneSuspends;
     GlobalQueue.Ot = laneReadsCommitted;
-    GlobalQueue.We = recomputeLane;
+    GlobalQueue.Ye = recomputeLane;
     GlobalQueue.Ke = laneAsyncPending;
     GlobalQueue.Me = laneAsyncSettled;
     GlobalQueue.Nn = trackOptimisticStore;

package/dist/prod/core/owner.js

@@ -54,7 +54,7 @@ function disposeChildren(e, n = false, t) {
         if (n.be || n.ge) GlobalQueue.un(n);
     }
     if (n && e.ke) e.Te = null;
-    let l = t ? e.Le : e.me;
+    let l = t ? e.ye : e.me;
     while (l) {
         const e = l.ve;
         if (l.Xe) {
@@ -71,7 +71,7 @@ function disposeChildren(e, n = false, t) {
         l = e;
     }
     if (t) {
-        e.Le = null;
+        e.ye = null;
     } else {
         e.me = null;
         e.Qe = 0;
@@ -90,15 +90,15 @@ function disposeChildren(e, n = false, t) {
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.Et) {
-        const n = e.Et;
-        e.Et = undefined;
+        if (n && e.ft) {
+        const n = e.ft;
+        e.ft = undefined;
         n();
     }
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.ye : e.xe;
+    let t = n ? e.Le : e.xe;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -108,7 +108,7 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.ye = null : e.xe = null;
+    n ? e.Le = null : e.xe = null;
 }
 
 function childId(e, n) {
@@ -235,8 +235,8 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, t, n),
         T: t ? CONFIG_TRANSPARENT : 0,
-        ft: true,
-        Nt: n?.ft ? n.Nt : n,
+        Et: true,
+        Nt: n?.Et ? n.Nt : n,
         me: null,
         ve: null,
         st: null,
@@ -244,8 +244,8 @@ function disposeRootSelf(e = true) {
         C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
         Qe: 0,
-        ye: null,
         Le: null,
+        ye: null,
         Ge: n,
         dispose: disposeRootSelf
     };