@solidjs/signals 2.0.0-beta.26 → 2.0.0-beta.27

package/dist/prod/core/action.js

@@ -1,4 +1,4 @@
-import { globalQueue, activeTransition, currentTransition, setActiveTransition, schedule, flush } from "./scheduler.js";
+import { globalQueue, activeTransition, currentTransition, schedule, flush } from "./scheduler.js";
 
 import { isThenable } from "./async.js";
 
@@ -79,13 +79,18 @@ function restoreTransition(e, r) {
         globalQueue.initTransition();
         let o = activeTransition;
         o.ie.push(i);
-        const done = (e, r, s = false) => {
+        const done = (e, r, u = false) => {
             o = currentTransition(o);
-            const u = o.ie.indexOf(i);
-            if (u >= 0) o.ie.splice(u, 1);
-            setActiveTransition(o);
+            const s = o.ie.indexOf(i);
+            if (s >= 0) o.ie.splice(s, 1);
+            // Re-adopt through initTransition like every other resumption site:
+            // a bare setActiveTransition leaves globalQueue._batch as a detached
+            // ambient batch, and anything registered before the scheduled flush
+            // (held writes on a merging transition, optimistic overrides,
+            // affects() marks) lands there with nothing to ever finalize it.
+                        globalQueue.initTransition(o);
             schedule();
-            s ? n(r) : t(e);
+            u ? n(r) : t(e);
         };
         const step = (e, r) => {
             let t;

package/dist/prod/core/async.js

@@ -92,6 +92,37 @@ function releaseSettledDependents(e) {
     if (n) for (const e of n) releaseIfSettledUnobserved(e);
 }
 
+// Error-dimension twin of settlePendingSource's blocked re-enqueue (#2949):
+// a node in STATUS_ERROR that recovers by recomputing to an UNCHANGED value
+// fires no value notification — the recovery is completely silent. But a
+// dependent that re-ran during the error window consumed its dirty flag and
+// committed nothing (the fresh sibling values it read were absorbed into an
+// errored run), so its committed value is stale. The propagated error is one
+// object identity down the whole dependent tree, and holding it is exactly
+// the "blocked on this error" marker — re-enqueue those holders so they
+// re-run: fresh values commit and flow, and a dependent with another
+// still-broken source simply re-errors. The async dimension needs no twin of
+// its own: recovery there passes through a pending window whose re-runners
+// set _blocked and ride settlePendingSource. Walks the full dependent graph
+// (releaseSettledDependents shape): identity holders can sit below an
+// intermediate whose own error state has since been scrubbed or replaced
+// (e.g. an error boundary's tree node).
+function settleErroredDependents(e, n) {
+    let t = false;
+    const r = new Set;
+    const visit = e => {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e._ === n) {
+            enqueueSub(e);
+            t = true;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) schedule();
+}
+
 function settlePendingSource(e) {
     let n = false;
     let t;
@@ -206,8 +237,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e._e === NOT_PENDING) queuePendingNode(e);
-            e._e = r;
+            if (e.De === NOT_PENDING) queuePendingNode(e);
+            e.De = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -215,14 +246,14 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.De !== null && GlobalQueue.De(e, r);
+                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.Se = clock;
         } else if (l) {
             // Route through lane's effect queue for independent flushing
             const n = e.Pe;
             const t = e.Ue;
-            const o = e.Re;
+            const o = e.be;
             try {
                 if (!n && u || !o || !o(r, t)) {
                     e.Ue = r;
@@ -230,7 +261,7 @@ function handleAsync(e, n, t) {
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.De !== null && GlobalQueue.De(e, r);
+                                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -383,13 +414,13 @@ function clearStatus(e, n = false) {
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.be = false;
+        e.Re = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.he || e.Ge) GlobalQueue.ce(e);
-    if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+        if (e.he || e.pe) GlobalQueue.ce(e);
+    if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     if (e.i) e.i();
 }
 
@@ -413,7 +444,7 @@ function notifyStatus(e, n, t, r, o) {
             e._ = t;
         }
         GlobalQueue.ce !== null && GlobalQueue.ce(e);
-        if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+        if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
@@ -439,7 +470,7 @@ function notifyStatus(e, n, t, r, o) {
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r.ge && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.Oe && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
@@ -450,4 +481,4 @@ function notifyStatus(e, n, t, r, o) {
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, releaseSettledDependents, setPendingError, settlePendingSource };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
-import { handleAsync, clearStatus, notifyStatus } from "./async.js";
+import { handleAsync, clearStatus, notifyStatus, settleErroredDependents } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, 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_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";
 
@@ -14,9 +14,9 @@ import "./invariants.js";
 
 import { disposeChildren, markDisposal, inheritId } from "./owner.js";
 
-GlobalQueue.pe = recompute;
+GlobalQueue.Ce = recompute;
 
-GlobalQueue.Ce = disposeChildren;
+GlobalQueue.me = disposeChildren;
 
 let tracking = false;
 
@@ -48,7 +48,7 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.me) return true;
+        if (e.ge) return true;
         e = e.ve;
     }
     return false;
@@ -60,11 +60,11 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.me = true;
+    e.ge = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.me = false;
+    e.ge = false;
     releaseSubtree(e);
     schedule();
 }
@@ -72,7 +72,7 @@ function releaseSnapshotScope(e) {
 function releaseSubtree(e) {
     let t = e.ke;
     while (t) {
-        if (t.me) {
+        if (t.ge) {
             t = t.Fe;
             continue;
         }
@@ -124,19 +124,23 @@ function recompute(e, t = false) {
     let i = !!(e.se & REACTIVE_OPTIMISTIC_DIRTY);
     const u = e.Ae !== undefined && e.Ae !== NOT_PENDING;
     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;
     // 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;
+        const s = (e.se & REACTIVE_REASK) !== 0;
+    const a = context;
     context = e;
     e.We = null;
     e.Ye++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.Se = clock;
-    let a = e._e === NOT_PENDING ? e.Ue : e._e;
-    let r = e.Ve;
-    let c = tracking;
-    let _ = currentOptimisticLane;
+    let r = e.De === NOT_PENDING ? e.Ue : e.De;
+    let c = e.Ve;
+    let _ = tracking;
+    let f = 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
@@ -144,7 +148,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 f = latestReadActive;
+        const E = 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
@@ -162,12 +166,12 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const E = n && n !== EFFECT_USER;
-    const N = stale;
-    if (E) stale = true;
+    const N = n && n !== EFFECT_USER;
+    const T = stale;
+    if (N) stale = true;
     try {
         if (!false && e.T & CONFIG_SYNC) {
-            a = e.ae(a);
+            r = e.ae(r);
             e.Te = null;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
@@ -176,16 +180,16 @@ function recompute(e, t = false) {
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
             const t = e.Te;
-            const n = e.ae(a);
+            const n = e.ae(r);
             const i = typeof n === "object" && n !== null;
             const u = e.Te !== t;
-            a = u || !i ? n : handleAsync(e, n);
+            r = u || !i ? n : handleAsync(e, n);
             if (!u && !i) e.Te = null;
         }
         // 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.be || e.de || e.oe !== undefined || e.he !== undefined || e.Ge !== undefined || e.u !== null) clearStatus(e, t);
+                if (e.S !== 0 || e.i !== undefined || e._ || e.Re || e.de || e.oe !== undefined || e.he !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.Me) GlobalQueue.Ke(e);
     } catch (t) {
@@ -195,23 +199,23 @@ function recompute(e, t = false) {
         let n = false;
         if (t instanceof NotReadyError) {
             e.de = true;
-            if (GlobalQueue.$e !== null) n = GlobalQueue.$e(e, o);
+            if (GlobalQueue.$e !== null) n = GlobalQueue.$e(e, s);
         }
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.Me : undefined);
         if (n) GlobalQueue.k(e);
     } finally {
-        tracking = c;
-        latestReadActive = f;
-        if (E) stale = N;
+        tracking = _;
+        latestReadActive = E;
+        if (N) stale = T;
         e.se = REACTIVE_NONE | (t ? e.se & REACTIVE_SNAPSHOT_STALE : 0);
-        context = s;
+        context = a;
     }
     if (!e._) {
         trimStaleDeps(e);
-        const o = u ? unwrapOverride(e.Ae) : e._e === NOT_PENDING ? e.Ue : e._e;
-        let s = false;
+        const s = u ? unwrapOverride(e.Ae) : e.De === NOT_PENDING ? e.Ue : e.De;
+        let a = false;
         try {
-            s = !n && l || !e.Re || !e.Re(o, a);
+            a = !n && l || !e.be || !e.be(s, r);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -224,13 +228,13 @@ function recompute(e, t = false) {
         // its runner — happen here instead. `!create` matches the previous `initialized`
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
-                if (n && s) {
+                if (n && a) {
             e.Be = !e._;
             // 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.Je ??= GlobalQueue.Xe.bind(null, e));
         }
-        if (e._) ; else if (s) {
+        if (e._) ; else if (a) {
             const l = u ? e.Ae : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
@@ -238,23 +242,23 @@ function recompute(e, t = false) {
             // commitPendingNodes) exists to sequence transition reveals, and
             // paying it per effect on the plain path is pure overhead.
             n && (activeTransition !== e.Ie || activeTransition === null) || i) {
-                e.Ue = a;
+                e.Ue = r;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
                                 if (u && i) {
-                    e.Ae = a === undefined ? OVERRIDE_UNDEFINED : a;
-                    e._e = NOT_PENDING;
+                    e.Ae = r === undefined ? OVERRIDE_UNDEFINED : r;
+                    e.De = NOT_PENDING;
                 }
             } else {
-                e._e = a;
+                e.De = r;
                 // 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.Ie) && GlobalQueue.De !== null) GlobalQueue.De(e, a);
+                                if ((activeTransition || e.Ie) && GlobalQueue._e !== null) GlobalQueue._e(e, r);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
@@ -263,22 +267,28 @@ function recompute(e, t = false) {
             // 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._e === NOT_PENDING) queuePendingNode(e);
-            e._e = a;
-        } else if (e.Ve != r) {
+            if (e.De === NOT_PENDING) queuePendingNode(e);
+            e.De = r;
+        } else if (e.Ve != c) {
             for (let t = e.o; t !== null; t = t.ue) {
                 insertIntoHeapHeight(t.le, queueFor(t.le));
             }
         }
+        // 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 && !a && !e._) settleErroredDependents(e, o);
     }
-    currentOptimisticLane = _;
-    const T = e._e !== NOT_PENDING || e.Qe !== null || e.ye !== null || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    currentOptimisticLane = f;
+    const d = e.De !== NOT_PENDING || e.Qe !== null || e.ye !== 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.Ie || u) && queuePendingNode(e);
+        d && (!t || e.S & STATUS_PENDING) && (!e.Ie || u) && queuePendingNode(e);
     e.Ie && n && activeTransition !== e.Ie && runInTransition(e.Ie, () => recompute(e));
 }
 
@@ -306,7 +316,7 @@ function computed(e, t) {
     const i = {
         id: inheritId(t, n, context),
         T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Re: t?.equals != null ? t.equals : isEqual,
+        be: t?.equals != null ? t.equals : isEqual,
         ut: t?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
@@ -330,12 +340,12 @@ function computed(e, t) {
         se: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         S: STATUS_UNINITIALIZED,
         Se: clock,
-        _e: NOT_PENDING,
+        De: NOT_PENDING,
         ye: null,
         Qe: null,
         Te: null,
         Ie: null,
-        be: false
+        Re: false
     };
     setupComputedNode(i, t);
     return i;
@@ -351,7 +361,7 @@ function computed(e, t) {
     const s = {
         id: inheritId(l, o, context),
         T: (o ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Re: false,
+        be: false,
         ut: l?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
@@ -375,12 +385,12 @@ function computed(e, t) {
         se: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         Se: clock,
-        _e: NOT_PENDING,
+        De: NOT_PENDING,
         ye: null,
         Qe: null,
         Te: null,
         Ie: null,
-        be: false,
+        Re: false,
         Be: false,
         ct: undefined,
         _t: t,
@@ -411,7 +421,7 @@ function setupComputedNode(e, t) {
         }
     }
     if (n) e.Ve = n.Ve + 1;
-    if (GlobalQueue.It !== null) GlobalQueue.It(e);
+    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)) {
@@ -423,7 +433,7 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        Re: t?.equals != null ? t.equals : isEqual,
+        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,
@@ -432,7 +442,7 @@ function signal(e, t, n = null) {
         Se: clock,
         it: n,
         fe: n?.u || null,
-        _e: NOT_PENDING
+        De: NOT_PENDING
     };
     n && (n.u = i);
     if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
@@ -480,11 +490,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.dt === null && !tracking && true) return e();
+    if (GlobalQueue.It === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.dt !== null) return GlobalQueue.dt(e);
+        if (GlobalQueue.It !== null) return GlobalQueue.It(e);
         return e();
     } finally {
         tracking = n;
@@ -524,7 +534,7 @@ function isEqual(e, t) {
     let t = context;
     if (t?.Nt) t = t.Tt;
     if (t && tracking) link(e, t);
-    return !t || e._e === NOT_PENDING ? e.Ue : e._e;
+    return !t || e.De === NOT_PENDING ? e.Ue : e.De;
 }
 
 function read(e) {
@@ -548,7 +558,7 @@ function read(e) {
     }
     if (!n.ae && u === e && e.Ae === undefined && e.xe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e._e === NOT_PENDING ? e.Ue : e._e;
+        return !t || e.De === NOT_PENDING ? e.Ue : e.De;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -582,21 +592,25 @@ function read(e) {
             throw u._;
         }
     }
-    if (e.ae && e.S & STATUS_ERROR) {
+    // `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 (u.ae && 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
-        // - el._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && e.Se < clock) {
-            recompute(e);
+        // - owner._time < clock: only on a later cycle than the one the error was found
+        if (tracking && !pendingCheckActive && u.Se < clock) {
+            recompute(u);
             return read(e);
-        } else throw e._;
+        } else throw u._;
     }
     if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
         const n = e.xe;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e._e !== NOT_PENDING ? e._e : e.Ue;
+            const u = e.De !== NOT_PENDING ? e.De : e.Ue;
             if (u !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
@@ -619,7 +633,7 @@ function read(e) {
     // and for regular signals in stale mode (render effects). Non-stale readers (user
     // effects) see _pendingValue so that latest() and direct reads stay consistent.
     // (The lane-context clause lives with the engine.)
-        const l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e._e === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.Ue : e._e;
+        const l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e.De === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.Ue : e.De;
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
         if (pendingCheckActive) GlobalQueue.Pt(e, l);
@@ -636,18 +650,18 @@ function setSignal(e, t) {
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
         if (e.Ae !== undefined && !projectionWriteActive) return GlobalQueue.ht(e, t);
-    const n = e._e === NOT_PENDING ? e.Ue : e._e;
+    const n = e.De === NOT_PENDING ? e.Ue : e.De;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.Re || !e.Re(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(n, t);
     if (!i) return t;
-    if (e._e === NOT_PENDING) queuePendingNode(e);
-    e._e = t;
+    if (e.De === NOT_PENDING) queuePendingNode(e);
+    e.De = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook).
-        (e.he !== undefined || e.Ge !== undefined) && GlobalQueue.De !== null && GlobalQueue.De(e, t);
+        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, t);
     e.Se = clock;
     insertSubs(e);
     schedule();
@@ -662,7 +676,7 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.se & REACTIVE_MANUAL_WRITE) && e._e === NOT_PENDING) {
+    if (!(e.se & REACTIVE_MANUAL_WRITE) && e.De === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }

package/dist/prod/core/external.js

@@ -64,8 +64,8 @@ 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 ? externalUntrack : null;
+    GlobalQueue.dt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.It = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -61,7 +61,7 @@ function link(l, n, e = false) {
     // read order within the computation.
     const u = n.We;
     if (u !== null && u.nt === l) {
-        u.ge &&= e;
+        u.Oe &&= e;
         return;
     }
     let s = null;
@@ -72,7 +72,7 @@ function link(l, n, e = false) {
             s.nl = n.Ye;
             n.We = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.ge = e;
+                        s.Oe = e;
             return;
         }
     }
@@ -85,7 +85,7 @@ function link(l, n, e = false) {
     if (i !== null && i.le === n && (!t || i.nl === n.Ye)) {
         // 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.ge &&= e; else i.ge = e;
+        if (t) i.Oe &&= e; else i.Oe = e;
         return;
     }
     const o = n.We = l.st = {
@@ -95,7 +95,7 @@ function link(l, n, e = false) {
         ll: i,
         ue: null,
         nl: n.Ye,
-        ge: e
+        Oe: e
     };
     if (u !== null) u.tt = o; else n.et = o;
     if (i !== null) i.ue = o; else l.o = o;

package/dist/prod/core/lanes.js

@@ -37,7 +37,7 @@ const activeLanes = new Set;
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
         adoptCompanionLane(n.he, e);
-    adoptCompanionLane(n.Ge, e);
+    adoptCompanionLane(n.pe, e);
     return e;
 }
 

package/dist/prod/core/optimistic.js

@@ -27,7 +27,7 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     const t = e.Ae !== NOT_PENDING;
     const i = t ? unwrapOverride(e.Ae) : e.Ue;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Re || !e.Re(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -54,7 +54,7 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
         e.Ae = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.he !== undefined || e.Ge !== undefined) && GlobalQueue.De !== null && GlobalQueue.De(e, n);
+        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
     e.Se = clock;
     insertSubs(e, true);
     schedule();
@@ -98,9 +98,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let t = 0; t < n; t++) {
         const n = e[t];
-        if (n.he || n.Ge) GlobalQueue.un(n);
+        if (n.he || n.pe) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.he === n || i.Ge === n)) GlobalQueue.un(i);
+        if (i && (i.he === n || i.pe === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -153,7 +153,7 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, n, t) {
-    if (latestReadActive || e._e === NOT_PENDING || e.ae || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.De === NOT_PENDING || e.ae || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ln.add(t);