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

package/dist/observe/core/core.js

@@ -1,6 +1,6 @@
 import { notifyStatus, releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, stageError, settlePendingSource, releaseIfSettledUnobserved, settleErroredDependents } from "./async.js";
 
-import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_PLUMBING, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, CONFIG_STAGED_ERROR, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, STATUS_NONE } from "./constants.js";
+import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_PLUMBING, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, CONFIG_STAGED_ERROR, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, NewSet, STATUS_NONE } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -82,7 +82,7 @@ function ownerInSnapshotScope(e) {
 
 function setSnapshotCapture(e) {
     snapshotCaptureActive = e;
-    if (e && !snapshotSources) snapshotSources = new Set;
+    if (e && !snapshotSources) snapshotSources = new NewSet;
 }
 
 function markSnapshotScope(e) {
@@ -243,14 +243,14 @@ function recompute(e, t = false) {
     // value, leaving blocked dependents outside that source’s settle walk.
         const u = e.m & STATUS_ERROR ? e.T?.F : undefined;
     const a = (e.m & STATUS_PENDING) !== 0;
-    const _ = a ? e.T?.fe : undefined;
+    const _ = a ? e.T?.se : undefined;
     // Pending SOURCE-hood, captured before the compute clears status: a node
     // whose own flight parked dependents self-registers in _pendingSources
     // (notifyStatus, isSource). If this recompute supersedes that flight and
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const I = e.T?.fe?.has(e);
+        const I = e.T?.se?.has(e);
     // D-41: this pass's error is staged, not published (`stageError`).
         let N = false;
     // A19 exc. 2: a `refresh()` re-asks the question already answered — quiet
@@ -275,7 +275,7 @@ function recompute(e, t = false) {
     // L2: did this pass read the future (REACTIVE_JOINED, set by read) — or,
     // a lane's mount, a staging of this flush (#3851, #4166)?
         let R = false;
-    let d = tracking;
+    let C = tracking;
     tracking = true;
     try {
         if (!false && e.l & CONFIG_SYNC) {
@@ -319,7 +319,7 @@ function recompute(e, t = false) {
             // D-41: a pass of a held node, or one that read a staging of this
             // flush, stages its error (`stageError`).
             if (n || !(N = stageError(e, t, true))) {
-                if (n) ext(e).se = true;
+                if (n) ext(e).fe = true;
                 notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t);
                 // The replacement source is fully propagated now. If no new flight
                 // re-owned self, retire the superseded flight and its dependent copies.
@@ -334,10 +334,10 @@ function recompute(e, t = false) {
             // re-park twin of the unchanged-value recovery sweep below; dependents
             // with another path keep the source (retryReaches). A staged error
             // answered what the pass carried: the same.
-                        if ((n || N) && _) for (const t of _) if (t !== e && !e.T?.fe?.has(t)) settlePendingSource(e, t);
+                        if ((n || N) && _) for (const t of _) if (t !== e && !e.T?.se?.has(t)) settlePendingSource(e, t);
         }
     } finally {
-        tracking = d;
+        tracking = C;
         if (laneStageHook) laneRoot = E;
         // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
         // landed beneath this pass on a link it had already validated. The wipe
@@ -391,12 +391,12 @@ function recompute(e, t = false) {
     // seat that read none of the lane's world has left it: its result is the
     // frame's (a derivation whose branch no longer reaches the guess). A
     // guess is written, not derived — it never leaves this way.
-        let C = !laneStageHook ? null : passLane;
+        let d = !laneStageHook ? null : passLane;
     // Listed before its staging, a pending pass included (the lane's own
     // flight is the lane's); false: the pass left the lane (lanes.ts).
         const O = !!e.T?.F || N;
-    if (laneStageHook && C !== null) {
-        if (laneStageHook(e, C, t, O)) setPassLane(C); else C = null;
+    if (laneStageHook && d !== null) {
+        if (laneStageHook(e, d, t, O)) setPassLane(d); else d = null;
     }
     if (!O) {
         // Observe-tier fan-in (HUGE_FAN_IN): the validated prefix [_deps.._depsTail]
@@ -445,7 +445,7 @@ function recompute(e, t = false) {
             // Lane work's run is the lane's (released at its reveal) — a first
             // pass under a lane too: `effect()` skips the synchronous first run of
             // a lane's node.
-                        if (!t || C !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.K.bind(null, e), C);
+                        if (!t || d !== null) globalQueue.enqueue(n, e.W ??= GlobalQueue.K.bind(null, e), d);
         }
         // Lanes. A written guess's own pass from the frame: its source
         // recomputed it — the truth (A18: "the source is whatever recomputes the
@@ -453,7 +453,7 @@ function recompute(e, t = false) {
         // confirm is a landing too — the lane's end commits it) and notifies
         // only a correction: an equal truth re-runs nothing (lanes.ts). (As the
         // lane's own work the lane judged it — `laneStage`.)
-                if (!t && C === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, S, O)) ; else if (O) ; else if (s) {
+                if (!t && d === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, S, O)) ; else if (O) ; else if (s) {
             // L2: a first pass is born held — staged, committed with the
             // transaction, its effect's first run the landing's (A29; `effect()`
             // skips the synchronous first run on a staged value) — when the flush
@@ -470,14 +470,14 @@ function recompute(e, t = false) {
             // pass that runs before anything joins: the pass's input, not a verdict
             // after it. An effect still carrying an uncommitted staged value
             // re-stages: the commit applies the latest pass, not the born-held one.
-            if (C !== null) {
+            if (d !== null) {
                 // Lane work: the lane's value — into the slot while the lane has not
                 // revealed (its reveal shows it), as its staging once it has (the
                 // next reveal promotes it; the screen keeps the revealed value). An
                 // effect's value slot is private: the run the lane holds is what
                 // shows it — unless the effect was born held, whose first run is the
                 // commit's (A29): it re-stages, as below.
-                if (n && e.ue === NOT_PENDING) e.Ie = S; else if (n || C.It) e.ue = S; else e.T.V = S;
+                if (n && e.ue === NOT_PENDING) e.Ie = S; else if (n || d.It) e.ue = S; else e.T.V = S;
             } else if (t ? !((flushTransaction !== null || passTx !== null) && (R || creatorPass(T)?.R & REACTIVE_JOINED)) : n && e.ue === NOT_PENDING) {
                 // A first pass publishes directly. So does an effect: its value slot
                 // is private (only its own run reads it), and the staging round-trip
@@ -517,7 +517,7 @@ function recompute(e, t = false) {
                         if (e.o !== null) {
                 insertSubs(e);
                 // Lane work re-staged: the lane's members re-derive as its work.
-                                if (C !== null) laneDirty(e, C);
+                                if (d !== null) laneDirty(e, d);
             }
         } else if (e.Et != c) {
             for (let t = e.o; t !== null; t = t.t) insertIntoHeapHeight(t.u, dirtyQueue);
@@ -546,7 +546,7 @@ function recompute(e, t = false) {
     // hold's commit (D-12) — but the hold does not wait for it: its only
     // readers are behind the fallback (`_hidden`; F-4, #3540). A boundary
     // re-armed by `on` owns what it collects outright (D-14): not held.
-        if (t && C === null && R && e.m & STATUS_PENDING) {
+        if (t && d === null && R && e.m & STATUS_PENDING) {
         const t = flushTransaction ?? passTx;
         if (t && !t.V && freshHook?.(e) !== CAUGHT_REARMED) holdNode(e, t);
     }
@@ -572,7 +572,7 @@ function recompute(e, t = false) {
     }
     // Observe: the posture the run executed under — lane work (optimistic:
     // overlay, never waste), a transaction's pass (held), or plain.
-        if (attrHooks !== null) attrHooks.recomputeEnd(e, t, i, C !== null, flushTransaction !== null || passTx !== null || (e.l & CONFIG_HELD) !== 0, e.ue !== NOT_PENDING);
+        if (attrHooks !== null) attrHooks.recomputeEnd(e, t, i, d !== null, flushTransaction !== null || passTx !== null || (e.l & CONFIG_HELD) !== 0, e.ue !== NOT_PENDING);
     // A staged value, a parked frame (L2: the commit retires it), or status the
     // commit sweep must settle (a pending or uninitialized pass), queues the
     // node for this flush's commit. A first pass queues only when pending or
@@ -581,7 +581,7 @@ function recompute(e, t = false) {
         if (e.ue !== NOT_PENDING || e.T !== null && (e.T.Nt !== null || e.T.ft !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
         e.l |= CONFIG_STAGED;
         // Lane work is the lane's to reveal (its seam), not this flush's commit.
-                if (C === null) queuePendingNode(e);
+                if (d === null) queuePendingNode(e);
     }
     setPassLane(s);
     // Missed-wake reschedule (see the finally above): values this pass read
@@ -661,10 +661,10 @@ function computed(e, t) {
         _: null,
         Ne: 0,
         o: null,
-        dt: null,
+        Ct: null,
         _parent: context,
         Xe: null,
-        Ct: null,
+        dt: null,
         ze: null,
         R: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         m: o ? 0 : STATUS_UNINITIALIZED,
@@ -694,8 +694,8 @@ function computed(e, t) {
         Se: null,
         ae: null,
         F: undefined,
-        se: undefined,
         fe: undefined,
+        se: undefined,
         Dt: undefined,
         lt: undefined,
         Nt: null,
@@ -838,10 +838,10 @@ function computed(e, t) {
         _: null,
         Ne: 0,
         o: null,
-        dt: null,
+        Ct: null,
         _parent: context,
         Xe: null,
-        Ct: null,
+        dt: null,
         ze: null,
         R: REACTIVE_LAZY,
         m: STATUS_UNINITIALIZED,
@@ -886,7 +886,7 @@ function setEffectStatusNotify(e) {
  * 0, and only effect literals carry the field) get the shared notifier.
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */ function statusNotifierOf(e) {
-    return e.i ? effectStatusNotify ?? undefined : undefined;
+    return e.i ? effectStatusNotify : null;
 }
 
 const lazyOptions = {
@@ -919,7 +919,7 @@ function signal(e, t) {
         l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.le ? CONFIG_NO_SNAPSHOT : 0),
         Ie: e,
         o: null,
-        dt: null,
+        Ct: null,
         ie: clock,
         ue: NOT_PENDING,
         Ot: -1,
@@ -957,7 +957,7 @@ function isEqual(e, t) {
         l: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
         Ie: e,
         o: null,
-        dt: null,
+        Ct: null,
         ie: clock,
         ue: NOT_PENDING,
         Ot: -1,

package/dist/observe/core/effect.js

@@ -18,45 +18,48 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, e, o, u) {
-    const E = !!u?.user;
-    const r = createEffectNode(t, e, o, E ? EFFECT_USER : EFFECT_RENDER, u);
-    recompute(r, true);
+ */ function effect(t, e, o, r) {
+    const u = !!r?.user;
+    const E = createEffectNode(t, e, o, u ? EFFECT_USER : EFFECT_RENDER, r);
+    recompute(E, true);
     // A first pass that read a staged value was staged itself (recompute: born
     // staged); the flush's commit replays this effect. Its first run is not this
     // creation's (A29). A lane's node likewise: its run is the lane's, queued
     // by the pass and released at the reveal (lanes.ts).
-        !u?.defer && r.ue === NOT_PENDING && !r.T?.Je?.V && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !r?.defer && E.ue === NOT_PENDING && !E.T?.Je?.V && (E.i === EFFECT_USER || r?.schedule ? globalQueue.enqueue(E.i, runEffect.bind(null, E)) : runEffect(E, E.i));
 }
 
-function notifyEffectStatus(t, e) {
-    // Use passed values if provided, otherwise read from node
-    const o = t !== undefined ? t : this.m;
-    const u = e !== undefined ? e : this.T?.F;
-    if (o & STATUS_ERROR) {
+function notifyEffectStatus() {
+    const t = this.m;
+    const e = this.T?.F;
+    if (t & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
             // and the runner dispatches on them, so a recovery before the effect
-            // phase takes the success arm instead. Blocked forwards (explicit
-            // `status` arg without node-state writes) don't queue: the status
-            // re-propagates unblocked at commit.
+            // phase takes the success arm instead. (Re-read: the boundary
+            // notify above can run a redraw.)
             if (this.m & STATUS_ERROR) {
                 this.Qe = true;
                 globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            // Dev locates the halt at the node that threw: the StatusError's
-            // source, upstream of this effect when a computed failed.
-            haltReactivity(unwrapStatusError(u));
-            throw u;
-        }
+        // Dev locates the halt at the node that threw: the StatusError's
+        // source, upstream of this effect when a computed failed.
+                escalate(this, unwrapStatusError(e), e, this);
     } else if (this.i === EFFECT_RENDER) {
-        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, o, u);
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, t, e);
+    }
+}
+
+/** An effect's error no boundary takes halts the system (boundary-or-halt):
+ * halted with `cause`, `thrown` rethrown; dev locates it at `subject`. */ function escalate(t, e, o = e, r = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw o;
     }
 }
 
@@ -92,10 +95,7 @@ function runEffect(t, e) {
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(e);
-                throw e;
-            }
+            escalate(t, e);
         }
         return;
     }
@@ -107,10 +107,10 @@ function runEffect(t, e) {
     // cascade an observer reports) and what times the callback (the `effect`
     // record) — facts a production observer needs, not only a dev console.
         if (attrHooks !== null) attrHooks.effectRunStart(t);
-    const u = t.kt;
+    const r = t.kt;
     t.kt = undefined;
     try {
-        u?.();
+        r?.();
         const e = t.Ge(t.Ie, t._t);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
@@ -118,10 +118,7 @@ function runEffect(t, e) {
     } catch (e) {
         ext(t).F = new StatusError(t, e);
         t.m |= STATUS_ERROR;
-        if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(e);
-            throw e;
-        }
+        escalate(t, e);
     } finally {
         t._t = t.Ie;
         t.Qe = false;
@@ -159,8 +156,8 @@ GlobalQueue.K = runEffect;
         const e = o.kt;
         o.kt = undefined;
         e?.();
-        const u = staleValues(t);
-        o.kt = u;
+        const r = staleValues(t);
+        o.kt = r;
     }, {
         ...e,
         lazy: true

package/dist/observe/core/graph.js

@@ -1,4 +1,4 @@
-import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
+import { NewSet, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
 
 import { deleteFromHeap } from "./heap.js";
 
@@ -21,7 +21,7 @@ function unlinkSubs(e) {
     const l = e.G;
     const o = e.t;
     const s = e.en;
-    if (o !== null) o.en = s; else n.dt = s;
+    if (o !== null) o.en = s; else n.Ct = s;
     if (s !== null) s.t = o; else {
         n.o = o;
         if (o === null) {
@@ -107,7 +107,7 @@ function unobserved(e) {
  * stays alive and serves its cache, uniform with observed memos) while
  * reclamation still happens within one microtask — the enqueue site arms
  * schedule(), so a flush is guaranteed even when no other work is queued.
- */ const dormantNodes = new Set;
+ */ const dormantNodes = new NewSet;
 
 function sweepDormant() {
     if (dormantNodes.size === 0) return;
@@ -143,9 +143,9 @@ function link(e, n) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const r = e.dt;
+        const r = e.Ct;
     if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
-    const t = n._ = e.dt = {
+    const t = n._ = e.Ct = {
         S: e,
         u: n,
         G: o,

package/dist/observe/core/owner.js

@@ -107,7 +107,7 @@ function disposeChildren(e, n = false, r) {
         // on the fresh head and survives. Pointing each drained child's prev at
         // itself routes its later splice onto the detached chain, never the head,
         // and keeps the dev owner-chain-head invariant honest for those children.
-                l.Ct = l;
+                l.dt = l;
         disposeChildren(l, true);
         // Read after, not before: a sibling this disposal made dormant spliced
         // itself out of the detached chain, and a cleanup may then have linked
@@ -122,11 +122,11 @@ function disposeChildren(e, n = false, r) {
     // node._nextSibling intact so outer walks that already advanced past us
     // still reach later siblings.
         if (n && !r && !(t & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
-        const n = e.Ct;
+        const n = e.dt;
         const r = e.Xe;
         if (n !== null) n.Xe = r; else e._parent.ze = r;
-        if (r !== null) r.Ct = n;
-        e.Ct = null;
+        if (r !== null) r.dt = n;
+        e.dt = null;
     }
     runDisposal(e, r);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
@@ -140,9 +140,9 @@ function disposeChildren(e, n = false, r) {
 
 function linkChild(e, n) {
     const r = e.ze;
-    n.Ct = null;
+    n.dt = null;
     n.Xe = r;
-    if (r !== null) r.Ct = n;
+    if (r !== null) r.dt = n;
     e.ze = n;
 }
 
@@ -311,7 +311,7 @@ function disposeRootSelf(e = true) {
         Ht: n?.Pt ? n.Ht : n,
         ze: null,
         Xe: null,
-        Ct: null,
+        dt: null,
         rt: null,
         A: n?.A || defaultContext,
         ct: 0,

package/dist/observe/core/scheduler.js

@@ -291,7 +291,7 @@ let judge = null;
 /** A source the pending node waits on that is `t`'s (held by it, or by no
  * one) — not another transaction's or lane's work. Itself, when it is the
  * source. */ function ownSource(e, o) {
-    const n = e.T?.fe;
+    const n = e.T?.se;
     if (n === undefined) return true;
     for (const e of n) {
         const n = e.T?.Je;
@@ -819,31 +819,34 @@ 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 o = 0; o < e.En.length; o++) {
-        const n = e.En[o];
+ * it. Truthy when an effect re-derives (`land`). */ function reruns(e) {
+    let o;
+    for (let n = 0; n < e.En.length; n++) {
+        const t = e.En[n];
         // 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 (n.R & REACTIVE_DISPOSED || n.m & STATUS_ERROR) continue;
-        if (n.R & REACTIVE_FRAME_READ || n.l & CONFIG_VERDICT) {
-            n.R &= ~REACTIVE_FRAME_READ;
-            n.Qe = false;
+                if (t.R & REACTIVE_DISPOSED || t.m & STATUS_ERROR) continue;
+        if (t.R & REACTIVE_FRAME_READ || t.l & CONFIG_VERDICT) {
+            o ||= t.i;
+            t.R &= ~REACTIVE_FRAME_READ;
+            t.Qe = 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 = n.ze; e !== null; e = e.Xe) if (e.i) e.Qe = false;
-            enqueueSub(n);
+                        for (let e = t.ze; e !== null; e = e.Xe) if (e.i) e.Qe = false;
+            enqueueSub(t);
         }
     }
     e.En.length = 0;
+    return o;
 }
 
 /** The landing: the held frame becomes the frame. */ function land(e) {
     // Attribution hook: judged complete — its held writes commit next
     // (`_nodes` still lists them).
     if (attrHooks !== null) attrHooks.transitionSettled(e);
-    reruns(e);
+    const o = 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
@@ -858,7 +861,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 (o) globalQueue.un[1].push(() => releaseQueues(e)); else releaseQueues(e);
 }
 
 /** The held runs join this flush's effect phase after its own runs (the

package/dist/observe/core/verdict.js

@@ -139,8 +139,8 @@ let probeFound = false;
  * when every flight it waits on is. */ function quietPending(e) {
     const t = e.T;
     if (t === null) return false;
-    if (t.fe !== undefined) {
-        for (const e of t.fe) if (!e.T?.ut) return false;
+    if (t.se !== undefined) {
+        for (const e of t.se) if (!e.T?.ut) return false;
         return true;
     }
     return t.ut;

package/dist/observe/deferred.js

@@ -135,26 +135,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 = {
@@ -162,7 +162,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({
@@ -177,7 +180,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
             }
         }
         land(o);
-        return c;
+        return s;
     }, r));
 }