@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settleErroredDependents } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTO_DISPOSE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -49,7 +49,7 @@ let snapshotSources = null;
 function ownerInSnapshotScope(e) {
     while (e) {
         if (e.ve) return true;
-        e = e.ke;
+        e = e.Fe;
     }
     return false;
 }
@@ -70,7 +70,7 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e.Fe;
+    let t = e.ke;
     while (t) {
         if (t.ve) {
             t = t.He;
@@ -82,7 +82,7 @@ function releaseSubtree(e) {
             if (e.se & REACTIVE_SNAPSHOT_STALE) {
                 e.se &= ~REACTIVE_SNAPSHOT_STALE;
                 e.se |= REACTIVE_DIRTY;
-                if (dirtyQueue.Ve > e.xe) dirtyQueue.Ve = e.xe;
+                if (dirtyQueue.Ve > e.Le) dirtyQueue.Ve = e.Le;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
@@ -94,7 +94,7 @@ function releaseSubtree(e) {
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.Le;
+            delete e.xe;
             // 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.
@@ -112,25 +112,25 @@ function recompute(e, t = false) {
         deleteFromHeap(e, queueFor(e));
         e.Te = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.Ne || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Fe !== null || e.ye !== null) {
+                if (e.Ne || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ke !== null || e.he !== null) {
             markDisposal(e);
-            e.Qe = e.ye;
-            e.We = e.Fe;
-            e.ye = null;
-            e.Fe = null;
+            e.Qe = e.he;
+            e.We = e.ke;
+            e.he = null;
+            e.ke = null;
             e.qe = 0;
         } else ;
     }
     let i = !!(e.se & REACTIVE_OPTIMISTIC_DIRTY);
-    const l = e._e !== undefined && e._e !== NOT_PENDING;
+    const l = e.De !== undefined && e.De !== NOT_PENDING;
     const u = !!(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
     // be swept (settleErroredDependents, #2949).
-        const o = e.S & STATUS_ERROR ? e._ : undefined;
+        const s = e.S & STATUS_ERROR ? e._ : undefined;
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const s = (e.se & REACTIVE_REASK) !== 0;
+        const o = (e.se & REACTIVE_REASK) !== 0;
     // Captured before the compute clears it on a sync landing: if that landing
     // is transition-held below, the window must stay open until the hold
     // commits (commitPendingNode) — a closed window plus a held value reads as
@@ -142,8 +142,8 @@ function recompute(e, t = false) {
     e.Ze++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.de = clock;
-    let c = e.De === NOT_PENDING ? e.Ue : e.De;
-    let _ = e.xe;
+    let c = e._e === NOT_PENDING ? e.be : e._e;
+    let _ = e.Le;
     let f = tracking;
     let E = currentOptimisticLane;
     tracking = true;
@@ -153,7 +153,7 @@ 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 T = latestReadActive;
+        const N = 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
@@ -161,6 +161,10 @@ function recompute(e, t = false) {
         if (i) {
         const t = GlobalQueue.je(e, true);
         if (t) currentOptimisticLane = t;
+        // `false` = wake-only lane demotion: recompute plain so a mid-tick
+        // latest()/isPending() pull stages instead of direct-committing (#3009).
+        // The predicate lives with the engine (recomputeLane).
+         else if (t === false) i = false;
     } else if (activeTransition && !t && activeTransition.Me.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
@@ -171,9 +175,9 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const N = n && n !== EFFECT_USER;
-    const d = stale;
-    if (N) stale = true;
+    const T = n && n !== EFFECT_USER;
+    const I = stale;
+    if (T) stale = true;
     try {
         if (!false && e.T & CONFIG_SYNC) {
             c = e.ce(c);
@@ -202,9 +206,9 @@ 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.he || e.ue || e.oe !== undefined || e.ge !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
+                if (e.S !== 0 || e.i !== undefined || e._ || e.pe || e.le || e.oe !== undefined || e.Oe !== undefined || e.ge !== undefined || e.u !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
-                if (e.Ke) GlobalQueue.ze(e);
+                if (e.Ke) GlobalQueue.Be(e);
     } catch (t) {
         const n = t instanceof NotReadyError;
         if (n && e.Ee) {
@@ -219,28 +223,28 @@ function recompute(e, t = false) {
         } else {
             // Track pending async in the lane (not the lane's source — it creates the lane
             // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-            if (n && currentOptimisticLane) GlobalQueue.$e(e);
+            if (n && currentOptimisticLane) GlobalQueue.ze(e);
             let i = false;
             if (n) {
-                e.ue = true;
-                if (GlobalQueue.Be !== null) i = GlobalQueue.Be(e, s);
+                e.le = true;
+                if (GlobalQueue.$e !== null) i = GlobalQueue.$e(e, o);
             }
             notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.Ke : undefined);
             if (i) GlobalQueue.k(e);
         }
     } finally {
         tracking = f;
-        latestReadActive = T;
-        if (N) stale = d;
+        latestReadActive = N;
+        if (T) stale = I;
         e.se = REACTIVE_NONE | (t ? e.se & REACTIVE_SNAPSHOT_STALE : 0);
         context = r;
     }
     if (!e._) {
         trimStaleDeps(e);
-        const s = l ? unwrapOverride(e._e) : e.De === NOT_PENDING ? e.Ue : e.De;
+        const o = l ? unwrapOverride(e.De) : e._e === NOT_PENDING ? e.be : e._e;
         let r = false;
         try {
-            r = !n && u || !e.be || !e.be(s, c);
+            r = !n && u || !e.Ue || !e.Ue(o, c);
         } 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
@@ -260,24 +264,24 @@ function recompute(e, t = false) {
                         if (!t) e.C.enqueue(n, e.Xe ??= GlobalQueue.et.bind(null, e));
         }
         if (e._) ; else if (r) {
-            const u = l ? e._e : undefined;
+            const u = l ? e.De : 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.Ne || activeTransition === null) || i) {
-                e.Ue = c;
+                e.be = c;
                 // 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) {
-                    e._e = c === undefined ? OVERRIDE_UNDEFINED : c;
-                    e.De = NOT_PENDING;
+                    e.De = c === undefined ? OVERRIDE_UNDEFINED : c;
+                    e._e = NOT_PENDING;
                 }
             } else {
-                e.De = c;
+                e._e = c;
                 // 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 (a) e.Ee = true;
@@ -290,17 +294,17 @@ function recompute(e, t = false) {
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.o !== null && (!l || i || e._e !== u)) insertSubs(e, i || l);
+                        if (e.o !== null && (!l || i || e.De !== u)) insertSubs(e, i || l);
         } else if (l) {
             // 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.De === NOT_PENDING) queuePendingNode(e);
-            e.De = c;
+            if (e._e === NOT_PENDING) queuePendingNode(e);
+            e._e = c;
             if (a) e.Ee = true;
  // see the held branch above (#2990)
-                } else if (e.xe != _) {
-            for (let t = e.o; t !== null; t = t.le) {
+                } else if (e.Le != _) {
+            for (let t = e.o; t !== null; t = t.ue) {
                 insertIntoHeapHeight(t.fe, queueFor(t.fe));
             }
         }
@@ -309,16 +313,16 @@ function recompute(e, t = false) {
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._error re-set), so this only runs on a genuinely clean recovery.
-                if (o !== undefined && !r && !e._) settleErroredDependents(e, o);
+                if (s !== undefined && !r && !e._) settleErroredDependents(e, s);
     }
     currentOptimisticLane = E;
-    const I = e.De !== NOT_PENDING || e.We !== null || e.Qe !== null || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const d = e._e !== NOT_PENDING || e.We !== null || e.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
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        I && (!t || e.S & STATUS_PENDING) && (!e.Ne || l) && queuePendingNode(e);
+        d && (!t || e.S & STATUS_PENDING) && (!e.Ne || l) && queuePendingNode(e);
     e.Ne && n && activeTransition !== e.Ne && runInTransition(e.Ne, () => recompute(e));
 }
 
@@ -350,37 +354,37 @@ function computed(e, t) {
     const l = {
         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,
+        Ue: t?.equals != null ? t.equals : isEqual,
         ut: t?.unobserved,
-        ye: null,
+        he: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ce: e,
-        Ue: i ? t.loadingValue : undefined,
-        xe: 0,
+        be: i ? t.loadingValue : undefined,
+        Le: 0,
         u: null,
-        ot: undefined,
-        st: null,
+        st: undefined,
+        ot: null,
         tt: null,
         Ye: null,
         Ze: 0,
         o: null,
         rt: null,
-        ke: context,
+        Fe: context,
         He: null,
         ct: null,
-        Fe: null,
+        ke: null,
         se: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
         S: i ? 0 : STATUS_UNINITIALIZED,
         de: clock,
-        De: NOT_PENDING,
+        _e: NOT_PENDING,
         Qe: null,
         We: null,
         Te: null,
         Ne: null,
-        he: false,
+        pe: false,
         Ee: i
     };
     setupComputedNode(l, t);
@@ -393,51 +397,51 @@ function computed(e, t) {
  * 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;
-    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),
-        be: false,
+    const s = u?.transparent ?? false;
+    const o = {
+        id: inheritId(u, s, context),
+        T: (s ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ue: false,
         ut: u?.unobserved,
-        ye: null,
+        he: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ce: e,
-        Ue: undefined,
-        xe: 0,
+        be: undefined,
+        Le: 0,
         u: null,
-        ot: undefined,
-        st: null,
+        st: undefined,
+        ot: null,
         tt: null,
         Ye: null,
         Ze: 0,
         o: null,
         rt: null,
-        ke: context,
+        Fe: context,
         He: null,
         ct: null,
-        Fe: null,
+        ke: null,
         se: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         de: clock,
-        De: NOT_PENDING,
+        _e: NOT_PENDING,
         Qe: null,
         We: null,
         Te: null,
         Ne: null,
-        he: false,
+        pe: false,
         Ee: false,
         Je: false,
         _t: undefined,
         ft: t,
         Et: n,
-        Tt: undefined,
+        Nt: undefined,
         Re: i,
         i: l
     };
-    setupComputedNode(s, lazyOptions);
-    return s;
+    setupComputedNode(o, lazyOptions);
+    return o;
 }
 
 const lazyOptions = {
@@ -445,24 +449,24 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.st = e;
-    const n = context?.Nt ? context.dt : context;
+    e.ot = e;
+    const n = context?.Tt ? context.It : context;
     if (context) {
-        const t = context.Fe;
+        const t = context.ke;
         if (t === null) {
-            context.Fe = e;
+            context.ke = e;
         } else {
             e.He = t;
             t.ct = e;
-            context.Fe = e;
+            context.ke = e;
         }
     }
-    if (n) e.xe = n.xe + 1;
-    if (GlobalQueue.It !== null) GlobalQueue.It(e);
+    if (n) e.Le = n.Le + 1;
+    if (GlobalQueue.dt !== null) GlobalQueue.dt(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
         if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
-            e.Le = e.Ue === undefined ? NO_SNAPSHOT : e.Ue;
+            e.xe = e.be === undefined ? NO_SNAPSHOT : e.be;
             snapshotSources.add(e);
         }
     }
@@ -470,20 +474,20 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        be: t?.equals != null ? t.equals : isEqual,
+        Ue: 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,
         rt: null,
         de: clock,
         lt: n,
         ae: n?.u || null,
-        De: NOT_PENDING
+        _e: NOT_PENDING
     };
     n && (n.u = i);
     if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
-        i.Le = e === undefined ? NO_SNAPSHOT : e;
+        i.xe = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(i);
     }
     return i;
@@ -491,13 +495,13 @@ function signal(e, t, n = null) {
 
 function optimisticSignal(e, t) {
     const n = signal(e, t);
-    n._e = NOT_PENDING;
+    n.De = NOT_PENDING;
     return n;
 }
 
 function optimisticComputed(e, t) {
     const n = computed(e, t);
-    n._e = NOT_PENDING;
+    n.De = NOT_PENDING;
     return n;
 }
 
@@ -567,11 +571,15 @@ function isEqual(e, t) {
  * 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.ce || e.lt || e._e !== undefined || e.Le !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.ce || e.lt || e.De !== undefined || e.xe !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.Nt) t = t.dt;
+    if (t?.Tt) t = t.It;
     if (t && tracking) link(e, t);
-    return !t || e.De === NOT_PENDING ? e.Ue : e.De;
+    // Children-forbidden readers (createTrackedEffect / onSettled callbacks) get
+    // 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._e === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e._e;
 }
 
 function read(e) {
@@ -581,7 +589,7 @@ function read(e) {
     // than the original node (which stays "pending" while held in a transition).
     if (latestReadActive) return GlobalQueue.At(e);
     let t = context;
-    if (t?.Nt) t = t.dt;
+    if (t?.Tt) t = t.It;
     const n = e;
     const i = e.lt;
     const l = i || e;
@@ -593,23 +601,24 @@ function read(e) {
     } else if (typeof n.ce === "function") {
         prepareComputed(e, false);
     }
-    if (!n.ce && l === e && e._e === undefined && e.Le === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.ce && l === e && e.De === 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;
+        // Committed visibility for children-forbidden readers — see readNodeFast.
+                return !t || e._e === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e._e;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
         if (l.ce) {
             const n = queueFor(e);
-            if (l.xe >= n.Ve) {
+            if (l.Le >= n.Ve) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(l);
             }
-            const i = l.xe;
+            const i = l.Le;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.xe && e.ke !== t) {
-                t.xe = i + 1;
+                        if (i >= t.Le && e.Fe !== t) {
+                t.Le = i + 1;
             }
         }
     }
@@ -644,17 +653,17 @@ function read(e) {
         } else throw l._;
     }
     if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.Le;
+        const n = e.xe;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const l = e.De !== NOT_PENDING ? e.De : e.Ue;
+            const l = e._e !== NOT_PENDING ? e._e : e.be;
             if (l !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
-    if (e._e !== undefined && e._e !== NOT_PENDING) {
+    if (e.De !== undefined && e.De !== NOT_PENDING) {
         // A17: the override IS the value for every reader.
-        return unwrapOverride(e._e);
+        return unwrapOverride(e.De);
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
     // a pending mid-transition write sees the committed value. Projection-store
@@ -664,16 +673,18 @@ 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.Rt(e, l, 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 u = !t || currentOptimisticLane !== null && GlobalQueue.Pt(e, l, t) || e.De === NOT_PENDING || stale && e.Ne && activeTransition !== e.Ne ? e.Ue : e.De;
+    // (The lane-context clause lives with the engine.) Children-forbidden readers
+    // (createTrackedEffect / onSettled callbacks) get committed visibility — see
+    // readNodeFast (#3006).
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.Dt(e, l, t) || e._e === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e.Ne && activeTransition !== e.Ne ? e.be : e._e;
     // 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.ht(e, u);
+        if (pendingCheckActive) GlobalQueue.Pt(e, u);
     if (!t && l === e && typeof n.ce === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.o) {
         unobserved(e);
     }
@@ -686,19 +697,19 @@ function setSignal(e, t) {
     // optimisticComputed callers and optimistic store nodes carry an
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
-        if (e._e !== undefined && !projectionWriteActive) return GlobalQueue.Gt(e, t);
-    const n = e.De === NOT_PENDING ? e.Ue : e.De;
+        if (e.De !== undefined && !projectionWriteActive) return GlobalQueue.Gt(e, t);
+    const n = e._e === NOT_PENDING ? e.be : e._e;
     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.Ue || !e.Ue(n, t);
     if (!i) return t;
-    if (e.De === NOT_PENDING) queuePendingNode(e);
-    e.De = t;
+    if (e._e === NOT_PENDING) queuePendingNode(e);
+    e._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.ge !== undefined || e.pe !== undefined) && GlobalQueue.Pe !== null && GlobalQueue.Pe(e, t);
+        (e.Oe !== undefined || e.ge !== undefined) && GlobalQueue.Pe !== null && GlobalQueue.Pe(e, t);
     e.de = clock;
     insertSubs(e);
     schedule();
@@ -713,7 +724,7 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.se & REACTIVE_MANUAL_WRITE) && e.De === NOT_PENDING) {
+    if (!(e.se & REACTIVE_MANUAL_WRITE) && e._e === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }

package/dist/prod/core/effect.js

@@ -62,12 +62,12 @@ function runEffect(t) {
     // same flush must not be hijacked by a later-arriving error status.
         if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t._t = t.Ue;
+        t._t = t.be;
         t.Je = false;
         try {
             t.Et ? t.Et(E, () => {
-                const E = t.Tt;
-                t.Tt = undefined;
+                const E = t.Nt;
+                t.Nt = undefined;
                 E?.();
             }) : console.error(E);
         } catch (E) {
@@ -78,14 +78,14 @@ function runEffect(t) {
         }
         return;
     }
-    const E = t.Tt;
-    t.Tt = undefined;
+    const E = t.Nt;
+    t.Nt = undefined;
     try {
         E?.();
-        const e = t.ft(t.Ue, t._t);
+        const e = t.ft(t.be, t._t);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Tt = e;
+                t.Nt = e;
     } catch (E) {
         t._ = new StatusError(t, E);
         t.S |= STATUS_ERROR;
@@ -94,7 +94,7 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t._t = t.Ue;
+        t._t = t.be;
         t.Je = false;
     }
 }
@@ -114,16 +114,16 @@ GlobalQueue.et = runEffect;
         } finally {}
     };
     const e = computed(() => {
-        const E = e.Tt;
-        e.Tt = undefined;
+        const E = e.Nt;
+        e.Nt = undefined;
         E?.();
         const R = staleValues(t);
-        e.Tt = R;
+        e.Nt = R;
     }, {
         ...E,
         lazy: true
     });
-    e.Tt = undefined;
+    e.Nt = undefined;
     e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     e.Je = true;
     e.Re = EFFECT_TRACKED;
@@ -138,7 +138,7 @@ GlobalQueue.et = runEffect;
             }
         }
     };
-    e.Ft = run;
+    e.ht = run;
     e.C.enqueue(EFFECT_USER, run);
 }
 

package/dist/prod/core/external.js

@@ -64,7 +64,7 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.It = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.dt = externalSourceConfig ? wireExternalSource : null;
     GlobalQueue.St = externalSourceConfig ? externalUntrack : null;
 }