@solidjs/signals 2.0.0-rc.16 → 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/context.js

@@ -33,6 +33,8 @@ import { getOwner } from "./owner.js";
         let r = t.A[e.id];
     if (r === undefined) r = e.defaultValue;
     if (r === undefined) {
+        // Dev names the context and why it has no value: no provider, or a
+        // provider that passed `undefined` (the key is set, to `undefined`).
         throw new ContextNotFoundError;
     }
     return r;

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";
 
@@ -10,7 +10,7 @@ import { insertIntoHeap, deleteFromHeap, insertIntoHeapHeight, enqueueSub, markN
 
 import { inheritId, linkChild, disposeChildren, markDisposal } from "./owner.js";
 
-import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneReadHook, laneStageHook, passLane, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, deferZombie } from "./scheduler.js";
+import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneStageHook, passLane, laneReadHook, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, deferZombie } from "./scheduler.js";
 
 // The heap's per-node step. A tracked effect's heap visit is its compute
 // phase — empty, like a user effect whose compute reads nothing — and hands
@@ -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;
             }
         }
@@ -210,7 +210,9 @@ function recompute(e, t = false) {
         // and own nothing to park.
                 if (n === EFFECT_TRACKED || e.l & CONFIG_STAGED) {
             // A lazy node only those children read is released when this pass
-            // ends, if the pass doesn't read it again (#4142).
+            // ends, if the pass doesn't read it again (#4142). A cleanup or
+            // `unobserved` hook that throws here neither stops the pass nor skips
+            // that drain: its error is rethrown when the flush ends (owner.ts).
             const t = deferredReleases;
             deferReleases(o = []);
             disposeChildren(e);
@@ -219,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;
         }
     }
@@ -255,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,
@@ -305,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.
@@ -331,7 +333,10 @@ function recompute(e, t = false) {
         // (markNode(c) in read()) marks the running node as part of ordinary
         // bookkeeping, and those marks are correctly discarded here.
                 c = (e.R & REACTIVE_MISSED_WAKE) !== 0;
-        A = !!(e.R & (i ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
+        // A mount's staged read joins it — except a nested derivation left
+        // pending: no render effect reaches it yet, so it holds nothing and
+        // reaches no boundary (Reader, #4203). A reader that does is caught.
+                A = !!(e.R & (i && (E || n || !(e.m & STATUS_PENDING)) ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
         // A verdict reader is one for as long as it probes, or reads a memo
         // that does (`read`): a pass that did neither (REACTIVE_PROBED, the same
         // bit) is an ordinary derivation again.
@@ -385,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
@@ -398,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.
@@ -437,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
@@ -451,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.
@@ -527,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
@@ -535,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);
@@ -624,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
@@ -645,7 +650,7 @@ function computed(e, t) {
         Se: null,
         ae: null,
         F: undefined,
-        ue: undefined,
+        se: undefined,
         fe: undefined,
         we: undefined,
         Pe: undefined,
@@ -653,8 +658,8 @@ function computed(e, t) {
         me: null,
         Re: null,
         Ve: false,
-        Be: NOT_PENDING,
-        Qe: -1,
+        je: NOT_PENDING,
+        Be: -1,
         Ee: 0,
         v: NOT_PENDING,
         I: 0,
@@ -682,6 +687,12 @@ function computed(e, t) {
         if (t.m & STATUS_UNINITIALIZED || e.i !== EFFECT_RENDER) joinPassTx(txOf(t), !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
 }
 
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */ function joinPassAt(e, t) {
+    e.R |= REACTIVE_JOINED;
+    joinPassTx(t, !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
+}
+
 /** A15's stale reader (shared-hole and reveal corollaries): a render effect
  * reading a node held by a transaction that is not the flush's. It is served
  * the committed value — a pending one's too — publishes mainline, and is
@@ -739,7 +750,7 @@ function computed(e, t) {
 
 /** The computed whose pass a creation under `owner` belongs to (a root's is
  * its nearest computed ancestor's), or null outside every pass. */ function creatorPass(e) {
-    return e !== null && e.je ? e.Ye : e;
+    return e !== null && e.Qe ? e.Ye : e;
 }
 
 /** L2 — park the previous pass's frame for this node's commit: the children
@@ -791,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,
@@ -828,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 = {
@@ -837,7 +848,7 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.We = e;
-    const n = context?.je ? context.Ye : context;
+    const n = context?.Qe ? context.Ye : context;
     if (context) linkChild(context, e);
     if (n) e.Fe = n.Fe + 1;
     wireExternalSourceHook?.(e);
@@ -863,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-
@@ -903,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,
@@ -1033,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;
@@ -1054,11 +1065,11 @@ 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.
-        if (e.l & CONFIG_HELD) return e.T.Qe === clock ? e.T.Be : NOT_PENDING;
+        if (e.l & CONFIG_HELD) return e.T.Be === clock ? e.T.je : NOT_PENDING;
     return e.Ie;
 }
 
@@ -1066,9 +1077,9 @@ function markUnflushedStaged() {
  * flush left (`_flushed`) until the flush that carries the rewrite — the
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
     const t = e.T;
-    if (t.Qe !== clock) {
-        t.Be = e.se;
-        t.Qe = clock;
+    if (t.Be !== clock) {
+        t.je = e.ue;
+        t.Be = clock;
         unflushedStaged = true;
     }
 }
@@ -1115,7 +1126,7 @@ function resyncUnflushedCompanions() {
 
 function read(e) {
     let t = context;
-    if (t?.je) t = t.Ye;
+    if (t?.Qe) t = t.Ye;
     const n = e;
     // CARVE 1: `owner` was `el._firewall || el` — a store leaf's status,
     // height and error were read off its projection computed. (Typed loosely
@@ -1126,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) {
@@ -1147,11 +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.)
-                if (observeFlightHook && t.l & CONFIG_VERDICT && stagedScreen(t)) return e.Ie;
+        // 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).
@@ -1237,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;
         }
@@ -1274,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);
@@ -1284,13 +1297,16 @@ 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
  * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
- * lane sees the screen plus its own guesses): the staging is the screen if
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
  * the frame commits — one pass, the common case — and a held write if it
  * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
  * the committed world and its lane's runs wait that round, so the held
@@ -1377,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
@@ -1404,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.
@@ -1466,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;
 }
 
@@ -1527,4 +1543,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };
+export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, joinPassAt, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };

package/dist/prod/core/effect.js

@@ -15,42 +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)) {
-            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;
     }
 }
 
@@ -86,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;
     }
@@ -107,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,8 +1,8 @@
-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";
 
-import { disposeChildren } from "./owner.js";
+import { disposeChildren, runCleanup } from "./owner.js";
 
 import { bumpNotifyEpoch, dirtyQueue } from "./scheduler.js";
 
@@ -27,7 +27,9 @@ function unlinkSubs(e) {
         if (o === null) {
             // Store slot nodes dispatch to the ONE shared hook — no per-node
             // unobserved closure, no NodeExtension to hold it.
-            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.T?.we?.();
+            // A user hook that throws is collected like a cleanup (owner.ts): the
+            // unlink and the teardown around it carry on.
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.we) runCleanup(n.T.we);
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work is an observer —
             // tearing down would orphan the work and re-execute it on the next
@@ -105,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;
@@ -141,18 +143,18 @@ 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 t = e.ve;
-    if (t !== null && t.u === n && (!s || t.Te === n.Ne)) return;
-    const r = n._ = e.ve = {
+        const r = e.ve;
+    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    const t = n._ = e.ve = {
         S: e,
         u: n,
         G: o,
-        Xe: t,
+        Xe: r,
         t: null,
         Te: n.Ne
     };
-    if (l !== null) l.G = r; else n.C = r;
-    if (t !== null) t.t = r; else e.o = r;
+    if (l !== null) l.G = t; else n.C = t;
+    if (r !== null) r.t = t; else e.o = t;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }

package/dist/prod/core/heap.js

@@ -16,7 +16,7 @@ import { dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.je ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
+    const E = (e._parent?.Qe ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
     if (E >= e.Fe) e.Fe = E + 1;
     const n = e.Fe;
     const I = t.$e[n];