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

package/dist/prod/core/constants.js

@@ -228,4 +228,6 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CAUGHT_REARMED, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };
+const NewSet = Set;
+
+export { $REFRESH, CAUGHT_REARMED, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, NewSet, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };

package/dist/prod/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_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_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";
 
@@ -78,7 +78,7 @@ function ownerInSnapshotScope(e) {
 
 function setSnapshotCapture(e) {
     snapshotCaptureActive = e;
-    if (e && !snapshotSources) snapshotSources = new Set;
+    if (e && !snapshotSources) snapshotSources = new NewSet;
 }
 
 function markSnapshotScope(e) {
@@ -199,7 +199,7 @@ function recompute(e, t = false) {
                 // after the new frame's first runs, and the held pass's own
                 // children die below (`disposeChildren`). The landing re-derives a
                 // fresh held frame for the reveal (`_reruns`).
-                e.se = NOT_PENDING;
+                e.ue = NOT_PENDING;
                 if (n === EFFECT_RENDER) e.l &= ~CONFIG_HELD;
             }
         }
@@ -221,7 +221,7 @@ function recompute(e, t = false) {
         // An error a pass staged (D-41) is replaced by this pass's answer: a
         // value, a flight, or an error of its own (#4109, #4145).
                 if (e.l & CONFIG_STAGED_ERROR) {
-            e.se = NOT_PENDING;
+            e.ue = NOT_PENDING;
             e.l ^= CONFIG_STAGED_ERROR;
         }
     }
@@ -257,7 +257,7 @@ function recompute(e, t = false) {
     e.ie = clock;
     // The pass's previous value: its staging, else a lane node's lane value
     // when it has one (lanes.ts), else the committed one.
-        let T = e.se !== NOT_PENDING ? e.se : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
+        let T = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
     let S = e.Fe;
     let c = false;
     // L2: did this pass read the future (REACTIVE_JOINED, set by read) — or,
@@ -307,7 +307,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 || !(I = stageError(e, t, true))) {
-                if (n) ext(e).ue = true;
+                if (n) ext(e).se = 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.
@@ -390,7 +390,7 @@ function recompute(e, t = false) {
         // publishes to — the staged `_pendingValue` when staged; a lane node's
         // lane value (a node entering the lane this pass has none yet — its
         // committed value, `laneStage` having voided a frame staging).
-        const o = e.se !== NOT_PENDING ? e.se : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
+        const o = e.ue !== NOT_PENDING ? e.ue : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
         // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
                 const E = !n && l || !!e.T?.de || !isSame(e, o, T);
         // Effects use `_equals: false` (no per-effect closure). The side effects that
@@ -403,7 +403,7 @@ function recompute(e, t = false) {
         // last applied owes no run (lanes.ts).
         !(e.R & REACTIVE_SCREEN_READ && !e.Ae && Object.is(e.ge, T)) && 
         // A re-staging pass owes no run: the commit replays the effect (#3802).
-        e.se === NOT_PENDING) {
+        e.ue === NOT_PENDING) {
             e.Ae = !e.T?.F;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
@@ -442,8 +442,8 @@ function recompute(e, t = false) {
                 // 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.se === NOT_PENDING) e.Ie = T; else if (n || C.ke) e.se = T; else e.T.v = T;
-            } else if (t ? !((flushTransaction !== null || passTx !== null) && (A || creatorPass(f)?.R & REACTIVE_JOINED)) : n && e.se === NOT_PENDING) {
+                if (n && e.ue === NOT_PENDING) e.Ie = T; else if (n || C.ke) e.ue = T; else e.T.v = T;
+            } else if (t ? !((flushTransaction !== null || passTx !== null) && (A || creatorPass(f)?.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
                 // (queuePendingNode + commitPendingNodes) paid per effect on the
@@ -456,7 +456,7 @@ function recompute(e, t = false) {
                 // that separation; it cannot be skipped on any path a pull can reach.
                 e.Ie = T;
             } else {
-                e.se = T;
+                e.ue = T;
                 // Born held: in the transaction from birth, so a read of it this
                 // tick is a read of its world (the mount-during-a-hold case), not
                 // only after the seam parks it.
@@ -532,7 +532,7 @@ function recompute(e, t = false) {
     // kept at a park — one spurious recompute at most). A creation pass and a
     // tracked effect trim now: their frames are replaceable like a direct
     // commit, and a tracked effect's spurious run would be user-visible.
-        if (!e.T?.F && e.se === NOT_PENDING && !(n && e.Ae)) {
+        if (!e.T?.F && e.ue === NOT_PENDING && !(n && e.Ae)) {
         if (t || n === EFFECT_TRACKED) trimStaleDeps(e); else heldTrim(e);
     }
     // A staged value, a parked frame (L2: the commit retires it), or status the
@@ -540,7 +540,7 @@ function recompute(e, t = false) {
     // node for this flush's commit. A first pass queues only when pending or
     // born held: otherwise its value published directly. A queued pass's
     // children are uncommitted (CONFIG_STAGED) until that commit.
-        if (e.se !== NOT_PENDING || e.T !== null && (e.T.Ue !== null || e.T.me !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
+        if (e.ue !== NOT_PENDING || e.T !== null && (e.T.Ue !== null || e.T.me !== 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);
@@ -629,7 +629,7 @@ function computed(e, t) {
         // A loadingValue node is born committed: commit #0 is already in _value.
         m: o ? 0 : STATUS_UNINITIALIZED,
         ie: clock,
-        se: NOT_PENDING,
+        ue: NOT_PENDING,
         Me: -1,
         ce: o,
         // Cold machinery (async slots) lives one hop away in the lazily-allocated extension — the core literal MUST
@@ -650,7 +650,7 @@ function computed(e, t) {
         Se: null,
         ae: null,
         F: undefined,
-        ue: undefined,
+        se: undefined,
         fe: undefined,
         we: undefined,
         Pe: undefined,
@@ -802,7 +802,7 @@ function computed(e, t) {
         R: REACTIVE_LAZY,
         m: STATUS_UNINITIALIZED,
         ie: clock,
-        se: NOT_PENDING,
+        ue: NOT_PENDING,
         Me: -1,
         ce: false,
         Ae: false,
@@ -839,7 +839,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 = {
@@ -874,7 +874,7 @@ function signal(e, t) {
         o: null,
         ve: null,
         ie: clock,
-        se: NOT_PENDING,
+        ue: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
@@ -914,7 +914,7 @@ function isEqual(e, t) {
         o: null,
         ve: null,
         ie: clock,
-        se: NOT_PENDING,
+        ue: NOT_PENDING,
         Me: -1,
         T: null,
         O: n,
@@ -1044,7 +1044,7 @@ function setVerdict(e) {
  *   never the graph — A32).
  * False means the reader derives from the staged value.
  */ function readerSeesCommitted(e, t) {
-    return !t || e.se === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
+    return !t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
 }
 
 /** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
@@ -1065,7 +1065,7 @@ function markUnflushedStaged() {
  * is unflushed. Exempt: promoted writes (A28 (4): a write issued inside a
  * recompute is promoted at that recompute's end — boundary and loading
  * machinery, signals declared for in-computation writes). */ function unflushedValue(e) {
-    if (globalQueue.q || e.se === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
+    if (globalQueue.q || e.ue === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
     // A held node (L2) carries a staged value between flushes too, but it was
     // flushed — and parked. Not an unflushed write — unless rewritten since:
     // then the flushed staging is what the world sees until the next flush.
@@ -1078,7 +1078,7 @@ function markUnflushedStaged() {
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
     const t = e.T;
     if (t.Be !== clock) {
-        t.je = e.se;
+        t.je = e.ue;
         t.Be = clock;
         unflushedStaged = true;
     }
@@ -1137,7 +1137,7 @@ function read(e) {
     // The verdict windows (`latest`, `isPending`; verdict.ts): one cold path,
     // off this one, present only while a window is open.
         if (verdict !== null) return verdict(e, t);
-    if (!n.X && e.T?.Pe === undefined && !snapshotCaptureActive && (!unflushedStaged || e.se === NOT_PENDING) && // A28, see readNodeFast
+    if (!n.X && e.T?.Pe === undefined && !snapshotCaptureActive && (!unflushedStaged || e.ue === NOT_PENDING) && // A28, see readNodeFast
     !(e.l & CONFIG_OVERRIDE) && // lanes: the slow path's one arm
     true) {
         if (t) {
@@ -1158,13 +1158,13 @@ function read(e) {
             }
         }
         // Committed visibility for untracked and children-forbidden readers.
-                if (!t || e.se === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.Ie;
+                if (!t || e.ue === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.Ie;
         // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
         // Lane work over a folded lane (D-34), once the frame has a
         // transaction, reads the screen too.
                 if ((observeFlightHook && t.l & CONFIG_VERDICT || laneStageHook && passLane?.folded) && stagedScreen(t)) return e.Ie;
         stagedRead(t);
-        return e.se;
+        return e.ue;
     }
     // Rule 3: this read serves the committed value to a render effect outside a
     // parking flush (decided after the pull below — a pull can join).
@@ -1250,7 +1250,7 @@ function read(e) {
         const n = e.T?.Pe;
         if (n !== undefined) {
             const o = n === NO_SNAPSHOT ? undefined : n;
-            const E = e.se !== NOT_PENDING ? e.se : e.Ie;
+            const E = e.ue !== NOT_PENDING ? e.ue : e.Ie;
             if (E !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
             return o;
         }
@@ -1287,7 +1287,7 @@ function read(e) {
     // an untracked reader has nothing to serve and holds (A19 exception 1) — a
     // bookkeeping read (`spectate`) likewise, and a children-forbidden reader
     // (A32: the frame, which has nothing here).
-    if (e.se !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
+    if (e.ue !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
     const n = t && unflushedStaged ? unflushedValue(e) : NOT_PENDING;
     if (n !== NOT_PENDING) {
         markLateLinker(t);
@@ -1297,8 +1297,8 @@ function read(e) {
     if (observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.Ie;
     stagedRead(t, e);
     // D-41: the staged answer is an error (`stageError`).
-        if (e.l & CONFIG_STAGED_ERROR) throw e.se;
-    return e.se;
+        if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
+    return e.ue;
 }
 
 /** A pass read a staging of this flush: it derives from what the flush may
@@ -1393,7 +1393,7 @@ function read(e) {
 
 function setSignal(e, t) {
     if (writeHook !== null) writeHook(e);
-    const n = e.se === NOT_PENDING ? e.Ie : e.se;
+    const n = e.ue === NOT_PENDING ? e.Ie : e.ue;
     if (typeof t === "function") t = t(n);
     // Lanes: a write landing on a guess is its truth (A18 — an async guess's
     // own landing), judged against the guess; one landing on a lane's
@@ -1420,12 +1420,12 @@ function setSignal(e, t) {
     // pass reads a value the server never had. Store leaves written here are
     // plain signals and qualify the same way.
         if (snapshotCaptureActive) captureWriteSnapshot(e, n);
-    const E = e.se !== NOT_PENDING;
+    const E = e.ue !== NOT_PENDING;
     if (!E) queuePendingNode(e);
     // A28: a held node rewritten outside a flush keeps its flushed staging
     // for every reader until the flush that carries the rewrite.
      else if (e.l & CONFIG_HELD && !globalQueue.q) stashFlushed(e);
-    e.se = t;
+    e.ue = t;
     if (context !== null) notePromotedWrite(e);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
@@ -1482,7 +1482,7 @@ function setSignal(e, t) {
         e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(e, dirtyQueue);
         schedule();
-    } else if (e.se !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
+    } else if (e.ue !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
     return t;
 }
 

package/dist/prod/core/effect.js

@@ -15,44 +15,47 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */ function effect(t, e, E, u) {
-    const f = !!u?.user;
-    const r = createEffectNode(t, e, E, f ? EFFECT_USER : EFFECT_RENDER, u);
-    recompute(r, true);
+    const r = !!u?.user;
+    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, u);
+    recompute(f, 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.se === NOT_PENDING && !r.T?.Re?.v && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !u?.defer && f.ue === NOT_PENDING && !f.T?.Re?.v && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : runEffect(f, f.i));
 }
 
-function notifyEffectStatus(t, e) {
-    // Use passed values if provided, otherwise read from node
-    const E = t !== undefined ? t : this.m;
-    const u = e !== undefined ? e : this.T?.F;
-    if (E & 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.Ae = 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, E, 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, E = e, u = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw E;
     }
 }
 
@@ -88,10 +91,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;
     }
@@ -109,10 +109,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.ge = t.Ie;
         t.Ae = false;

package/dist/prod/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";
 
@@ -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;

package/dist/prod/core/lanes.js

@@ -119,7 +119,7 @@ function applyGuesses(e) {
             // value re-asked renews the question; nothing to notify.
             u = !t.xe || !t.xe(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.se = NOT_PENDING;
+                t.ue = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
             t.T.v = l;
@@ -264,7 +264,7 @@ function unlink(e) {
     }
     if (!e.i) {
         if (!(e.l & CONFIG_OVERRIDE)) {
-            e.se = NOT_PENDING;
+            e.ue = NOT_PENDING;
             e.l = e.l & -1048833 | CONFIG_OVERRIDE;
             ext(e);
         }
@@ -321,7 +321,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.sn?.(t);
     }
-    e.se = n;
+    e.ue = n;
     joinFuture(l);
 }
 
@@ -365,7 +365,7 @@ function supersede(e, n, s) {
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
             u.Re = null;
-            if (!i && !r) l.se = f;
+            if (!i && !r) l.ue = f;
             commitPendingNode(l);
             if (!i) {
                 if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.m & STATUS_PENDING) l.l |= CONFIG_INPUTS_PUBLISHED;
@@ -376,7 +376,7 @@ function supersede(e, n, s) {
             // else the value it covered — is the parent's to land, and its readers
             // re-derive from it there. What the screen showed stays the screen
             // until then (A18 (c)).
-            if (l.se === NOT_PENDING) l.se = covered(l);
+            if (l.ue === NOT_PENDING) l.ue = covered(l);
             if (e.ke) l.Ie = o;
             holdNode(l, n);
             insertSubs(l);
@@ -390,7 +390,7 @@ function supersede(e, n, s) {
             // it: an input's truth equal to its committed value is silent).
             u.Re = null;
             if (!i) {
-                if (E !== NOT_PENDING && e.ke) l.se = E;
+                if (E !== NOT_PENDING && e.ke) l.ue = E;
                 if (l.m & STATUS_PENDING) {
                     u.Se = null;
                     enqueueSub(l);
@@ -470,7 +470,7 @@ function supersede(e, n, s) {
             // joined its transaction) reads the answer it waited on — the lane's
             // staging, revealed at this seam.
             if (u & STATUS_PENDING && n.T.v === NOT_PENDING) return NOT_PENDING;
-            if (n.se !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.se;
+            if (n.ue !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ue;
         }
         if (t.ln || !s && u & STATUS_PENDING) {
             if (!s && !t.ke && u & STATUS_UNINITIALIZED) throw new NotReadyError(null);
@@ -529,7 +529,7 @@ function supersede(e, n, s) {
                 for (let e = 0; e < t.tn.length && lanes.indexOf(t) !== -1; e++) {
             const n = t.tn[e];
             if (n.l & CONFIG_GUESS && n.T.Re === t) {
-                const e = n.se !== NOT_PENDING ? n.se : covered(n);
+                const e = n.ue !== NOT_PENDING ? n.ue : covered(n);
                 supersede(n, e, !n.xe || !n.xe(n.T.v, e));
             }
         }
@@ -555,9 +555,9 @@ function laneSeam(e, n) {
         }
         const t = s.T;
         if (t.Re !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.se !== NOT_PENDING) {
-            t.v = s.se;
-            s.se = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ue !== NOT_PENDING) {
+            t.v = s.ue;
+            s.ue = NOT_PENDING;
         }
         // The frame this pass built is the screen's now; the one it replaced
         // goes (as `commitPendingNode` retires a committed pass's).
@@ -611,7 +611,7 @@ function laneSeam(e, n) {
         // folds a current one beneath it (D-34): true.
         const s = stale(e, question);
         if (GlobalQueue.an?.(e, n, s) || s) {
-            e.se = n;
+            e.ue = n;
             e.l |= CONFIG_HELD;
             schedule();
             return n;
@@ -620,7 +620,7 @@ function laneSeam(e, n) {
     } else {
         const s = txOf(e);
         if (e.xe && e.xe(laneValueOf(e), n)) return n;
-        if (s.ke) e.se = n; else e.T.v = n;
+        if (s.ke) e.ue = n; else e.T.v = n;
         if (e.X !== undefined) e.ie = clock;
         insertSubs(e);
         laneDirty(e, s);
@@ -643,7 +643,7 @@ function laneSeam(e, n) {
  * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, s) {
     if (s) return true;
     if (stale(e, answered(e))) {
-        e.se = n;
+        e.ue = n;
         e.l |= CONFIG_HELD;
         return true;
     }

package/dist/prod/core/scheduler.js

@@ -612,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;
                     }
@@ -796,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
@@ -832,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
@@ -935,16 +946,16 @@ 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 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;
@@ -954,13 +965,13 @@ function commitPendingNode(e) {
     // 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 (t) {
-        const o = e.se;
-        e.se = NOT_PENDING;
+        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

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;
 }