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

package/dist/observe/core/async.js

@@ -0,0 +1,824 @@
+import { STATUS_ERROR, STATUS_PENDING, STATUS_NO_VALUE, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_ASYNC, REACTIVE_WINDOW, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, CONFIG_INPUTS_PUBLISHED, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
+
+import { attrHooks } from "./attribution-hooks.js";
+
+import { ext, statusNotifierOf, context, untrack, setSignal } from "./core.js";
+
+import "./dev.js";
+
+import { StatusError, NotReadyError } from "./error.js";
+
+import { unobserved, trimStaleDeps } from "./graph.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { disposeChildren, cleanup } from "./owner.js";
+
+import { guessing, passLane, joinFuture, txOf, holdWorkHook, question, MAINLINE_QUESTION, globalQueue, schedule, clock, flush, freshHook, 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 —
+// 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?.se?.has(t)) return false;
+    (ext(e).se ??= new NewSet).add(t);
+    return true;
+}
+
+function removePendingSource(e, t) {
+    const n = e.T?.se;
+    if (!n?.delete(t)) return false;
+    if (!n.size) e.T.se = 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.T !== null) e.T.se = undefined;
+}
+
+// A rejection-pending only resolves through the settle sweep over the
+// SOURCE's subscribers, so it is retryable iff a tracked read created that
+// 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?.se?.has(t)) return true;
+    }
+    return false;
+}
+
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * 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).fe = 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.m & STATUS_ERROR)) setPendingError(e, t.source, t);
+}
+
+function setPendingError(e, t, n) {
+    if (!t) {
+        if (e.T !== null) e.T.U = null;
+        return;
+    }
+    if (n instanceof NotReadyError && n.source === t) {
+        ext(e).U = n;
+        return;
+    }
+    const r = e.T?.U;
+    if (!(r instanceof NotReadyError) || r.source !== t) {
+        ext(e).U = new NotReadyError(t);
+    }
+}
+
+function forEachDependent(e, t) {
+    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
+// settles and when an `isPending` observer must re-evaluate after a real error):
+// shared scheduling helper in heap.ts (tracked effects bypass the heap).
+// Settle-time counterpart of unlinkSubs' last-one-out check. A lazy node that
+// loses its last subscriber while STATUS_PENDING is exempt from autodispose
+// (the in-flight work is an observer), so whatever CLEARS that pending state
+// must run the release — otherwise the node stays linked and recomputes
+// forever with zero subscribers (#2934). The node's own promise/iterator
+// callbacks handle their own release (settleAutodispose in handleAsync); this
+// covers derivatively-pending dependents, which have no callbacks of their own.
+function releaseIfSettledUnobserved(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
+// sources through its own recursion (no per-node settle callback), so after
+// 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 NewSet;
+    const visit = e => {
+        if (n.has(e)) return;
+        n.add(e);
+        if (!e.o && e.l & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) for (const e of t) 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. Pending recovery uses
+// settlePendingSource to clear inherited status and retry blocked readers.
+// 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).
+/** 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).
+    // 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 || n && e.R & REACTIVE_STAGED_READ && globalQueue.Y && !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.fe = 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 NewSet;
+    const visit = e => {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e.T?.U === t) {
+            enqueueSub(e);
+            n = true;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (n) 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) {
+    // 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;
+    let r;
+    const o = new NewSet;
+    const settle = s => {
+        if (o.has(s) || 
+        // A conditional dropped this source, but another dependency can still
+        // carry it. Only retire pending state inherited through the recovered
+        // branch. Deliberately NOT marked visited on this early return: the
+        // 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(s, t) || !removePendingSource(s, t)) 
+        // 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
+        // is its verdict changing: it runs again. (Verdict readers exist only
+        // with the verdict engine installed.)
+        return holdWorkHook && s.l & CONFIG_VERDICT && enqueueSub(s);
+        o.add(s);
+        s.ie = clock;
+        const f = s.T?.se?.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 u = s.m & STATUS_ERROR;
+        if (f) {
+            if (!u) setPendingError(s, f);
+        } else {
+            s.m &= ~STATUS_PENDING;
+            if (!u) setPendingError(s);
+            // 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 (s.l & CONFIG_HELD) joinFuture(txOf(s));
+            if (s.T?.fe) {
+                enqueueSub(s);
+                n = true;
+            }
+            if (s.T !== null) s.T.fe = 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 (!s.o && s.l & CONFIG_AUTO_DISPOSE) (r ??= []).push(s);
+        }
+        forEachDependent(s, settle);
+    };
+    forEachDependent(e, settle);
+    // 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();
+}
+
+// Object-thenable detection (Promises/A+ shape).
+function isThenable(e) {
+    return e != null && typeof e === "object" && typeof e.then === "function";
+}
+
+/** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
+    const t = e.T?.Se;
+    if (t != null) {
+        e.T.Se = null;
+        t();
+    }
+}
+
+/**
+ * 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 t = context;
+    if (t === null || t.X === undefined || !(t.R & REACTIVE_RECOMPUTING_DEPS)) return;
+    const n = t.T === null;
+    const r = ext(t);
+    // 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 (n) r.Ee = undefined;
+    const o = r.Se;
+    r.Se = o === null ? e : () => {
+        try {
+            o();
+        } finally {
+            e();
+        }
+    };
+}
+
+function handleAsync(e, t, n, 
+// 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
+// pending on another source, not errored.
+r) {
+    let o = false;
+    let s = false;
+    if (typeof t === "object" && t !== null) {
+        untrack(() => {
+            o = t[Symbol.asyncIterator];
+            s = !o && isThenable(t);
+        });
+    }
+    if (!s && !o) {
+        if (e.T !== null) {
+            e.T.Ee = null;
+            if (holdWorkHook) e.l &= ~CONFIG_ASYNC;
+        }
+        // A sync landing is the first real answer for a loadingValue node.
+                e.ce = false;
+        return t;
+    }
+    // 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).Ee = t;
+    // D-25 (verdict.ts `holdWork`): an async memo whose answering pass opened
+    // no verdict window of its own (`markVerdictReader` clears the bit).
+    // Kept by the verdict engine alone (`holdWorkHook`): a build without it
+    // folds the bit's upkeep away.
+        if (holdWorkHook && !(e.R & REACTIVE_WINDOW)) e.l |= CONFIG_ASYNC;
+    // The question this flight answers (A18 provenance, lanes.ts): the action
+    // whose slice asked it; mainline is always the current question.
+        e.T.Ie = 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.T.se = 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 f;
+    const handleError = o => {
+        if (e.T?.Ee !== t) return;
+        // NotReadyError from rejected promises should be treated as pending, not error
+                let s = o instanceof NotReadyError;
+        if (s && 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.T !== null) e.T.Ee = null;
+            parkLoadingWindow(e, o);
+            e.ie = clock;
+            return;
+        }
+        // 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 (s || n || !stageError(e, o)) {
+            notifyStatus(e, s ? 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 (!s) 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.
+                if (s) 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 (!s) releaseSettledDependents(e);
+        r?.(o, s);
+    };
+    const asyncWrite = (r, o) => {
+        if (e.T?.Ee !== 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 s = 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
+        // change (and only then classify it as an async landing).
+                if (attrHooks !== null) attrHooks.asyncStart(e);
+        if (n) {
+            try {
+                n(r);
+            } catch (e) {
+                handleError(e);
+                return;
+            }
+            // A store derive's landing commits through its setter: unheld, the
+            // shown error leaves now, and so does a commit-beneath-a-flight's
+            // CONFIG_INPUTS_PUBLISHED (its first flight's, #4269) — left standing,
+            // a verdict reader of the next flight would suspend instead of being
+            // served the screen; held, both at the derive's commit.
+                        if (!(e.l & CONFIG_HELD)) {
+                e.T.Te = null;
+                e.l &= ~CONFIG_INPUTS_PUBLISHED;
+            }
+            if (s) landStatus(e, true);
+            // Attribution hook: this path landed through the setter (derived
+            // stores, projections), which does not go through setSignal, so the
+            // plain branch's asyncEnd never ran and the flight stayed open — the
+            // next flight counted a committed answer as abandoned (#3947).
+            // direct=true: asyncEnd finalizes either way and stamps an async write
+            // only if the commit moved `_value`/`_time` or parked `_pendingValue`.
+            // A store setter does not move this node's `_value`, so no stamp is
+            // recorded and waterfall chaining through derived stores stays
+            // unmeasured. Outside the try (#2883 — see attribution-hooks.ts).
+                        if (attrHooks !== null) attrHooks.asyncEnd(e, undefined, r, true);
+        } else {
+            // 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`). 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.
+            // Outside the try (#2883 — see attribution-hooks.ts).
+                        if (attrHooks !== null) attrHooks.asyncEnd(e, undefined, r, false);
+        }
+        // First real answer landing: the window closes when the answer becomes
+        // OBSERVABLE. A direct commit is observable now; a staged write
+        // (`_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.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.
+                        trimStaleDeps(e);
+        }
+        settlePendingSource(e);
+        schedule();
+        flush();
+        o?.();
+    };
+    // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+    // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+    // work (a lazy async memo would otherwise tear down and re-execute — one
+    // fetch per suspended re-read). Settling is that observer's release, so
+    // it runs the same last-one-out check the other release sites run.
+    // 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.l & CONFIG_AUTO_DISPOSE && !e.o && !(e.m & STATUS_PENDING)) {
+            unobserved(e);
+            return true;
+        }
+        return false;
+    };
+    // Consumes an AsyncIterable as this flight's value stream. Two postures:
+    // LIVE (called synchronously from this read — the compute returned an
+    // iterable directly, or a sync-settled thenable held one), where the
+    // initial drain may stash a sync first yield for the caller to return and
+    // 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 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 s = false;
+        let u = false;
+        let i = !r;
+        const close = () => {
+            if (u) return;
+            u = true;
+            try {
+                const e = o.return?.();
+                if (isThenable(e)) e.then(undefined, () => {});
+            } catch {}
+        };
+        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. 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).Se = 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 = () => {
+            try {
+                if (!settleAutodispose()) iterate();
+            } catch (e) {
+                handleError(e);
+            }
+        };
+        const iterate = () => {
+            let n, r, l = false, S = false, a = 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 E = o.next();
+            const c = isThenable(E) ? E : {
+                then: e => void e(E)
+            };
+            c.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
+                // sync-thenable producer mid-stream — has no caller reading the
+                // 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 (a && i) {
+                    n = r;
+                    l = true;
+                    if (r.done) u = true;
+                } else if (e.T?.Ee !== t) {
+                    return;
+                } else if (!r.done) {
+                    s = true;
+                    asyncWrite(r.value, iterateOrRelease);
+                } else {
+                    u = true;
+                    if (s) {
+                        schedule();
+                        flush();
+                    } else {
+                        // Empty completion settles like the immediately-done sync path.
+                        asyncWrite(undefined);
+                    }
+                    settleAutodispose();
+                }
+            }, n => {
+                if (a && i) {
+                    r = n;
+                    S = true;
+                } else if (e.T?.Ee === t) {
+                    u = true;
+                    handleError(n);
+                    settleAutodispose();
+                }
+            });
+            a = false;
+            if (S) {
+                // Match the promise branch, but only rethrow during the initial read.
+                u = true;
+                handleError(r);
+                if (i) throw r;
+                return true;
+            }
+            if (l && !n.done) {
+                f = n.value;
+                s = true;
+                return iterate();
+            }
+            return l && n.done;
+        };
+        const l = iterate();
+        // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
+                i = false;
+        return s || l;
+    };
+    // 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 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;
+        if (typeof e === "object" && e !== null) {
+            untrack(() => {
+                n = e[Symbol.asyncIterator];
+            });
+        }
+        if (!n) return false;
+        f = undefined;
+        const r = consumeIterator(e, t);
+        if (!t) u = r;
+        return true;
+    };
+    if (s) {
+        let n = false, r = false, o, s = true;
+        t.then(r => {
+            if (s) {
+                f = r;
+                n = true;
+            } 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?.Ee === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
+                    asyncWrite(r);
+                } catch (e) {
+                    handleError(e);
+                }
+                settleAutodispose();
+            }
+        }, e => {
+            if (s) {
+                o = e;
+                r = true;
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
+        });
+        s = false;
+        if (r) {
+            // Settle through the same status path an async rejection uses, then
+            // unwind the in-progress synchronous read so the errored node isn't
+            // momentarily read as `undefined`.
+            handleError(o);
+            throw o;
+        } else if (!n) {
+            // 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(f)) {
+            // Synchronously-resolved promise: the first real answer landed.
+            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 (u !== null) {
+        if (!u) {
+            // Loading window: serve commit #0 instead of suspending.
+            if (e.ce) return e.le;
+            throw new NotReadyError(context);
+        }
+        // A sync first yield (or immediate empty completion) is the first real
+        // answer; async yields clear inside asyncWrite.
+                e.ce = false;
+    }
+    return f;
+}
+
+function clearStatus(e, t = false) {
+    if (e.T?.se) clearPendingSources(e);
+    if (e.T?.fe) e.T.fe = false;
+    e.m = t ? 0 : e.m & STATUS_UNINITIALIZED;
+    if (e.T?.U) setPendingError(e);
+    const n = statusNotifierOf(e);
+    if (n) n.call(e);
+}
+
+/**
+ * Status clear for a flight LANDING (asyncWrite). A landing answers the
+ * node's OWN question — it retires the node's self entry, not the pending
+ * state its sources propagated onto it. An input re-asked while this flight
+ * was up (a second write to the signal feeding `a` while `b`'s first flight
+ * is in the air, #3373) marks `b` pending on `a` by propagation, with `b`'s
+ * flight still current: nothing superseded it (the re-ask only changed `a`'s
+ * status, not yet its value), so the landing arrives, and a full clear made
+ * `b` answer with the stale value — the newer signal committed beside the
+ * older derived value (`2 / 1`) for the gap (#3376).
+ * With another source still pending the node stays derivatively pending on
+ * it; the landed value is written below (the staged answer is still the
+ * answer for the inputs it was asked with) and the input's own settle
+ * releases it, or its value change recomputes the node into a fresh flight.
+ * `_blocked` clears like a full clear: a landing that passed the `_inFlight`
+ * guard was not superseded by a re-run (recompute nulls `_inFlight` first),
+ * so the flag is the flight's own registration throw — the input settling
+ * unchanged must not re-run the node (an extra flight for the same inputs).
+ * The node is already STATUS_PENDING in that branch (only notifyStatus fills
+ * the set, with status; a loading-window park cannot coexist with a live
+ * flight since registration drops the set), so the flags only change when
+ * 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?.se;
+    // (The full clear below drops the set whether or not self was retired first.)
+        if (n && (n.delete(e), n.size)) {
+        e.T.fe = false;
+        if (t) e.m = STATUS_PENDING;
+        setPendingError(e, n.values().next().value);
+    } else clearStatus(e, t);
+}
+
+function notifyStatus(e, t, n) {
+    // Wrap regular errors to track source node
+    if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
+    const r = t === STATUS_PENDING && n instanceof NotReadyError && n.source;
+    // (CARVE 2: the lane assignment went with the engine.)
+        if (t === STATUS_PENDING && r) {
+        // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
+        if (e.m & STATUS_ERROR) e.T.Te = e.T.U;
+        addPendingSource(e, r);
+        // A re-ask of an error that answered the first read: still no value.
+                e.m = STATUS_PENDING | (e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
+        // Preserve the current source on this propagation so readers park on
+        // the distinct pending source.
+                setPendingError(e, r, n);
+    } else {
+        clearPendingSources(e);
+        // An error answering a node with no value marks it so; a re-ask of it
+        // (pending) is uninitialized again; a write (STATUS_NONE) gives it one.
+                e.m = t | (t === STATUS_ERROR ? e.m & (STATUS_UNINITIALIZED | STATUS_NO_VALUE) ? STATUS_NO_VALUE : 0 : t === STATUS_PENDING && e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
+        ext(e).U = n;
+    }
+    // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
+    // future value until we know otherwise"). Its own source in flight is its
+    // status, not its readers': they read the guess. The flight is the parent
+    // 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`). An input changed
+    // from outside the guess's hold asks a new question: the frame that
+    // changed it is held with that hold (D-34, #4336) — it shows beside the
+    // guess's truth, which reveals at that hold's commit (F-1). A `refresh()`
+    // re-asks the same question: its frame is its own.
+    // (No guess written, no arm.)
+        if (guessing && t === STATUS_PENDING && e.l & CONFIG_GUESS) {
+        if (passLane === null) joinFuture(e.R & REACTIVE_REASK ? null : txOf(e)._parent);
+        return;
+    }
+    const o = statusNotifierOf(e);
+    if (o) {
+        o.call(e);
+        return;
+    }
+    propagateStatus(e, t, n);
+}
+
+/** 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) {
+    const r = t === STATUS_PENDING && n instanceof NotReadyError && n.source;
+    forEachDependent(e, (o, s) => {
+        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
+        // that frame still derives from them while the pass that dropped them is
+        // staged. A source going pending there is a question for the node's NEXT
+        // pass, not a fact about its current one. Re-derived, the pass decides:
+        // it reads the dep and registers through its own read, or reads neither
+        // and is done. Clears and errors still ride every link. A link inside the prefix carries the
+        // pass's generation (`link()`), so the test is O(1); mid-pass the prefix
+        // is what the pass has read so far, and the heap refuses a recomputing
+        // node — a dep it has yet to reach registers through its own read.
+        // A verdict reader likewise (CONFIG_VERDICT), for either status: the
+        // dependency going pending or erroring changed what `isPending`/`latest`
+        // answer, so its pass runs again — it decides, breaking out as the
+        // verdict lane's, going pending through a plain read of its own, or
+        // answering an errored source (`isPending` false; `latest` throws it).
+        // 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.
+        // Not one D-25 makes the hold's work (verdict.ts `holdWork`): an async
+        // memo with no verdict window of its own reads a verdict memo's value,
+        // and that source going pending changes none of its reads — re-derived,
+        // it is served the committed value it already derived from (A10) and
+        // asks that question again. It waits on the source like any derivation
+        // (F-9), and asks its next question once, at the landing (#4397).
+                if (o.l & CONFIG_REDERIVE || holdWorkHook && o.l & CONFIG_VERDICT && !(r && holdWorkHook(o, e)) || t === STATUS_PENDING && s.de !== o.Ne) {
+            enqueueSub(o);
+            schedule();
+            return;
+        }
+        // Already pending on this source (a re-ask of its flight): the status is
+        // unchanged and nothing re-notifies. The re-asking write is held with the
+        // flight the observer waits on (fuzzer #3446 P1): the propagation joins
+        // the observer's transaction. An independent render effect in the same
+        // 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 && r && o.T?.se?.has(r)) {
+            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.Y && !freshHook?.(o, r.ie === clock)) joinFuture(txOf(o));
+            return;
+        }
+        if (t === STATUS_PENDING && r || t !== STATUS_PENDING && (o.T?.U !== n || o.T?.se)) {
+            // 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(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 (t === STATUS_PENDING && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !o.i) joinFuture(txOf(o));
+            }
+            notifyStatus(o, t, n);
+            // A derived store's derive (store/projection.ts): marked, not re-run —
+            // its leaves' readers are not its dependents, so the family walks them.
+                        o.fam?.st(t);
+        }
+    });
+}
+
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, onSupersede, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, removePendingSource, setPendingError, settleErroredDependents, settlePendingSource, stageError };