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

package/dist/prod/core/scheduler.js

@@ -14,6 +14,8 @@ import { runHeap, enqueueSub, deleteFromHeap } from "./heap.js";
 
 import { devCheckQuiescent } from "./invariants.js";
 
+import { rethrowCleanupError } from "./owner.js";
+
 // Optional-module hooks: module bindings, not `GlobalQueue` statics, so a
 // bundle that never imports the installing module never assigns them — its
 // minifier folds every guarded call site (and the branch behind it) away.
@@ -38,12 +40,12 @@ let endLanesHook = null;
 
 let lanesBlockedHook = null;
 
-function installLaneHooks(e, n, o, l, t, s, u, i, r) {
+function installLaneHooks(e, n, o, t, l, s, u, i, r) {
     laneReadHook = e;
     laneStageHook = n;
     laneOutcomeHook = o;
-    laneWriteHook = l;
-    applyGuessesHook = t;
+    laneWriteHook = t;
+    applyGuessesHook = l;
     laneSeamsHook = s;
     laneCorrectionsHook = u;
     endLanesHook = i;
@@ -73,12 +75,12 @@ let boundarySeamHook = null;
 
 let heldRunHook = null;
 
-function installBoundaryHooks(e, n, o, l, t) {
+function installBoundaryHooks(e, n, o, t, l) {
     catchHook = e;
     freshHook = n;
     hiddenHook = o;
-    boundarySeamHook = l;
-    heldRunHook = t;
+    boundarySeamHook = t;
+    heldRunHook = l;
 }
 
 /** Store (store/store.ts): `park` — the flush parked into `t`: the store
@@ -287,16 +289,16 @@ let judge = null;
 }
 
 function blockedBy(e, n, o = false) {
-    for (let l = 0; l < e.length; l++) {
-        const t = e[l];
-        if (!(t.m & STATUS_PENDING) || t.R & REACTIVE_DISPOSED || t.l & CONFIG_GUESS || t.T.Re !== null && txOf(t) !== n || o && !ownSource(t, n)) continue;
+    for (let t = 0; t < e.length; t++) {
+        const l = e[t];
+        if (!(l.m & STATUS_PENDING) || l.R & REACTIVE_DISPOSED || l.l & CONFIG_GUESS || l.T.Re !== null && txOf(l) !== n || o && !ownSource(l, n)) continue;
         // The frame's own pending observer (off screen: this one holds nothing;
         // the next listed node may).
-                if (t.i === EFFECT_RENDER) {
-            if (onScreen(t, judge ?? n)) return true;
+                if (l.i === EFFECT_RENDER) {
+            if (onScreen(l, judge ?? n)) return true;
             continue;
         }
-        for (let e = t.o; e !== null; e = e.t) {
+        for (let e = l.o; e !== null; e = e.t) {
             const o = e.u;
             // A frame reader: a render effect, or a stale reader of the flight
             // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
@@ -399,9 +401,9 @@ function deferZombie(e) {
 
 /** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
  * what an earlier hold staged under a re-armed boundary). */ function heldUnder(e, n, o) {
-    for (let l = e.De; l !== null; l = l.pe) {
-        if ((l.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(l) !== n) o(l);
-        heldUnder(l, n, o);
+    for (let t = e.De; t !== null; t = t.pe) {
+        if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(t) !== n) o(t);
+        heldUnder(t, n, o);
     }
 }
 
@@ -498,6 +500,8 @@ function schedule() {
 function haltReactivity(e) {
     if (halted) return;
     halted = true;
+    // A cleanup error collected before the halt is dropped (owner.ts).
+        rethrowCleanupError(true);
     let n = "[REACTIVITY_HALTED]";
     // Surface the cause here too: callers rethrow it, but a creation-time throw
     // unwinds through ancestor recomputes that convert it to status instead of
@@ -513,6 +517,15 @@ function haltReactivity(e) {
     o && o(e);
 }
 
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */ function haltReactivityAt(e, n) {
+    haltReactivity(e);
+}
+
 // Logs on the first write after a halt so a frozen interaction is traceable.
 function notifyHalted() {
     if (haltNotified) return;
@@ -599,18 +612,18 @@ class GlobalQueue {
                     // stale stamp was the bridge that entangled unrelated updates
                     // with a never-resolving flight). Its observers are held and
                     // wait on its flight (`blocked`).
-                    if (e.se === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
+                    if (e.ue === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
                     // A34 (2): a tick whose writes net to the committed value made no
                     // proposal (`setShow(false); setShow(true)` on a committed true) —
                     // not staged, not held, pends nothing; a later write to it is
                     // plain mainline. (A node already held stays held when written
                     // back: A34 (1).)
-                                        if (e.se !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.Ue == null && e.T?.me == null && 
+                                        if (e.ue !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.Ue == null && e.T?.me == null && 
                     // The comparator last: a pass that created children (an object
                     // owning a fresh async memo, #4111) must not have it read them.
                     // A NotReady read there is a change (`isSame`).
-                    isSame(e, e.Ie, e.se)) {
-                        e.se = NOT_PENDING;
+                    isSame(e, e.Ie, e.ue)) {
+                        e.ue = NOT_PENDING;
                         e.l &= ~CONFIG_STAGED;
                         continue;
                     }
@@ -664,7 +677,7 @@ class GlobalQueue {
         // This flush's own runs, the lanes' reveals, and the landings' held runs
         // are collected apart and ordered below.
                 const o = this.un;
-        const l = this.un = [ [], [] ];
+        const t = this.un = [ [], [] ];
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
@@ -691,8 +704,8 @@ class GlobalQueue {
         // parked (something async below) — the window is the frame's, the marks
         // are its transaction's; else they release at the seam, verdict-only,
         // nothing to show (affects.ts).
-                const t = n && liveTx(n);
-        releaseAmbientMarksHook?.(t);
+                const l = n && liveTx(n);
+        releaseAmbientMarksHook?.(l);
         // The effect phase: lane work first (displayed ahead of the frame), then
         // this flush's runs, then the runs the landings held from earlier
         // flushes — as one pass would have queued them (#3540: a shell
@@ -700,14 +713,14 @@ class GlobalQueue {
         // write; #3528: a display-ahead swap before the count it is shown
         // beside). A parked frame's runs wait with its transaction instead: the
         // effect phase applies a committed frame.
-                const s = t !== null;
+                const s = l !== null;
         for (let e = 0; e < 2; e++) {
-            if (s) append(t.un[e], o[e]);
+            if (s) append(l.un[e], o[e]);
             // The plain flush — no reveal, no landing, not parked — has nothing to
             // order around its own runs: they are the queue as they stand (the
             // same array, not a copy; `run` takes it whole). Every other seam
             // builds the ordered queue above.
-                        this.un[e] = s || l[e].length || this.un[e].length ? l[e].concat(s ? [] : o[e], this.un[e]) : o[e];
+                        this.un[e] = s || t[e].length || this.un[e].length ? t[e].concat(s ? [] : o[e], this.un[e]) : o[e];
         }
         if (deferredZombies.length !== 0) {
             // Survivors are the displayed frame of a held pass: they rerun for the
@@ -749,8 +762,8 @@ class GlobalQueue {
      *
      * A boundary between the observer and the root (boundaries.ts) is asked
      * first: a fallback catches what is not ready under it, and the root
-     * never hears of it. */    notify(e, n, o, l) {
-        if (catchHook?.(e, o & n, l)) return true;
+     * never hears of it. */    notify(e, n, o, t) {
+        if (catchHook?.(e, o & n, t)) return true;
         if (n & STATUS_PENDING) {
             if (o & STATUS_PENDING) {
                 // A pass that went pending holds its frame: the async's own
@@ -783,28 +796,31 @@ class GlobalQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */ function reruns(e) {
-    for (let n = 0; n < e.En.length; n++) {
-        const o = e.En[n];
+ * it. Truthy when an effect re-derives (`land`). */ function reruns(e) {
+    let n;
+    for (let o = 0; o < e.En.length; o++) {
+        const t = e.En[o];
         // An errored reader's display is its error (D-39): the landing gives it
         // nothing to re-derive, and a re-run would be a read that retries the
         // errored source (#3945).
-                if (o.R & REACTIVE_DISPOSED || o.m & STATUS_ERROR) continue;
-        if (o.R & REACTIVE_FRAME_READ || o.l & CONFIG_VERDICT) {
-            o.R &= ~REACTIVE_FRAME_READ;
-            o.Ae = false;
+                if (t.R & REACTIVE_DISPOSED || t.m & STATUS_ERROR) continue;
+        if (t.R & REACTIVE_FRAME_READ || t.l & CONFIG_VERDICT) {
+            n ||= t.i;
+            t.R &= ~REACTIVE_FRAME_READ;
+            t.Ae = false;
             // Its frame is replaced by the re-derivation: a run one of its
             // children queued this flush (re-run by the same landing) is for the
             // frame being replaced — void too (#3404).
-                        for (let e = o.De; e !== null; e = e.pe) if (e.i) e.Ae = false;
-            enqueueSub(o);
+                        for (let e = t.De; e !== null; e = e.pe) if (e.i) e.Ae = false;
+            enqueueSub(t);
         }
     }
     e.En.length = 0;
+    return n;
 }
 
 /** The landing: the held frame becomes the frame. */ function land(e) {
-    reruns(e);
+    const n = reruns(e);
     if (e.I !== null) releaseMarksHook(e.I);
     // Old children die in the commits (cleanups first), then the stashed
     // effects run ahead of this flush's own. A node a lane took over since
@@ -819,7 +835,15 @@ class GlobalQueue {
     // `u`, which has left `transactions`: the write is this landing's, and
     // the next flush must not park in it (#4089).
         if (flushTransaction === e) flushTransaction = null;
-    releaseQueues(e);
+    // An effect re-derives next round (`reruns`): the held runs wait for it
+    // (D-9, the A15 reveal corollary, #4071). Its re-derivation can discover a
+    // flight — a stale reader whose mainline pass stopped reading it, now
+    // reading the landed world — and a landing that showed its runs first
+    // would reveal the held write beside a frame that can only show its old
+    // value. Queued last in this effect phase, the release hands them to the
+    // next round's own runs, ahead of the re-derivation's: they show with it,
+    // or park with it in the hold its pending opens. The commits stand.
+        if (n) globalQueue.un[1].push(() => releaseQueues(e)); else releaseQueues(e);
 }
 
 /** The held runs join this flush's effect phase after its own runs (the
@@ -922,17 +946,17 @@ function commitPendingNode(e) {
     // commits a value.
         if (!n.X) {
         e.l &= -385;
-        if (e.se !== NOT_PENDING) {
-            e.Ie = e.se;
-            e.se = NOT_PENDING;
+        if (e.ue !== NOT_PENDING) {
+            e.Ie = e.ue;
+            e.ue = NOT_PENDING;
         }
         return;
     }
     // Computeds only from here (`_statusFlags` is not a signal field). A
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
-        const o = e.se === NOT_PENDING && (n.m & STATUS_PENDING) !== 0;
-    const l = e.l & CONFIG_STAGED_ERROR;
+        const o = e.ue === NOT_PENDING && (n.m & STATUS_PENDING) !== 0;
+    const t = e.l & CONFIG_STAGED_ERROR;
     // An answer commits: the error it replaces leaves the display (D-41).
         if (!o && n.T) n.T.de = undefined;
     e.l = o ? e.l & -1048833 | CONFIG_INPUTS_PUBLISHED : e.l & -3147137;
@@ -940,21 +964,21 @@ function commitPendingNode(e) {
     // show, through the ordinary error path (`stageError`). Its readers first
     // see it in the cycle after this seam: a tracked re-read there is not a
     // retry (`read`), or a boundary re-derived by it would retry it forever.
-        if (l) {
-        const o = e.se;
-        e.se = NOT_PENDING;
+        if (t) {
+        const o = e.ue;
+        e.ue = NOT_PENDING;
         e.ie = clock + 1;
         notifyStatus(n, STATUS_ERROR, o);
-    } else if (e.se !== NOT_PENDING) {
-        e.Ie = e.se;
-        e.se = NOT_PENDING;
+    } else if (e.ue !== NOT_PENDING) {
+        e.Ie = e.ue;
+        e.ue = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
                 n.m &= ~STATUS_UNINITIALIZED;
         // A quiet re-ask's classification survives its landing and dies with
         // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
         // the reveal. (The sweep of a node still in flight is not a landing.)
         // The A28 stash goes with it.
-                if (n.T != null) n.T.Ve = false, n.T.Be = NOT_PENDING;
+                if (n.T != null) n.T.Ve = false, n.T.je = NOT_PENDING;
         // An effect with a staged value was born held (L2): its first run is
         // this commit's, not its creation's (A29) — queue it now.
                 if (e.i && e.i !== EFFECT_TRACKED) {
@@ -1018,10 +1042,13 @@ function flush(e) {
     while (scheduled) {
         globalQueue.flush();
     }
+    // A cleanup that threw during the drain, now that the drain is complete
+    // (owner.ts).
+        rethrowCleanupError();
 }
 
 function runQueue(e, n) {
     for (let o = 0; o < e.length; o++) e[o](n);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };

package/dist/prod/core/truth.js

@@ -12,7 +12,7 @@ import { enqueueSub } from "./heap.js";
  * staging a shown lane holds for its next reveal, else its slot; the
  * committed value while it has none (its first lane pass in flight). */
 function laneValueOf(r) {
-    if (!(r.l & CONFIG_GUESS) && r.se !== NOT_PENDING) return r.se;
+    if (!(r.l & CONFIG_GUESS) && r.ue !== NOT_PENDING) return r.ue;
     const t = r.T.v;
     return t !== NOT_PENDING ? t : r.Ie;
 }
@@ -25,7 +25,7 @@ function laneValueOf(r) {
  * value. */ function truthRead(r) {
     if (truth(r)) return laneValueOf(r);
     if (!(r.l & CONFIG_GUESS)) throw new NotReadyError(null);
-    return r.se !== NOT_PENDING ? r.se : r.Ie;
+    return r.ue !== NOT_PENDING ? r.ue : r.Ie;
 }
 
 /** A guess confirmed: its lane's truth readers re-read — of the lane's
@@ -36,8 +36,8 @@ function laneValueOf(r) {
 /** A lane node's value is the truth when every guess beneath it is
  * confirmed — its source staged a value equal to the guess — and nothing
  * beneath it is held in the parent: same inputs, same value. */ function truth(r) {
-    if (r.l & CONFIG_GUESS) return r.se !== NOT_PENDING && r.xe && r.xe(r.T.v, r.se);
-    if (r.se !== NOT_PENDING) return;
+    if (r.l & CONFIG_GUESS) return r.ue !== NOT_PENDING && r.xe && r.xe(r.T.v, r.ue);
+    if (r.ue !== NOT_PENDING) return;
     if (r.l & CONFIG_OVERRIDE) for (let t = r.C; t; t = t.G) if (!truth(t.S)) return;
     return 1;
 }

package/dist/prod/core/verdict.js

@@ -157,7 +157,7 @@ let probeFound = false;
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
     if ((e.m & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.se !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.xe || !e.xe(e.Ie, e.se));
+    return e.ue !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.xe || !e.xe(e.Ie, e.ue));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
@@ -175,7 +175,7 @@ let probeFound = false;
  * a router's link claim probing inside the computation that creates the
  * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
     let t = context;
-    if (t?.je) t = t.Ye;
+    if (t?.Qe) t = t.Ye;
     if (t !== null && tracking) {
         t.l |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
@@ -256,8 +256,8 @@ let probeFound = false;
 }
 
 /** The staging, or the staged error thrown (D-41). */ function staged(e) {
-    if (e.l & CONFIG_STAGED_ERROR) throw e.se;
-    return e.se;
+    if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
+    return e.ue;
 }
 
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
@@ -317,7 +317,10 @@ let probeFound = false;
         if (i) verdictRead(t, r._parent ?? r);
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
-            if (probing && (u || e.se !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.se)))) probeFound = true;
+            if (probing && (u || e.ue !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.ue)))) probeFound = true;
+            // A lane a correction folded under (D-34): `latest()` shows the hold's
+            // world whole — the truth beneath each guess, else what it covered.
+                        if (latestActive && r.folded) return r.folded(null, e);
             return e.T.v;
         }
         if (probing && u) probeFound = true;
@@ -338,7 +341,7 @@ let probeFound = false;
             }
             if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.se !== NOT_PENDING) {
+            if (latestActive && e.ue !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
@@ -351,11 +354,11 @@ let probeFound = false;
         // committed value, so no verdict: `isPending` reads it as its read does —
         // the owner joins the hold (held with it, or caught by a boundary that
         // has not shown content) and answers for the commit, where it is final.
-                if (e.se !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
+                if (e.ue !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
             if (probing && r) joinPass(t, e);
             return staged(e);
         }
-    } else if (e.se !== NOT_PENDING) {
+    } else if (e.ue !== NOT_PENDING) {
         if (n.m & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.q) provisionalVerdict(t, !latestActive && !u);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that

package/dist/prod/deferred.js

@@ -121,7 +121,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
      * does not replace (D-40) — restaged as the committed value, the hold's
      * readers would re-derive against the old input. */    const serve = e => {
         const r = handleAsync(t, e);
-        return t.l & CONFIG_HELD && t.se !== NOT_PENDING ? t.se : r;
+        return t.l & CONFIG_HELD && t.ue !== NOT_PENDING ? t.ue : r;
     };
     const end = () => t.R & REACTIVE_DISPOSED && land(o);
     return accessor(computed(r => {
@@ -133,26 +133,26 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
         // Sticky, and read before this wrapper ever opens the window itself.
                 const n = l ||= !(t.m & STATUS_UNINITIALIZED) && !t.ce;
         if (n) t.ce = true, t.l |= CONFIG_LAGS;
-        let c;
+        let s;
         try {
-            c = e(r);
+            s = e(r);
         } catch (e) {
             // The wrapping form: an unready source parks the node in the window,
             // and the wait is its flight until the source's settle re-runs it.
-            if (n && e instanceof NotReadyError) ask(e);
+            if (n && e instanceof NotReadyError) ask(e); else land(o);
             throw e;
         }
-        if (n && typeof c === "object" && c !== null) {
-            if (isThenable(c)) {
-                ask(c);
-                const done = () => land(c, true);
-                c.then(done, done);
-                return serve(c);
+        if (n && typeof s === "object" && s !== null) {
+            if (isThenable(s)) {
+                ask(s);
+                const done = () => land(s, true);
+                s.then(done, done);
+                return serve(s);
             }
-            const e = c[Symbol.asyncIterator];
+            const e = s[Symbol.asyncIterator];
             if (e) {
                 // A stream's flight ends at its first yield (or its end).
-                const r = e.call(c);
+                const r = e.call(s);
                 let t = true;
                 const done = () => land(o, true);
                 const o = {
@@ -160,7 +160,10 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
                     // promise, as for a plain flight: verdict and value in one flush.
                     next: e => {
                         const o = r.next(e);
-                        if (t) t = false, o.then(done, done);
+                        if (t) {
+                            t = false;
+                            if (isThenable(o)) o.then(done, done); else done();
+                        }
                         return o;
                     },
                     return: e => r.return?.(e) ?? Promise.resolve({
@@ -175,7 +178,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
             }
         }
         land(o);
-        return c;
+        return s;
     }, r));
 }