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

package/dist/prod/core/core.js

@@ -1,14 +1,14 @@
 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, 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, OVERRIDE_UNDEFINED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, 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, CONFIG_FW_CHILDREN, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
 import { trimStaleDeps, link, unobserved } from "./graph.js";
 
-import { deleteFromHeap, queueFor, insertIntoHeapHeight, markNode, markHeap, insertIntoHeap } from "./heap.js";
+import { deleteFromHeap, queueFor, insertIntoHeapHeight, enqueueSub, markNode, markHeap, insertIntoHeap } from "./heap.js";
 
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, runInTransition, schedule, dirtyQueue, projectionWriteActive, armReaskClear } from "./scheduler.js";
+import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, runInTransition, schedule, notifyEpoch, dirtyQueue, bumpNotifyEpoch, projectionWriteActive, reaskArmed, armReaskClear } from "./scheduler.js";
 
 import "./invariants.js";
 
@@ -16,7 +16,7 @@ import { disposeChildren, markDisposal, inheritId } from "./owner.js";
 
 GlobalQueue.Ce = recompute;
 
-GlobalQueue.me = disposeChildren;
+GlobalQueue.Fe = disposeChildren;
 
 let tracking = false;
 
@@ -48,8 +48,8 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.ve) return true;
-        e = e.ke;
+        if (e.He) return true;
+        e = e.ve;
     }
     return false;
 }
@@ -60,41 +60,41 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.ve = true;
+    e.He = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.ve = false;
+    e.He = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.Fe;
+    let t = e.ke;
     while (t) {
-        if (t.ve) {
-            t = t.He;
+        if (t.He) {
+            t = t.Ve;
             continue;
         }
-        if (t.ce) {
+        if (t.Se) {
             const e = t;
             e.T &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            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 (e.ie & REACTIVE_SNAPSHOT_STALE) {
+                e.ie &= ~REACTIVE_SNAPSHOT_STALE;
+                e.ie |= REACTIVE_DIRTY;
+                if (dirtyQueue.xe > e.Le) dirtyQueue.xe = e.Le;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.He;
+        t = t.Ve;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.Le;
+            delete e.o?.Qe;
             // 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.
@@ -106,46 +106,50 @@ function clearSnapshots() {
 }
 
 function recompute(e, t = false) {
+    // §12d: any recompute can clean a marked subscriber — invalidate skips.
+    bumpNotifyEpoch();
     const n = e.Re;
     if (!t) {
-        if (e.Ne && (!n || activeTransition) && activeTransition !== e.Ne) globalQueue.initTransition(e.Ne);
+        if (e._e && (!n || activeTransition) && activeTransition !== e._e) globalQueue.initTransition(e._e);
         deleteFromHeap(e, queueFor(e));
-        e.Te = null;
+        if (e.o !== null) e.o.Ee = 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._e || 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 = 0;
+            const t = ext(e);
+            t.We = e.he;
+            t.qe = e.ke;
+            e.he = null;
+            e.ke = null;
+            e.Me = 0;
         } else ;
     }
-    let i = !!(e.se & REACTIVE_OPTIMISTIC_DIRTY);
-    const l = e._e !== undefined && e._e !== NOT_PENDING;
-    const u = !!(e.S & STATUS_UNINITIALIZED);
+    let i = !!(e.ie & REACTIVE_OPTIMISTIC_DIRTY);
+    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.De !== NOT_PENDING && e.o?.De !== 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
     // be swept (settleErroredDependents, #2949).
-        const o = e.S & STATUS_ERROR ? e._ : undefined;
+        const o = e.S & STATUS_ERROR ? e.o?._ : 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 s = (e.ie & 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
     // a pending frame to live observers of the verdict (#2990).
-        const a = e.Ee;
+        const a = e.Ie;
     const r = context;
     context = e;
     e.Ye = null;
     e.Ze++;
-    e.se = REACTIVE_RECOMPUTING_DEPS;
-    e.de = clock;
-    let c = e.De === NOT_PENDING ? e.Ue : e.De;
-    let _ = e.xe;
-    let f = tracking;
-    let E = currentOptimisticLane;
+    e.ie = REACTIVE_RECOMPUTING_DEPS;
+    e.Te = clock;
+    let c = e.Pe === NOT_PENDING ? e.be : e.Pe;
+    let _ = e.Le;
+    let f = false;
+    let E = tracking;
+    let I = currentOptimisticLane;
     tracking = true;
     // A computed's fn establishes its OWN dependencies, so it must never run
     // inside a latest() read window: read() short-circuits through the
@@ -153,7 +157,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,7 +165,11 @@ function recompute(e, t = false) {
         if (i) {
         const t = GlobalQueue.je(e, true);
         if (t) currentOptimisticLane = t;
-    } else if (activeTransition && !t && activeTransition.Me.length) {
+        // `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.Ke.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.
@@ -171,43 +179,45 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const N = n && n !== EFFECT_USER;
+    const T = n && n !== EFFECT_USER;
     const d = stale;
-    if (N) stale = true;
+    if (T) stale = true;
     try {
         if (!false && e.T & CONFIG_SYNC) {
-            c = e.ce(c);
-            e.Te = null;
-            e.Ee = false;
+            c = e.Se(c);
+            if (e.o !== null) e.o.Ee = null;
+            e.Ie = false;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
             // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.Te;
-            const n = e.ce(c);
+            const t = e.o?.Ee;
+            const n = e.Se(c);
             const i = typeof n === "object" && n !== null;
-            const l = e.Te !== t;
-            c = l || !i ? n : handleAsync(e, n);
-            if (!l && !i) {
-                e.Te = null;
+            const u = e.o?.Ee !== t;
+            c = u || !i ? n : handleAsync(e, n);
+            if (!u && !i) {
+                if (e.o !== null) e.o.Ee = null;
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight (inFlightChanged — projections) clears when
                 // its internal handleAsync lands.
-                                e.Ee = false;
+                                e.Ie = 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);
-        // _optimisticLane is only ever assigned by engine paths.
-                if (e.Ke) GlobalQueue.ze(e);
+        // On a status-free node clearStatus is a guaranteed no-op: every field
+        // its body gates on is either _statusFlags or lives in the cold
+        // extension — no extension, no status to clear. (_x from an unrelated
+        // installer just makes clearStatus a cheap re-verified no-op.)
+                if (e.S !== 0 || e.o !== null) clearStatus(e, t);
+        // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
+        // is their sticky presence mark).
+                if (e.T & CONFIG_HAS_LANE && e.o?.Be) GlobalQueue.ze(e);
     } catch (t) {
         const n = t instanceof NotReadyError;
-        if (n && e.Ee) {
+        if (n && e.Ie) {
             // Loading window with an unready sync dependency: register for the
             // source's settle (the settlePendingSource walk runs off
             // _pendingSources + _blocked alone) but take NO read-visible pending
@@ -222,25 +232,31 @@ function recompute(e, t = false) {
             if (n && currentOptimisticLane) GlobalQueue.$e(e);
             let i = false;
             if (n) {
-                e.ue = true;
-                if (GlobalQueue.Be !== null) i = GlobalQueue.Be(e, s);
+                ext(e).ue = true;
+                if (GlobalQueue.Je !== null) i = GlobalQueue.Je(e, s);
             }
-            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.Ke : undefined);
-            if (i) GlobalQueue.k(e);
+            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Be : undefined);
+            if (i) GlobalQueue.p(e);
         }
     } finally {
-        tracking = f;
-        latestReadActive = T;
-        if (N) stale = d;
-        e.se = REACTIVE_NONE | (t ? e.se & REACTIVE_SNAPSHOT_STALE : 0);
+        tracking = E;
+        latestReadActive = N;
+        if (T) stale = d;
+        // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
+        // landed beneath this pass on a link it had already validated. The wipe
+        // below must not key off DIRTY/CHECK — the read-time pull protocol
+        // (markNode(c) in read()) marks the running node as part of ordinary
+        // bookkeeping, and those marks are correctly discarded here.
+                f = (e.ie & REACTIVE_MISSED_WAKE) !== 0;
+        e.ie = REACTIVE_NONE | (t ? e.ie & REACTIVE_SNAPSHOT_STALE : 0);
         context = r;
     }
-    if (!e._) {
+    if (!e.o?._) {
         trimStaleDeps(e);
-        const s = l ? unwrapOverride(e._e) : e.De === NOT_PENDING ? e.Ue : e.De;
+        const s = u ? unwrapOverride(e.o?.De) : e.Pe === NOT_PENDING ? e.be : e.Pe;
         let r = false;
         try {
-            r = !n && u || !e.be || !e.be(s, c);
+            r = !n && l || !e.Ue || !e.Ue(s, 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
@@ -254,91 +270,105 @@ function recompute(e, t = false) {
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
                 if (n && r) {
-            e.Je = !e._;
+            e.Xe = !e.o?._;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.C.enqueue(n, e.Xe ??= GlobalQueue.et.bind(null, e));
+                        if (!t) e.C.enqueue(n, e.et ??= GlobalQueue.tt.bind(null, e));
         }
-        if (e._) ; else if (r) {
-            const u = l ? e._e : undefined;
+        if (e.o?._) ; else if (r) {
+            const l = u ? e.o?.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;
+            n && (activeTransition !== e._e || activeTransition === null) || i) {
+                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;
+                                if (u && i) {
+                    ext(e).De = c === undefined ? OVERRIDE_UNDEFINED : c;
+                    e.Pe = NOT_PENDING;
                 }
             } else {
-                e.De = c;
+                e.Pe = 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;
+                                if (a) e.Ie = true;
                 // Transition-held sync recompute is a write path like setSignal/asyncWrite,
                 // so sync derivations of held sources stay visible to isPending()/latest()
                 // (#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.Ne) && GlobalQueue.Pe !== null) GlobalQueue.Pe(e, c);
+                                if ((activeTransition || e._e) && GlobalQueue.Oe !== null) GlobalQueue.Oe(e, c);
             }
             // 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);
-        } else if (l) {
+                        if (e.u !== null && (!u || i || e.o?.De !== 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.De === NOT_PENDING) queuePendingNode(e);
-            e.De = c;
-            if (a) e.Ee = true;
+            if (e.Pe === NOT_PENDING) queuePendingNode(e);
+            e.Pe = c;
+            if (a) e.Ie = true;
  // see the held branch above (#2990)
-                } else if (e.xe != _) {
-            for (let t = e.o; t !== null; t = t.le) {
-                insertIntoHeapHeight(t.fe, queueFor(t.fe));
+                } else if (e.Le != _) {
+            for (let t = e.u; t !== null; t = t.fe) {
+                insertIntoHeapHeight(t.ae, queueFor(t.ae));
             }
         }
         // Silent recovery: errored → unchanged value fires no notification, but
         // dependents still holding the propagated error consumed their dirty flag
         // 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);
+        // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
+                if (o !== undefined && !r && !e.o?._) settleErroredDependents(e, o);
     }
-    currentOptimisticLane = E;
-    const I = e.De !== NOT_PENDING || e.We !== null || e.Qe !== null || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    currentOptimisticLane = I;
+    const S = e.Pe !== NOT_PENDING || e.o !== null && (e.o.qe !== null || e.o.We !== 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);
-    e.Ne && n && activeTransition !== e.Ne && runInTransition(e.Ne, () => recompute(e));
+        S && (!t || e.S & STATUS_PENDING) && (!e._e || u) && queuePendingNode(e);
+    e._e && n && activeTransition !== e._e && runInTransition(e._e, () => recompute(e));
+    // Missed-wake reschedule (see the finally above): values this pass read
+    // before the nested commit are stale, so run again now that the heap will
+    // accept the node. Equality gates stop same-value landings from cascading,
+    // and a re-run only latches again if another nested commit changes a dep
+    // beneath it — convergent unless deps genuinely keep changing.
+        if (f) {
+        enqueueSub(e);
+        schedule();
+    }
 }
 
 function updateIfNecessary(e) {
-    if (e.se & REACTIVE_CHECK) {
-        for (let t = e.tt; t; t = t.nt) {
-            const n = t.it;
+    // Never re-enter a node that is currently computing: its dep bookkeeping
+    // (_depsTail/_depGen) is live, and a nested recompute would corrupt it.
+    // A mid-pass mark stays latched for recompute's own tail to reschedule
+    // (#3037); readers meanwhile serve the values the pass has so far.
+    if (e.ie & REACTIVE_RECOMPUTING_DEPS) return;
+    if (e.ie & REACTIVE_CHECK) {
+        for (let t = e.nt; t; t = t.it) {
+            const n = t.ut;
             const i = n.lt || n;
-            if (i.ce) {
+            if (i.Se) {
                 updateIfNecessary(i);
             }
-            if (e.se & REACTIVE_DIRTY) {
+            if (e.ie & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e._ && e.de < clock && !e.Te) {
+    if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?._ && e.Te < clock && !e.o?.Ee) {
         recompute(e);
     }
-    e.se = e.se & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.ie = e.ie & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 
 function computed(e, t) {
@@ -347,44 +377,72 @@ function computed(e, t) {
     // `T | undefined` node is a real commit #0. The typeof guard tolerates
     // non-object option values that older call shapes force through `as any`.
         const i = t !== null && typeof t === "object" && "loadingValue" in t;
-    const l = {
+    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?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        be: t?.equals != null ? t.equals : isEqual,
-        ut: t?.unobserved,
-        ye: null,
+        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),
+        Ue: t?.equals != null ? t.equals : isEqual,
+        he: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
-        qe: 0,
-        ce: e,
-        Ue: i ? t.loadingValue : undefined,
-        xe: 0,
-        u: null,
+        Me: 0,
+        Se: e,
+        be: i ? t.loadingValue : undefined,
+        Le: 0,
         ot: undefined,
         st: null,
-        tt: null,
+        nt: null,
         Ye: null,
         Ze: 0,
-        o: null,
+        u: null,
         rt: null,
-        ke: context,
-        He: null,
+        ve: context,
+        Ve: null,
         ct: null,
-        Fe: null,
-        se: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        ke: null,
+        ie: 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,
-        Qe: null,
+        Te: clock,
+        Pe: NOT_PENDING,
+        _e: null,
+        _t: -1,
+        Ie: i,
+        // Cold machinery (async/transition/optimistic/verdict slots) lives one
+        // hop away in the lazily-allocated extension — the core literal MUST
+        // stay under V8's in-object boundary (§12: past ~39 fields every
+        // allocation spills to a backing store and creation cost ~4x's).
+        o: null
+    };
+    if (t?.unobserved) ext(u).ft = t.unobserved;
+    setupComputedNode(u, t);
+    return u;
+}
+
+/** Lazily allocate a node's cold extension (ONE shape for signals and
+ * computeds — `_x` access stays monomorphic). Installers write through
+ * 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 ??= {
+        De: undefined,
+        Et: undefined,
+        Be: undefined,
+        Ge: undefined,
+        ge: undefined,
+        It: undefined,
+        t: 0,
+        Ee: null,
+        _: undefined,
+        ue: undefined,
+        le: undefined,
+        A: undefined,
+        pe: false,
+        l: null,
+        ft: undefined,
+        Qe: undefined,
         We: null,
-        Te: null,
-        Ne: null,
-        he: false,
-        Ee: i
+        qe: null,
+        Nt: undefined
     };
-    setupComputedNode(l, t);
-    return l;
 }
 
 /**
@@ -392,50 +450,48 @@ 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),
-        be: false,
-        ut: u?.unobserved,
-        ye: null,
+        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),
+        Ue: false,
+        he: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
-        qe: 0,
-        ce: e,
-        Ue: undefined,
-        xe: 0,
-        u: null,
+        Me: 0,
+        Se: e,
+        be: undefined,
+        Le: 0,
         ot: undefined,
         st: null,
-        tt: null,
+        nt: null,
         Ye: null,
         Ze: 0,
-        o: null,
+        u: null,
         rt: null,
-        ke: context,
-        He: null,
+        ve: context,
+        Ve: null,
         ct: null,
-        Fe: null,
-        se: REACTIVE_LAZY,
+        ke: null,
+        ie: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
-        de: clock,
-        De: NOT_PENDING,
-        Qe: null,
-        We: null,
-        Te: null,
-        Ne: null,
-        he: false,
-        Ee: false,
-        Je: false,
-        _t: undefined,
-        ft: t,
-        Et: n,
+        Te: clock,
+        Pe: NOT_PENDING,
+        _e: null,
+        _t: -1,
+        Ie: false,
+        Xe: false,
         Tt: undefined,
+        dt: t,
+        St: n,
+        At: undefined,
         Re: i,
-        i: l
+        o: null
     };
+    // Boundary effects carry a status channel; most effects never touch _x.
+        if (u !== undefined) ext(s).A = u;
+    if (l?.unobserved) ext(s).ft = l.unobserved;
     setupComputedNode(s, lazyOptions);
     return s;
 }
@@ -446,23 +502,24 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.st = e;
-    const n = context?.Nt ? context.dt : context;
+    const n = context?.Ct ? context.Ot : context;
     if (context) {
-        const t = context.Fe;
+        const t = context.ke;
         if (t === null) {
-            context.Fe = e;
+            context.ke = e;
         } else {
-            e.He = t;
+            e.Ve = 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.Rt !== null) GlobalQueue.Rt(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;
+            ext(e).Qe = e.be === undefined ? NO_SNAPSHOT : e.be;
+            e.T |= CONFIG_HAS_SNAPSHOT;
             snapshotSources.add(e);
         }
     }
@@ -470,20 +527,32 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        be: t?.equals != null ? t.equals : isEqual,
-        T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
-        ut: t?.unobserved,
-        Ue: e,
-        o: null,
+        Ue: t?.equals != null ? t.equals : isEqual,
+        T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.H ? CONFIG_NO_SNAPSHOT : 0),
+        be: e,
+        u: null,
         rt: null,
-        de: clock,
+        Te: clock,
         lt: n,
-        ae: n?.u || null,
-        De: NOT_PENDING
+        ce: n?.o?.l || null,
+        Pe: 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-
+        // typed error-retry gating); _fn/_statusFlags read falsy-identically as
+        // missing properties on the shared paths (undefined masks to 0).
+        _e: null,
+        _t: -1,
+        o: null
     };
-    n && (n.u = i);
+    if (t?.unobserved) ext(i).ft = t.unobserved;
+    if (n) {
+        ext(n).l = i;
+        n.T |= CONFIG_FW_CHILDREN;
+    }
     if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
-        i.Le = e === undefined ? NO_SNAPSHOT : e;
+        ext(i).Qe = e === undefined ? NO_SNAPSHOT : e;
+        i.T |= CONFIG_HAS_SNAPSHOT;
         snapshotSources.add(i);
     }
     return i;
@@ -491,13 +560,15 @@ function signal(e, t, n = null) {
 
 function optimisticSignal(e, t) {
     const n = signal(e, t);
-    n._e = NOT_PENDING;
+    ext(n).De = NOT_PENDING;
+    n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
 
 function optimisticComputed(e, t) {
     const n = computed(e, t);
-    n._e = NOT_PENDING;
+    ext(n).De = NOT_PENDING;
+    n.T |= CONFIG_OPTIMISTIC;
     return n;
 }
 
@@ -527,11 +598,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.St === null && !tracking && true) return e();
+    if (GlobalQueue.Gt === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.St !== null) return GlobalQueue.St(e);
+        if (GlobalQueue.Gt !== null) return GlobalQueue.Gt(e);
         return e();
     } finally {
         tracking = n;
@@ -543,11 +614,17 @@ function isEqual(e, t) {
  * an isPending() probe (`refresh`) additionally pulls the node fully up to
  * date so its status flags reflect the current graph.
  */ function prepareComputed(e, t) {
-    if (e.se & REACTIVE_LAZY) {
-        e.se &= ~REACTIVE_LAZY;
-        recompute(e, true);
-    } else if (e.se & REACTIVE_DISPOSED) {
+    if (e.ie & REACTIVE_LAZY) {
+        e.ie &= ~REACTIVE_LAZY;
         recompute(e, true);
+    } else if (e.ie & REACTIVE_DISPOSED) {
+        // Two disposal lifecycles share the flag (#3024). Observation-lifecycle
+        // nodes (CONFIG_AUTO_DISPOSE) are dormant — torn down by unobserved()
+        // when the last subscriber left — and reads reawaken them; that is the
+        // pay-for-use contract. Owner-lifecycle nodes are dead: recomputing would
+        // re-run user code in a torn-down tree (and discard manual writes on
+        // derived-writable signals), so reads return the last committed value.
+        if (e.T & CONFIG_AUTO_DISPOSE) recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
     }
@@ -567,11 +644,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.Se || e.lt || e.o?.De !== undefined || e.o?.Qe !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.Nt) t = t.dt;
+    if (t?.Ct) t = t.Ot;
     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.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
 }
 
 function read(e) {
@@ -579,82 +660,93 @@ function read(e) {
     // 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.At(e);
+    if (latestReadActive) return GlobalQueue.Pt(e);
     let t = context;
-    if (t?.Nt) t = t.dt;
+    if (t?.Ct) t = t.Ot;
     const n = e;
     const i = e.lt;
-    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.Ct(e, t, l, i);
-    } else if (typeof n.ce === "function") {
+        GlobalQueue.Dt(e, t, u, i);
+    } else if (typeof n.Se === "function") {
         prepareComputed(e, false);
     }
-    if (!n.ce && l === e && e._e === undefined && e.Le === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.Se && u === e && e.o?.De === undefined && e.o?.Qe === 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.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (l.ce) {
+        if (u.Se) {
             const n = queueFor(e);
-            if (l.xe >= n.Ve) {
+            if (u.Le >= n.xe) {
                 markNode(t);
                 markHeap(n);
-                updateIfNecessary(l);
+                updateIfNecessary(u);
             }
-            const i = l.xe;
+            const i = u.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.ve !== t) {
+                t.Le = i + 1;
             }
         }
     }
-    if (l.S & STATUS_PENDING) {
-        if (t && !(stale && l.Ne && activeTransition !== l.Ne)) {
+    if (u.S & STATUS_PENDING) {
+        if (t && !(stale && u._e && activeTransition !== u._e)) {
             // 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.Ot(l)) {
+            if (currentOptimisticLane === null || GlobalQueue.ht(u)) {
                 if (!tracking && e !== t) link(e, t);
-                throw l._;
+                throw u.o?._;
             }
-        } else if (t && l !== e && l.S & STATUS_UNINITIALIZED) {
+        } else if (t && u.S & STATUS_UNINITIALIZED) {
+            // A stale (render) reader of a node held pending in ANOTHER transition
+            // normally keeps showing the node's committed value instead of
+            // entangling the two transactions — but an uninitialized node has no
+            // committed value to show. Suspend on it (firewall-backed store reads
+            // always took this branch; plain memos now do too): the reader
+            // registers as a reporter of that source, and its pending-node stamp
+            // ties it to the active transaction, so the two transactions merge
+            // when the source settles. Falling through served `undefined` as if
+            // settled and stranded the reader outside both transactions, so it
+            // never re-ran when either landed (#3043 port).
             if (!tracking && e !== t) link(e, t);
-            throw l._;
-        } else if (!t && l.S & STATUS_UNINITIALIZED) {
-            throw l._;
+            throw u.o?._;
+        } else if (!t && u.S & STATUS_UNINITIALIZED) {
+            throw u.o?._;
         }
     }
     // `owner` is the computed itself, or the firewall behind a store node —
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (l.ce && l.S & STATUS_ERROR) {
+        if (u.Se && u.S & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && l.de < clock) {
-            recompute(l);
+        if (tracking && !pendingCheckActive && u.Te < clock) {
+            recompute(u);
             return read(e);
-        } else throw l._;
+        } else throw u.o?._;
     }
     if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.Le;
+        const n = e.o?.Qe;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const l = e.De !== NOT_PENDING ? e.De : e.Ue;
-            if (l !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
+            const u = e.Pe !== NOT_PENDING ? e.Pe : e.be;
+            if (u !== i) t.ie |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
-    if (e._e !== undefined && e._e !== NOT_PENDING) {
+    if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) {
         // A17: the override IS the value for every reader.
-        return unwrapOverride(e._e);
+        return unwrapOverride(e.o?.De);
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
     // a pending mid-transition write sees the committed value. Projection-store
@@ -663,43 +755,57 @@ 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.Rt(e, l, t)) {
-        return e.Ue;
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ft(e, u, t)) {
+        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 l = !t || currentOptimisticLane !== null && GlobalQueue.gt(e, u, t) || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && e._e && activeTransition !== e._e ? e.be : e.Pe;
     // 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 (!t && l === e && typeof n.ce === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.o) {
+        if (pendingCheckActive) GlobalQueue.Ht(e, l);
+    if (!t && u === e && typeof n.Se === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.u) {
         unobserved(e);
     }
-    return u;
+    return l;
 }
 
 function setSignal(e, t) {
-    if (e.Ne && activeTransition !== e.Ne) globalQueue.initTransition(e.Ne);
+    if (e._e && activeTransition !== e._e) globalQueue.initTransition(e._e);
     // The optimistic write path lives with the engine: only optimisticSignal /
     // 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;
+    // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
+    // 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.vt(e, t);
+    const n = e.Pe === NOT_PENDING ? e.be : e.Pe;
     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;
+    const u = e.Pe !== NOT_PENDING;
+    if (!u) queuePendingNode(e);
+    e.Pe = 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.de = clock;
+    // 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.Oe !== null && GlobalQueue.Oe(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.Se !== undefined) e.Te = clock;
+    // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
+    // were already walked — and where nothing has recomputed or linked since
+    // (epoch) — re-stages the value and stops. The walk is idempotent (subs
+    // marked, heap entries flag-guarded, effects queued once); lane and reask
+    // contexts change what a walk MEANS, so they always walk.
+        if (u && e._t === notifyEpoch && currentOptimisticLane === null && !reaskArmed) return t;
     insertSubs(e);
     schedule();
     return t;
@@ -713,11 +819,12 @@ 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.ie & REACTIVE_MANUAL_WRITE) && e.Pe === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.se = e.se & -4 | REACTIVE_MANUAL_WRITE;
+    e.ie = e.ie & -4 | REACTIVE_MANUAL_WRITE;
+    e.kt = clock;
 }
 
 /**
@@ -796,7 +903,19 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.ce === "function" && !(t.se & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.Se === "function" && !(t.ie & REACTIVE_DISPOSED)) {
+        if (t.ie & REACTIVE_MANUAL_WRITE) {
+            // A manual write in the CURRENT tick wins over the refresh (#2692).
+            // A mask stamped in an earlier tick only survives because a
+            // transaction (action) is holding the pending drain open; there the
+            // refresh is a later, explicit re-ask and lifts the mask — otherwise
+            // any setStore early in an action silently swallows every refresh()
+            // for the rest of the transaction (#3026).
+            if (t.kt === clock) return;
+            t.ie &= ~REACTIVE_MANUAL_WRITE;
+            // No REASK below: the batch carries a manual value change, so the
+            // recompute is not a quiet re-ask of an unchanged question.
+                }
         // A refresh with no value-change dirt already queued is a re-ask of the
         // same question: mark it so the recompute classifies any resulting
         // pending window as quiet (not pending). If the node is already dirty
@@ -804,14 +923,14 @@ function staleValues(e, t = true) {
         // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
         // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
         // change followed by refresh() must not be laundered into a quiet re-ask.
-        if (!(t.se & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.se |= REACTIVE_REASK;
+         else if (!(t.ie & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.ie |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.se = t.se & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.ie = t.ie & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }
 }
 
-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 };
+export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, ext, 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 };