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

package/dist/observe/core/async.js

@@ -1,20 +1,20 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, CONFIG_GUESS, CONFIG_AUTO_DISPOSE, REACTIVE_DIRTY, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_HELD, CONFIG_OVERRIDE, REACTIVE_ZOMBIE } from "./constants.js";
+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 { attrHooks } from "./attribution-hooks.js";
 
-import { untrack, ext, context, statusNotifierOf, setSignal } from "./core.js";
+import { ext, statusNotifierOf, untrack, context, setSignal } from "./core.js";
 
 import "./dev.js";
 
-import { NotReadyError, StatusError } from "./error.js";
+import { StatusError, NotReadyError } from "./error.js";
 
-import { trimStaleDeps, unobserved } from "./graph.js";
+import { unobserved, trimStaleDeps } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
 import { cleanup } from "./owner.js";
 
-import { question, MAINLINE_QUESTION, passLane, joinFuture, clock, schedule, flush, globalQueue, txOf, GlobalQueue, queuePendingNode } from "./scheduler.js";
+import { passLane, joinFuture, question, MAINLINE_QUESTION, globalQueue, schedule, clock, flush, freshHook, txOf, laneStageHook, queuePendingNode } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -22,22 +22,22 @@ import { question, MAINLINE_QUESTION, passLane, joinFuture, clock, schedule, flu
 // 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.m?.Se?.has(t)) return false;
-    (ext(e).Se ??= new Set).add(t);
+    if (e.T?.fe?.has(t)) return false;
+    (ext(e).fe ??= new Set).add(t);
     return true;
 }
 
 function removePendingSource(e, t) {
-    const n = e.m?.Se;
+    const n = e.T?.fe;
     if (!n?.delete(t)) return false;
-    if (!n.size) e.m.Se = undefined;
+    if (!n.size) e.T.fe = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
     // This set is node-owned and never shared; dropping the sole reference
     // releases the set and every entry without a redundant clear() walk.
-    if (e.m !== null) e.m.Se = undefined;
+    if (e.T !== null) e.T.fe = undefined;
 }
 
 // A rejection-pending only resolves through the settle sweep over the
@@ -46,9 +46,9 @@ function clearPendingSources(e) {
 // (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.G; n; n = n._) {
-        const e = n.I;
-        if (e === t || e.m?.Se?.has(t)) return true;
+    for (let n = e.C; n; n = n.G) {
+        const e = n.S;
+        if (e === t || e.T?.fe?.has(t)) return true;
     }
     return false;
 }
@@ -60,32 +60,32 @@ function retryReaches(e, t) {
  * with NO read-visible pending status and no downstream propagation. Commit
  * #0 keeps serving.
  */ function parkLoadingWindow(e, t) {
-    ext(e).de = true;
+    ext(e).se = true;
     if (t.source) addPendingSource(e, t.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.S & STATUS_ERROR)) setPendingError(e, t.source, t);
+        if (!(e.m & STATUS_ERROR)) setPendingError(e, t.source, t);
 }
 
 function setPendingError(e, t, n) {
     if (!t) {
-        if (e.m !== null) e.m.F = null;
+        if (e.T !== null) e.T.F = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
         ext(e).F = n;
         return;
     }
-    const r = e.m?.F;
+    const r = e.T?.F;
     if (!(r instanceof NotReadyError) || r.source !== t) {
         ext(e).F = new NotReadyError(t);
     }
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.t; n !== null; n = n.o) t(n.l, n);
+    for (let n = e.o; n !== null; n = n.t) t(n.u, n);
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
@@ -99,7 +99,7 @@ function forEachDependent(e, t) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.ee && e.i & CONFIG_AUTO_DISPOSE && !e.t && !(e.R & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+    e.X && e.l & CONFIG_AUTO_DISPOSE && !e.o && !(e.R & REACTIVE_ZOMBIE) && !(e.m & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -112,7 +112,7 @@ function releaseSettledDependents(e) {
     const visit = e => {
         if (n.has(e)) return;
         n.add(e);
-        if (!e.t && e.i & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        if (!e.o && e.l & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
@@ -134,13 +134,42 @@ function releaseSettledDependents(e) {
 // (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).
+/** D-41: an error a pass of a held node found is an answer of
+ * that frame — it ends the wait like a value and shows when a value would.
+ * Staged like one: `_pendingValue` carries it (CONFIG_STAGED_ERROR), readers
+ * in the hold derive from it (`serve` throws it), and the commit publishes
+ * 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) {
+    // 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;
+    // 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.se = false;
+    if (!((e.m &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR)) setPendingError(e);
+    e.ue = t instanceof StatusError ? t : new StatusError(e, t);
+    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).
+        settlePendingSource(e);
+    schedule();
+    return true;
+}
+
 function settleErroredDependents(e, t) {
     let n = false;
     const r = new Set;
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.m?.F === t) {
+        if (e.T?.F === t) {
             enqueueSub(e);
             n = true;
         }
@@ -175,35 +204,35 @@ function settlePendingSource(e, t = e) {
         // when the source went pending, `propagateStatus`), and a landing
         // equal to the committed value notifies nobody — the source settling
         // is its verdict changing: it runs again.
-        return f.i & CONFIG_VERDICT && enqueueSub(f);
+        return f.l & CONFIG_VERDICT && enqueueSub(f);
         o.add(f);
-        f.Ie = clock;
-        const u = f.m?.Se?.values().next().value;
+        f.ie = clock;
+        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.S & STATUS_ERROR;
-        if (u) {
-            if (!s) setPendingError(f, u);
+                const u = f.m & STATUS_ERROR;
+        if (s) {
+            if (!u) setPendingError(f, s);
         } else {
-            f.S &= ~STATUS_PENDING;
-            if (!s) setPendingError(f);
+            f.m &= ~STATUS_PENDING;
+            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.i & CONFIG_HELD) joinFuture(txOf(f));
-            if (f.m?.de) {
+                        if (f.l & CONFIG_HELD) joinFuture(txOf(f));
+            if (f.T?.se) {
                 enqueueSub(f);
                 n = true;
             }
-            if (f.m !== null) f.m.de = 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.
-                        if (!f.t && f.i & CONFIG_AUTO_DISPOSE) (r ??= []).push(f);
+                        if (!f.o && f.l & CONFIG_AUTO_DISPOSE) (r ??= []).push(f);
         }
         forEachDependent(f, settle);
     };
@@ -220,9 +249,9 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const t = e.m?.Ne;
+    const t = e.T?.ae;
     if (t != null) {
-        e.m.Ne = null;
+        e.T.ae = null;
         t();
     }
 }
@@ -242,9 +271,9 @@ r) {
         });
     }
     if (!f && !o) {
-        if (e.m !== null) e.m.Te = null;
+        if (e.T !== null) e.T.Se = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e.De = false;
+                e.ce = false;
         return t;
     }
     // Flight replacement relies on recompute's supersede release for iterator
@@ -252,57 +281,60 @@ r) {
     // 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).Te = t;
+        ext(e).Se = t;
     // The question this flight answers (A18 provenance, lanes.ts): the action
     // whose slice asked it; mainline is always the current question.
-        e.m._e = question || MAINLINE_QUESTION;
+        e.T.Ee = question || MAINLINE_QUESTION;
     // The run that asked this flight read every input without throwing: an
     // input still in flight was masked for it (an active override, A17), so
     // pending state those inputs propagated onto the node earlier does not
     // describe this answer. Drop it — the flight is the node's pending now.
     // 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.m.Se = undefined;
+        e.T.fe = undefined;
     // Attribution hook: a new flight is registered. Fired here (not in the
     // branches below) so every flight shape — plain thenable, iterator, the
     // flattened combinations — is announced exactly once, while the recompute
     // frame that caused it is still on the engine's stack. Not inside a try
     // (#2883 — see attribution-hooks.ts).
         if (attrHooks !== null) attrHooks.flightStart(e, t);
-    let u;
-    const handleError = n => {
-        if (e.m?.Te !== t) return;
+    let s;
+    const handleError = o => {
+        if (e.T?.Se !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
-                let o = n instanceof NotReadyError;
-        if (o && e.De) {
+                let f = o instanceof NotReadyError;
+        if (f && e.ce) {
             // Loading window: the flight died waiting on an unready source. Keep
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.m !== null) e.m.Te = null;
-            parkLoadingWindow(e, n);
-            e.Ie = clock;
+            if (e.T !== null) e.T.Se = null;
+            parkLoadingWindow(e, o);
+            e.ie = clock;
             return;
         }
-        notifyStatus(e, o ? STATUS_PENDING : STATUS_ERROR, n);
+        // 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);
         // 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.
-                if (o) settlePendingSource(e);
-        e.Ie = clock;
+                if (f) settlePendingSource(e);
+        e.ie = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
-                if (!o) releaseSettledDependents(e);
-        r?.(n, o);
+                if (!f) releaseSettledDependents(e);
+        r?.(o, f);
     };
     const asyncWrite = (r, o) => {
-        if (e.m?.Te !== t) return;
+        if (e.T?.Se !== t) 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.S & STATUS_UNINITIALIZED);
+        const f = e.m & STATUS_UNINITIALIZED;
         landStatus(e);
         // Attribution hook: lets the engine snapshot state before the landing
         // branches, so it can tell whether the plain path's setSignal committed a
@@ -315,6 +347,9 @@ r) {
                 handleError(e);
                 return;
             }
+            // A store derive's landing commits through its setter: unheld, the
+            // shown error leaves now; held, at the derive's commit.
+                        if (!(e.l & CONFIG_HELD)) e.T.de = undefined;
             if (f) landStatus(e, true);
             // Attribution hook: this path landed through the setter (derived
             // stores, projections), which does not go through setSignal, so the
@@ -330,14 +365,9 @@ r) {
             // CARVE 2: the override-covered landing (hold + A18 supersession) and the
             // lane-routed landing (derived override, lane effect queue) went with
             // the optimistic engine; every landing is the plain setSignal. A node
-            // already held stages its answer into that hold (`setSignal`).
-            try {
-                setSignal(e, () => r);
-            } catch (t) {
-                // Same containment as above: setSignal's comparator throw is the only
-                // pre-commit failure here, and there is no user callsite to throw to.
-                notifyStatus(e, STATUS_ERROR, t);
-            }
+            // already held stages its answer into that hold (`setSignal`). Its
+            // comparator throw is contained there (`isSame`, A3).
+            setSignal(e, () => r);
             // Attribution hook: this path landed through setSignal, whose write
             // hook already saw any committed change — direct=false lets the engine
             // reclassify that write as an async landing iff it actually committed.
@@ -349,8 +379,8 @@ 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.Oe === NOT_PENDING) {
-            e.De = false;
+                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
             // committed frame yet; `commitPendingNode` trims it.
@@ -369,7 +399,7 @@ r) {
     // Returns whether the node released, so the iterator branch can stop
     // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.i & CONFIG_AUTO_DISPOSE && !e.t && !(e.S & STATUS_PENDING)) {
+        if (e.l & CONFIG_AUTO_DISPOSE && !e.o && !(e.m & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -382,46 +412,52 @@ r) {
     // close registration uses the ambient owner; and DEFERRED (the flattening
     // path — a thenable resolved to an iterable in a later microtask), where
     // there is no caller to serve and no ambient owner: sync-settled steps
-    // write through asyncWrite, and close registration goes through the slot
-    // the thenable branch pre-registered while it still owned the context.
-    // Returns whether a sync answer landed (first yield or empty completion) —
-    // meaningful only in the live posture.
+    // 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]();
         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, () => {});
             } catch {}
         };
-        r ? r(close) : cleanup(close);
+        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.
-                ext(e).Ne = close;
+                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
         // of pumping the stream forever with zero subscribers (#2935).
+        // Later pulls run from an async continuation with no compute catch above
+        // them: a throw invoking the protocol (next(), the step's then) settles
+        // as this flight's error instead of escaping as a rejection (#4112).
                 const iterateOrRelease = () => {
-            if (!settleAutodispose()) iterate();
+            try {
+                if (!settleAutodispose()) iterate();
+            } catch (e) {
+                handleError(e);
+            }
         };
         const iterate = () => {
-            let n, r, l = false, a = false, c = true;
+            let n, 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
             // buffered (seroval's deserialized streams do), so a bare result is
             // assimilated as an already-settled step instead of crashing on `.then`.
-                        const S = o.next();
-            const d = isThenable(S) ? S : {
-                then: e => void e(S)
+                        const c = o.next();
+            const E = isThenable(c) ? c : {
+                then: e => void e(c)
             };
-            d.then(r => {
+            E.then(r => {
                 // The sync stash only serves the INITIAL drain (handleAsync's caller
                 // consumes syncValue / throws NotReady from it). A sync-settled step
                 // after an async gap — seroval buffering values between pulls, a
@@ -429,17 +465,17 @@ r) {
                 // stash: it must write through the async path or the value is
                 // silently dropped. (The deferred posture never has a caller, so
                 // initialRead starts false there and everything writes through.)
-                if (c && i) {
+                if (S && i) {
                     n = r;
                     l = true;
-                    if (r.done) s = true;
-                } else if (e.m?.Te !== t) {
+                    if (r.done) u = true;
+                } else if (e.T?.Se !== t) {
                     return;
                 } else if (!r.done) {
                     f = true;
                     asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    s = true;
+                    u = true;
                     if (f) {
                         schedule();
                         flush();
@@ -450,25 +486,25 @@ r) {
                     settleAutodispose();
                 }
             }, n => {
-                if (c && i) {
+                if (S && i) {
                     r = n;
                     a = true;
-                } else if (e.m?.Te === t) {
-                    s = true;
+                } else if (e.T?.Se === t) {
+                    u = true;
                     handleError(n);
                     settleAutodispose();
                 }
             });
-            c = false;
+            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;
+                s = n.value;
                 f = true;
                 return iterate();
             }
@@ -482,7 +518,7 @@ 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
@@ -496,27 +532,33 @@ r) {
             });
         }
         if (!n) return false;
+        s = undefined;
         const r = consumeIterator(e, t);
-        if (!t) s = r;
+        if (!t) u = r;
         return true;
     };
     if (f) {
         let n = false, r = false, o, f = true;
-        // Close registration for the flattening path. Consumption starts in a
-        // microtask where the ambient owner is gone (or worse, someone else's),
-        // so `cleanup()` can't be used — the close targets el's disposal list
-        // directly, exactly where a live cleanup() during this recompute would
-        // have put it. Only a flight that actually flattens becomes
-        // disposal-bearing.
-                const registerDeferredClose = t => {
-            if (!e.Re) e.Re = t; else if (Array.isArray(e.Re)) e.Re.push(t); else e.Re = [ e.Re, t ];
-        };
         t.then(r => {
             if (f) {
-                u = r;
+                s = r;
                 n = true;
-            } else if (e.m?.Te === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
-                asyncWrite(r);
+            } else {
+                // Flattening consumes the stream as the value: each yield lands
+                // through asyncWrite under this flight's identity; the first one
+                // clears pending exactly like a plain promise resolution would.
+                // Disposed nodes never start a pump (their disposal list already
+                // ran, so nothing could close the iterator). Consumption starts in
+                // a microtask where the ambient owner is gone, so the close
+                // registers on el's own disposal list. Iterator setup here has no
+                // 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;
+                    asyncWrite(r);
+                } catch (e) {
+                    handleError(e);
+                }
                 settleAutodispose();
             }
         }, e => {
@@ -540,35 +582,35 @@ r) {
             // 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.De) return e.Ae;
+            if (e.ce) return e.Ie;
             throw new NotReadyError(context);
-        } else if (!flattenIfIterable(u)) {
+        } else if (!flattenIfIterable(s)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e.De = false;
+            e.ce = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // 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) {
+    if (u !== null) {
+        if (!u) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.De) return e.Ae;
+            if (e.ce) return e.Ie;
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
         // answer; async yields clear inside asyncWrite.
-                e.De = false;
+                e.ce = false;
     }
-    return u;
+    return s;
 }
 
 function clearStatus(e, t = false) {
-    if (e.m?.Se) clearPendingSources(e);
-    if (e.m?.de) if (e.m !== null) e.m.de = false;
-    e.S = t ? 0 : e.S & STATUS_UNINITIALIZED;
-    if (e.m?.F) setPendingError(e);
+    if (e.T?.fe) clearPendingSources(e);
+    if (e.T?.se) if (e.T !== null) e.T.se = false;
+    e.m = t ? 0 : e.m & STATUS_UNINITIALIZED;
+    if (e.T?.F) setPendingError(e);
     const n = statusNotifierOf(e);
     if (n) n.call(e);
 }
@@ -598,11 +640,11 @@ function clearStatus(e, t = false) {
  * 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.m?.Se;
+    const n = 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.m.de = false;
-        if (t) e.S = STATUS_PENDING;
+        e.T.se = false;
+        if (t) e.m = STATUS_PENDING;
         setPendingError(e, n.values().next().value);
     } else clearStatus(e, t);
 }
@@ -614,14 +656,16 @@ function notifyStatus(e, t, n, r) {
     // (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.S = STATUS_PENDING | e.S & STATUS_UNINITIALIZED;
+            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.S = t | (t !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
+            e.m = t | (t !== STATUS_ERROR ? e.m & STATUS_UNINITIALIZED : 0);
             ext(e).F = n;
         }
     }
@@ -631,7 +675,7 @@ 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.i & CONFIG_GUESS) {
+        if (t === STATUS_PENDING && e.l & CONFIG_GUESS) {
         if (passLane === null) joinFuture(null);
         return;
     }
@@ -652,7 +696,7 @@ function notifyStatus(e, t, n, r) {
  * (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;
+        r.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
@@ -672,7 +716,7 @@ 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.i & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && f.Pe !== r.pe) {
+                if (r.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && f.Te !== r.Ne) {
             enqueueSub(r);
             schedule();
             return;
@@ -684,25 +728,25 @@ 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.m?.Se?.has(o)) {
-            if (passLane === null && (r.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.X) joinFuture(txOf(r));
+                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));
             return;
         }
-        if (t === STATUS_PENDING && o || t !== STATUS_PENDING && (r.m?.F !== n || r.m?.Se)) {
+        if (t === STATUS_PENDING && o || t !== STATUS_PENDING && (r.T?.F !== n || r.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 (passLane !== null) GlobalQueue.W(r, passLane, true, e); else {
+                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.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !r.u) joinFuture(txOf(r));
+                                        if (t === STATUS_PENDING && (r.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !r.i) joinFuture(txOf(r));
                 }
             }
             notifyStatus(r, t, n);
@@ -710,4 +754,4 @@ function notifyStatus(e, t, n, r) {
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource, stageError };