@solidjs/signals 2.0.0-rc.16 → 2.0.0-rc.18

package/dist/prod/core/async.js

@@ -1,6 +1,6 @@
-import { STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, CONFIG_GUESS, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DIRTY, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
+import { STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
 
-import { ext, statusNotifierOf, untrack, context, setSignal } from "./core.js";
+import { ext, statusNotifierOf, context, untrack, setSignal } from "./core.js";
 
 import { StatusError, NotReadyError } from "./error.js";
 
@@ -8,7 +8,7 @@ import { unobserved, trimStaleDeps } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { cleanup } from "./owner.js";
+import { disposeChildren, cleanup } from "./owner.js";
 
 import { passLane, joinFuture, question, MAINLINE_QUESTION, globalQueue, schedule, clock, flush, freshHook, txOf, laneStageHook, queuePendingNode } from "./scheduler.js";
 
@@ -17,16 +17,16 @@ import { passLane, joinFuture, question, MAINLINE_QUESTION, globalQueue, schedul
 // created dual state whose migration invariant was easy to break: a third
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
-function addPendingSource(e, t) {
-    if (e.T?.fe?.has(t)) return false;
-    (ext(e).fe ??= new Set).add(t);
+function addPendingSource(e, n) {
+    if (e.T?.fe?.has(n)) return false;
+    (ext(e).fe ??= new NewSet).add(n);
     return true;
 }
 
-function removePendingSource(e, t) {
-    const n = e.T?.fe;
-    if (!n?.delete(t)) return false;
-    if (!n.size) e.T.fe = undefined;
+function removePendingSource(e, n) {
+    const t = e.T?.fe;
+    if (!t?.delete(n)) return false;
+    if (!t.size) e.T.fe = undefined;
     return true;
 }
 
@@ -41,10 +41,10 @@ function clearPendingSources(e) {
 // edge: a dep that IS the source, or one whose own pending chain carries it
 // (pending sources propagate the origin node, so this covers any depth).
 // Also guards branch-local recovery: another dependency may still need the source.
-function retryReaches(e, t) {
-    for (let n = e.C; n; n = n.G) {
-        const e = n.S;
-        if (e === t || e.T?.fe?.has(t)) return true;
+function retryReaches(e, n) {
+    for (let t = e.C; t; t = t.G) {
+        const e = t.S;
+        if (e === n || e.T?.fe?.has(n)) return true;
     }
     return false;
 }
@@ -55,33 +55,33 @@ function retryReaches(e, t) {
  * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
  * with NO read-visible pending status and no downstream propagation. Commit
  * #0 keeps serving.
- */ function parkLoadingWindow(e, t) {
-    ext(e).ue = true;
-    if (t.source) addPendingSource(e, t.source);
+ */ function parkLoadingWindow(e, n) {
+    ext(e).se = true;
+    if (n.source) addPendingSource(e, n.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
     // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
     // a pending-class NotReadyError from a read-invisible park (#2989).
-        if (!(e.m & STATUS_ERROR)) setPendingError(e, t.source, t);
+        if (!(e.m & STATUS_ERROR)) setPendingError(e, n.source, n);
 }
 
-function setPendingError(e, t, n) {
-    if (!t) {
+function setPendingError(e, n, t) {
+    if (!n) {
         if (e.T !== null) e.T.F = null;
         return;
     }
-    if (n instanceof NotReadyError && n.source === t) {
-        ext(e).F = n;
+    if (t instanceof NotReadyError && t.source === n) {
+        ext(e).F = t;
         return;
     }
     const r = e.T?.F;
-    if (!(r instanceof NotReadyError) || r.source !== t) {
-        ext(e).F = new NotReadyError(t);
+    if (!(r instanceof NotReadyError) || r.source !== n) {
+        ext(e).F = new NotReadyError(n);
     }
 }
 
-function forEachDependent(e, t) {
-    for (let n = e.o; n !== null; n = n.t) t(n.u, n);
+function forEachDependent(e, n) {
+    for (let t = e.o; t !== null; t = t.t) n(t.u, t);
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
@@ -103,16 +103,16 @@ function releaseIfSettledUnobserved(e) {
 // the propagation completes, walk the same graph for stranded lazy nodes.
 // Collect-then-release so unobserved() never unlinks under the walk.
 function releaseSettledDependents(e) {
-    let t;
-    const n = new Set;
+    let n;
+    const t = new NewSet;
     const visit = e => {
-        if (n.has(e)) return;
-        n.add(e);
-        if (!e.o && e.l & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        if (t.has(e)) return;
+        t.add(e);
+        if (!e.o && e.l & CONFIG_AUTO_DISPOSE) (n ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
-    if (t) for (const e of t) releaseIfSettledUnobserved(e);
+    if (n) for (const e of n) releaseIfSettledUnobserved(e);
 }
 
 // Error-dimension twin of settlePendingSource's blocked re-enqueue (#2949):
@@ -137,20 +137,22 @@ function releaseSettledDependents(e) {
  * it through the ordinary error path (`commitPendingNode` → `notifyStatus`),
  * dependents included. Not for a lane pass, nor a node with no shown value
  * (born held — its error has no frame to wait behind): those publish now,
- * as before. Returns whether the error was staged. */ function stageError(e, t, n) {
+ * as before. Returns whether the error was staged. */ function stageError(e, n, t) {
     // Held, or — for a pass's own throw — derived from a staging of a flush
     // (REACTIVE_STAGED_READ is this pass's; a landing after the pass cannot
     // read it, the flush it read a staging of has committed or parked since).
     // Staged whether or not the flush has joined a hold yet: a pass that runs
     // before its async sibling joins is the seam's to decide, like a value
     // (#4109). A flush that parks nothing publishes it at its commit (S-38).
-    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q) || passLane) return false;
+    // Not a projection's derive: its readers learn its error through the
+    // family, which the commit's publish never reaches (#4189).
+    if (!(e.l & CONFIG_HELD || t && e.R & REACTIVE_STAGED_READ && globalQueue.q && !e.fam) || passLane) return false;
     // The node answered (an error ends the wait — no longer pending, nor
     // blocked); a shown error stays its display until the commit.
         clearPendingSources(e);
-    if (e.T) e.T.ue = false;
+    if (e.T) e.T.se = false;
     if (!((e.m &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR)) setPendingError(e);
-    e.se = t instanceof StatusError ? t : new StatusError(e, t);
+    e.ue = n instanceof StatusError ? n : new StatusError(e, n);
     e.l |= CONFIG_STAGED | CONFIG_STAGED_ERROR;
     // Readers parked on the flight re-run and derive from the staging; the
     // verdict readers the walk wakes need a flush (#4106).
@@ -159,34 +161,34 @@ function releaseSettledDependents(e) {
     return true;
 }
 
-function settleErroredDependents(e, t) {
-    let n = false;
-    const r = new Set;
+function settleErroredDependents(e, n) {
+    let t = false;
+    const r = new NewSet;
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.T?.F === t) {
+        if (e.T?.F === n) {
             enqueueSub(e);
-            n = true;
+            t = true;
         }
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
-    if (n) schedule();
+    if (t) schedule();
 }
 
 // Retire `source` from pending state along the dependent graph rooted at `el`.
 // By default, `el` is the source whose flight settled or was superseded.
 // With a distinct `source`, `el` is a recovered computation that dropped it:
 // the source may still be pending, so dependents with another path to it stay pending.
-function settlePendingSource(e, t = e) {
+function settlePendingSource(e, n = e) {
     // Landing and branch recovery already cleared el's own set. Superseded
     // re-parks can retain an abandoned self entry (source === el), which must
     // retire in the same walk as its propagated copies.
-    removePendingSource(e, t);
-    let n = false;
+    removePendingSource(e, n);
+    let t = false;
     let r;
-    const o = new Set;
+    const o = new NewSet;
     const settle = f => {
         if (o.has(f) || 
         // A conditional dropped this source, but another dependency can still
@@ -195,7 +197,7 @@ function settlePendingSource(e, t = e) {
         // carrying dependency may itself be a later branch of this same walk
         // (two unchanged memos converging), and its visit must be free to
         // re-examine this node once that branch has retired the source.
-        t !== e && retryReaches(f, t) || !removePendingSource(f, t)) 
+        n !== e && retryReaches(f, n) || !removePendingSource(f, n)) 
         // A19: a verdict reader holds no pending of its own (it was re-derived
         // when the source went pending, `propagateStatus`), and a landing
         // equal to the committed value notifies nobody — the source settling
@@ -203,28 +205,28 @@ function settlePendingSource(e, t = e) {
         return f.l & CONFIG_VERDICT && enqueueSub(f);
         o.add(f);
         f.ie = clock;
-        const u = f.T?.fe?.values().next().value;
+        const s = f.T?.fe?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
         // nulling it here would have reads throw `null` until the re-enqueued
         // retry lands, or lose it entirely if that retry parks again (#2989).
-                const s = f.m & STATUS_ERROR;
-        if (u) {
-            if (!s) setPendingError(f, u);
+                const u = f.m & STATUS_ERROR;
+        if (s) {
+            if (!u) setPendingError(f, s);
         } else {
             f.m &= ~STATUS_PENDING;
-            if (!s) setPendingError(f);
+            if (!u) setPendingError(f);
             // L2: a landing resumes the transaction waiting on it (maintainer: "it
             // resumes the sync frame") — a held reader's re-pass over the landed
             // value is that transaction's work, and the flush that carries it
             // parks into it.
                         if (f.l & CONFIG_HELD) joinFuture(txOf(f));
-            if (f.T?.ue) {
+            if (f.T?.se) {
                 enqueueSub(f);
-                n = true;
+                t = true;
             }
-            if (f.T !== null) f.T.ue = false;
+            if (f.T !== null) f.T.se = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
@@ -236,7 +238,7 @@ function settlePendingSource(e, t = e) {
     // Release before the flush schedule below: unobserved() pulls the node back
     // out of the heap, so the enqueueSub above never recomputes a released node.
         if (r) for (const e of r) releaseIfSettledUnobserved(e);
-    if (n) schedule();
+    if (t) schedule();
 }
 
 // Object-thenable detection (Promises/A+ shape).
@@ -245,14 +247,42 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const t = e.T?.ae;
-    if (t != null) {
+    const n = e.T?.ae;
+    if (n != null) {
         e.T.ae = null;
-        t();
+        n();
     }
 }
 
-function handleAsync(e, t, n, 
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */ function onSupersede(e) {
+    const n = context;
+    if (n === null || n.X === undefined || !(n.R & REACTIVE_RECOMPUTING_DEPS)) return;
+    const t = n.T === null;
+    const r = ext(n);
+    // Allocating the extension mid-run turns `_x?._inFlight` from undefined into
+    // null, which recompute would read as a flight this body registered itself.
+    // Restore undefined here, so the fix costs nothing for code that never
+    // calls onSupersede.
+        if (t) r.Se = undefined;
+    const o = r.ae;
+    r.ae = o === null ? e : () => {
+        try {
+            o();
+        } finally {
+            e();
+        }
+    };
+}
+
+function handleAsync(e, n, t, 
 // The flight rejected (after the node's status is set): a projection
 // tells its leaves' readers, who are not the node's dependents
 // (store/projection.ts). `pending`: a NotReady rejection — the node is
@@ -260,24 +290,24 @@ function handleAsync(e, t, n,
 r) {
     let o = false;
     let f = false;
-    if (typeof t === "object" && t !== null) {
+    if (typeof n === "object" && n !== null) {
         untrack(() => {
-            o = t[Symbol.asyncIterator];
-            f = !o && isThenable(t);
+            o = n[Symbol.asyncIterator];
+            f = !o && isThenable(n);
         });
     }
     if (!f && !o) {
         if (e.T !== null) e.T.Se = null;
         // A sync landing is the first real answer for a loadingValue node.
                 e.ce = false;
-        return t;
+        return n;
     }
     // Flight replacement relies on recompute's supersede release for iterator
     // teardown (#3122): every handleAsync call — including the projection
     // self-registration — runs during a recompute of `el`, which has already
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
-        ext(e).Se = t;
+        ext(e).Se = n;
     // The question this flight answers (A18 provenance, lanes.ts): the action
     // whose slice asked it; mainline is always the current question.
         e.T.Ee = question || MAINLINE_QUESTION;
@@ -288,9 +318,9 @@ r) {
     // The landing retires only the flight's own entry (landStatus, #3373), so
     // an entry that survived here would hold the node past its own answer.
         e.T.fe = undefined;
-    let u;
+    let s;
     const handleError = o => {
-        if (e.T?.Se !== t) return;
+        if (e.T?.Se !== n) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let f = o instanceof NotReadyError;
         if (f && e.ce) {
@@ -306,7 +336,14 @@ r) {
         // D-41: a held node's error is staged (`stageError`). A derived store's
         // readers learn its error through the family, not the derive's
         // dependents: it publishes now.
-                if (f || n || !stageError(e, o)) notifyStatus(e, f ? STATUS_PENDING : STATUS_ERROR, o);
+                if (f || t || !stageError(e, o)) {
+            notifyStatus(e, f ? STATUS_PENDING : STATUS_ERROR, o);
+            // The error is this pass's answer, published now: it replaces the shown
+            // frame as a value's commit would (`commitPendingNode`), so the frame
+            // the pass parked goes instead of waiting for a later success. A no-op
+            // when nothing is parked.
+                        if (!f) disposeChildren(e, false, true);
+        }
         // A NotReady rejection is a landing into another pending source. The
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
@@ -319,16 +356,16 @@ r) {
         r?.(o, f);
     };
     const asyncWrite = (r, o) => {
-        if (e.T?.Se !== t) return;
+        if (e.T?.Se !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.R & REACTIVE_DIRTY) return;
         const f = e.m & STATUS_UNINITIALIZED;
         landStatus(e);
-        if (n) {
+        if (t) {
             try {
-                n(r);
+                t(r);
             } catch (e) {
                 handleError(e);
                 return;
@@ -350,7 +387,7 @@ r) {
         // (`_pendingValue` set inside setSignal) is not — commitPendingNode closes
         // the window when the flush commits it, so no one-frame pulse can leak to
         // observers between the landing and its commit (#2990).
-                if (e.se === NOT_PENDING) {
+                if (e.ue === NOT_PENDING) {
             e.ce = false;
             // The landing published: the dependency tail the flight's pass left
             // linked goes now (A30, #3410). A staged landing has not replaced the
@@ -386,14 +423,14 @@ r) {
     // write through asyncWrite, and close registration targets `owner` (el
     // itself) directly. Returns whether a sync answer landed (first yield or
     // empty completion) — meaningful only in the live posture.
-        const consumeIterator = (n, r) => {
-        const o = n[Symbol.asyncIterator]();
+        const consumeIterator = (t, r) => {
+        const o = t[Symbol.asyncIterator]();
         let f = false;
-        let s = false;
+        let u = false;
         let i = !r;
         const close = () => {
-            if (s) return;
-            s = true;
+            if (u) return;
+            u = true;
             try {
                 const e = o.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
@@ -402,7 +439,11 @@ r) {
         cleanup(close, r);
         // Flight-identity cancellation (#3122): the registration above is the
         // owner-death backstop; the teardown slot fires at the _inFlight release
-        // sites so supersede stops this stream immediately.
+        // sites so supersede stops this stream immediately. Assigned, not
+        // chained (chaining here costs every app bytes): it replaces any
+        // `onSupersede` teardown this run registered earlier, which then falls
+        // back to the owner-cleanup channel. A returned `from()` is unaffected:
+        // `close` calls its `return()`, which runs its own teardown.
                 ext(e).ae = close;
         // Release check before each next pull: an unobserved lazy node must tear
         // down (its close above runs via disposal, closing the iterator) instead
@@ -418,7 +459,7 @@ r) {
             }
         };
         const iterate = () => {
-            let n, r, l = false, a = false, S = true;
+            let t, r, l = false, a = false, S = true;
             // Protocol tolerance, matching `for await`: `await` unwraps whatever
             // next() returns — a thenable OR a bare IteratorResult. Real producers
             // use the bare form as a promise-free fast path when a value is already
@@ -437,16 +478,16 @@ r) {
                 // silently dropped. (The deferred posture never has a caller, so
                 // initialRead starts false there and everything writes through.)
                 if (S && i) {
-                    n = r;
+                    t = r;
                     l = true;
-                    if (r.done) s = true;
-                } else if (e.T?.Se !== t) {
+                    if (r.done) u = true;
+                } else if (e.T?.Se !== n) {
                     return;
                 } else if (!r.done) {
                     f = true;
                     asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    s = true;
+                    u = true;
                     if (f) {
                         schedule();
                         flush();
@@ -456,30 +497,30 @@ r) {
                     }
                     settleAutodispose();
                 }
-            }, n => {
+            }, t => {
                 if (S && i) {
-                    r = n;
+                    r = t;
                     a = true;
-                } else if (e.T?.Se === t) {
-                    s = true;
-                    handleError(n);
+                } else if (e.T?.Se === n) {
+                    u = true;
+                    handleError(t);
                     settleAutodispose();
                 }
             });
             S = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                s = true;
+                u = true;
                 handleError(r);
                 if (i) throw r;
                 return true;
             }
-            if (l && !n.done) {
-                u = n.value;
+            if (l && !t.done) {
+                s = t.value;
                 f = true;
                 return iterate();
             }
-            return l && n.done;
+            return l && t.done;
         };
         const l = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
@@ -489,31 +530,31 @@ r) {
     // Landed-synchronously verdict for a LIVE iterator drain; null when no live
     // drain ran (plain promise flight, or a deferred flatten). Drives the
     // shared NotReady/loading tail below.
-        let s = null;
+        let u = null;
     // Flatten one async level: a thenable that RESOLVES to an AsyncIterable —
     // the shape every async stub returning a stream produces — consumes as the
     // stream itself rather than settling on the iterable object. One level
     // only: A+ `then` already collapses nested thenables, so the resolved
     // value is never itself a thenable.
-        const flattenIfIterable = (e, t) => {
-        let n = false;
+        const flattenIfIterable = (e, n) => {
+        let t = false;
         if (typeof e === "object" && e !== null) {
             untrack(() => {
-                n = e[Symbol.asyncIterator];
+                t = e[Symbol.asyncIterator];
             });
         }
-        if (!n) return false;
-        u = undefined;
-        const r = consumeIterator(e, t);
-        if (!t) s = r;
+        if (!t) return false;
+        s = undefined;
+        const r = consumeIterator(e, n);
+        if (!n) u = r;
         return true;
     };
     if (f) {
-        let n = false, r = false, o, f = true;
-        t.then(r => {
+        let t = false, r = false, o, f = true;
+        n.then(r => {
             if (f) {
-                u = r;
-                n = true;
+                s = r;
+                t = true;
             } else {
                 // Flattening consumes the stream as the value: each yield lands
                 // through asyncWrite under this flight's identity; the first one
@@ -525,7 +566,7 @@ r) {
                 // compute catch above it: a protocol throw settles as this
                 // flight's error (#4112).
                 try {
-                    if (e.T?.Se === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
+                    if (e.T?.Se === n && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
                     asyncWrite(r);
                 } catch (e) {
                     handleError(e);
@@ -548,14 +589,14 @@ r) {
             // momentarily read as `undefined`.
             handleError(o);
             throw o;
-        } else if (!n) {
-            // Loading window: serve commit #0 instead of suspending — first-flight
-            // work on a loadingValue node is loading-class (invisible to
-            // boundaries); the flight itself is already registered in _inFlight and
-            // lands through asyncWrite.
-            if (e.ce) return e.Ie;
-            throw new NotReadyError(context);
-        } else if (!flattenIfIterable(u)) {
+        } else if (!t) {
+            // Not landed: the shared tail below suspends, or — loading window —
+            // serves commit #0 (first-flight work on a loadingValue node is
+            // loading-class, invisible to boundaries; the flight itself is already
+            // registered in _inFlight and lands through asyncWrite). A promise is
+            // never an iterator, so nothing between here and there runs.
+            u = false;
+        } else if (!flattenIfIterable(s)) {
             // Synchronously-resolved promise: the first real answer landed.
             e.ce = false;
         }
@@ -563,10 +604,10 @@ r) {
         // are still inside the synchronous read): full initial-drain semantics
         // apply and the shared tail below settles the verdict.
         }
-    if (o) flattenIfIterable(t);
-    if (s !== null) {
-        if (!s) {
-            // Loading window: serve commit #0 (see the promise branch above).
+    if (o) flattenIfIterable(n);
+    if (u !== null) {
+        if (!u) {
+            // Loading window: serve commit #0 instead of suspending.
             if (e.ce) return e.Ie;
             throw new NotReadyError(context);
         }
@@ -574,16 +615,16 @@ r) {
         // answer; async yields clear inside asyncWrite.
                 e.ce = false;
     }
-    return u;
+    return s;
 }
 
-function clearStatus(e, t = false) {
+function clearStatus(e, n = false) {
     if (e.T?.fe) clearPendingSources(e);
-    if (e.T?.ue) if (e.T !== null) e.T.ue = false;
-    e.m = t ? 0 : e.m & STATUS_UNINITIALIZED;
+    if (e.T?.se) e.T.se = false;
+    e.m = n ? 0 : e.m & STATUS_UNINITIALIZED;
     if (e.T?.F) setPendingError(e);
-    const n = statusNotifierOf(e);
-    if (n) n.call(e);
+    const t = statusNotifierOf(e);
+    if (t) t.call(e);
 }
 
 /**
@@ -610,35 +651,33 @@ function clearStatus(e, t = false) {
  * the first landing retires UNINITIALIZED. `_error` must move off self: a
  * reader thrown NotReady(self) would park on a retired entry. Companions
  * keep their verdict (pending before and after; the write re-syncs them).
- */ function landStatus(e, t = false) {
-    const n = e.T?.fe;
+ */ function landStatus(e, n = false) {
+    const t = e.T?.fe;
     // (The full clear below drops the set whether or not self was retired first.)
-        if (n && (n.delete(e), n.size)) {
-        e.T.ue = false;
-        if (t) e.m = STATUS_PENDING;
-        setPendingError(e, n.values().next().value);
-    } else clearStatus(e, t);
+        if (t && (t.delete(e), t.size)) {
+        e.T.se = false;
+        if (n) e.m = STATUS_PENDING;
+        setPendingError(e, t.values().next().value);
+    } else clearStatus(e, n);
 }
 
-function notifyStatus(e, t, n, r) {
+function notifyStatus(e, n, t) {
     // Wrap regular errors to track source node
-    if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
-    const o = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
+    if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
+    const r = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
     // (CARVE 2: the lane assignment went with the engine.)
-        {
-        if (t === STATUS_PENDING && o) {
-            // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
-            if (e.m & STATUS_ERROR) e.T.de = e.T.F;
-            addPendingSource(e, o);
-            e.m = STATUS_PENDING | e.m & STATUS_UNINITIALIZED;
-            // Preserve the current source on this propagation so readers park on
-            // the distinct pending source.
-                        setPendingError(e, o, n);
-        } else {
-            clearPendingSources(e);
-            e.m = t | (t !== STATUS_ERROR ? e.m & STATUS_UNINITIALIZED : 0);
-            ext(e).F = n;
-        }
+        if (n === STATUS_PENDING && r) {
+        // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
+        if (e.m & STATUS_ERROR) e.T.de = e.T.F;
+        addPendingSource(e, r);
+        e.m = STATUS_PENDING | e.m & STATUS_UNINITIALIZED;
+        // Preserve the current source on this propagation so readers park on
+        // the distinct pending source.
+                setPendingError(e, r, t);
+    } else {
+        clearPendingSources(e);
+        e.m = n | (n !== STATUS_ERROR ? e.m & STATUS_UNINITIALIZED : 0);
+        ext(e).F = t;
     }
     // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
     // future value until we know otherwise"). Its own source in flight is its
@@ -646,28 +685,26 @@ function notifyStatus(e, t, n, r) {
     // transition's to wait on — the frame it was asked in holds (A17: "a
     // transition whose optimistic node is still pending on its own fetch is
     // not complete"), through the node itself (`blocked`).
-        if (t === STATUS_PENDING && e.l & CONFIG_GUESS) {
+        if (n === STATUS_PENDING && e.l & CONFIG_GUESS) {
         if (passLane === null) joinFuture(null);
         return;
     }
-    const f = statusNotifierOf(e);
-    if (f) {
-        {
-            f.call(e);
-        }
+    const o = statusNotifierOf(e);
+    if (o) {
+        o.call(e);
         return;
     }
-    propagateStatus(e, t, n);
+    propagateStatus(e, n, t);
 }
 
 /** The dependents' half of `notifyStatus`: `el`'s status reaches each
  * subscriber as a propagated mark (or a re-derive). On its own for a store
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
- * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, t, n, r) {
-    const o = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
-    forEachDependent(e, (r, f) => {
-        r.ie = clock;
+ * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, n, t) {
+    const r = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
+    forEachDependent(e, (o, f) => {
+        o.ie = clock;
         // A pending mark on a kept-tail link re-derives the subscriber instead of
         // marking it (A30, #3494 review; fuzzer latest-1 #2141; #3519 review).
         // Past `_depsTail` lie the committed frame's deps, kept by A30 because
@@ -687,8 +724,8 @@ function notifyStatus(e, t, n, r) {
         // Inheriting the error would make a probe's reader errored. A boundary's
         // output (CONFIG_REDERIVE, boundaries.ts) the same: content or fallback
         // is its pass's call.
-                if (r.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && f.Te !== r.Ne) {
-            enqueueSub(r);
+                if (o.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || n === STATUS_PENDING && f.Te !== o.Ne) {
+            enqueueSub(o);
             schedule();
             return;
         }
@@ -699,30 +736,28 @@ function notifyStatus(e, t, n, r) {
         // frame still passes through — its pass is the frame's (#3372, compiled
         // shape: the unmount it stages makes the observer a zombie whose say is
         // moot for this transaction, A15 #3463).
-                if (t === STATUS_PENDING && o && r.T?.fe?.has(o)) {
-            if (passLane === null && (r.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.q && !freshHook?.(r, o.ie === clock)) joinFuture(txOf(r));
+                if (n === STATUS_PENDING && r && o.T?.fe?.has(r)) {
+            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.q && !freshHook?.(o, r.ie === clock)) joinFuture(txOf(o));
             return;
         }
-        if (t === STATUS_PENDING && o || t !== STATUS_PENDING && (r.T?.F !== n || r.T?.fe)) {
+        if (n === STATUS_PENDING && r || n !== STATUS_PENDING && (o.T?.F !== t || o.T?.fe)) {
             // The marked subscriber is queued for the commit sweep so its status
             // bookkeeping (loading window, uninitialized clear) runs with the flush
             // — with the lane, when the pass propagating is the lane's work and
             // the dependent's pending is the lane's own flight (`laneStage`).
-            {
-                // (No answer: a pending propagation leaves a written guess a guess.)
-                if (laneStageHook && passLane !== null) laneStageHook(r, passLane, true, e); else {
-                    queuePendingNode(r);
-                    // A15 (#3443): pending propagates onto a held memo without
-                    // recomputing it, and the propagation itself enters the memo's
-                    // transaction — the flight flows into a memo that transaction
-                    // holds, so the write that started it is held with it. A render
-                    // effect's membership is its pass's (`notify`), never sticky.
-                                        if (t === STATUS_PENDING && (r.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !r.i) joinFuture(txOf(r));
-                }
+            // (No answer: a pending propagation leaves a written guess a guess.)
+            if (laneStageHook && passLane !== null) laneStageHook(o, passLane, true, e); else {
+                queuePendingNode(o);
+                // A15 (#3443): pending propagates onto a held memo without
+                // recomputing it, and the propagation itself enters the memo's
+                // transaction — the flight flows into a memo that transaction
+                // holds, so the write that started it is held with it. A render
+                // effect's membership is its pass's (`notify`), never sticky.
+                                if (n === STATUS_PENDING && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !o.i) joinFuture(txOf(o));
             }
-            notifyStatus(r, t, n);
+            notifyStatus(o, n, t);
         }
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource, stageError };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, onSupersede, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource, stageError };