@solidjs/signals 2.0.0-rc.16 → 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";
 
@@ -14,7 +14,7 @@ import { attrHooks } from "./attribution-hooks.js";
 
 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
@@ -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) {
@@ -222,7 +222,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);
@@ -240,15 +242,15 @@ function recompute(e, t = false) {
     // A conditional can drop its pending source and recover to an unchanged
     // value, leaving blocked dependents outside that source’s settle walk.
         const u = e.m & STATUS_ERROR ? e.T?.F : undefined;
-    const _ = (e.m & STATUS_PENDING) !== 0;
-    const a = _ ? e.T?.fe : undefined;
+    const a = (e.m & STATUS_PENDING) !== 0;
+    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
@@ -273,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) {
@@ -317,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.
@@ -332,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) && a) for (const t of a) 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
@@ -343,7 +345,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.
                 A = (e.R & REACTIVE_MISSED_WAKE) !== 0;
-        R = !!(e.R & (l ? 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.
+                R = !!(e.R & (l && (s || 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.
@@ -386,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]
@@ -440,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
@@ -448,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
@@ -465,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
@@ -512,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);
@@ -526,7 +531,7 @@ function recompute(e, t = false) {
             if (u !== undefined) settleErroredDependents(e, u);
             // Self-registration (this node's own superseded flight) is the #3181
             // sweep's business below — retiring it here too would walk twice.
-                        if (a) for (const t of a) if (t !== e) settlePendingSource(e, t);
+                        if (_) for (const t of _) if (t !== e) settlePendingSource(e, t);
         }
         // #3181: a synchronous settle supersedes the old landing callback, so
         // recompute owns its pending-source sweep. An uninitialized node without
@@ -541,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);
     }
@@ -567,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
@@ -576,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
@@ -656,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,
@@ -689,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,
@@ -726,6 +731,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
@@ -827,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,
@@ -875,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 = {
@@ -908,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,
@@ -946,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,
@@ -1197,7 +1208,9 @@ function read(e) {
         // Committed visibility for untracked and children-forbidden readers.
                 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.ue;
     }
@@ -1338,7 +1351,10 @@ function read(e) {
 
 /** 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
@@ -1580,4 +1596,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/observe/core/effect.js

@@ -18,43 +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)) {
-            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;
     }
 }
 
@@ -90,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;
     }
@@ -105,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.
@@ -116,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;
@@ -157,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,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";
 
@@ -21,13 +21,15 @@ 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) {
             // 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?.Dt?.();
+            // 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?.Dt) runCleanup(n.T.Dt);
             // 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.dt;
-    if (t !== null && t.u === n && (!s || t.Te === n.Ne)) return;
-    const r = n._ = e.dt = {
+        const r = e.Ct;
+    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    const t = n._ = e.Ct = {
         S: e,
         u: n,
         G: o,
-        en: t,
+        en: 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/observe/core/lanes.js

@@ -461,12 +461,21 @@ function supersede(e, n, s) {
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
  * member throws like any. */ function laneRead(e, n) {
     const s = n.l & CONFIG_GUESS;
+    const t = txOf(n);
+    // A lane a correction folded under (D-34): store/optimistic.ts reads it.
+    // Before the authoritative arm: an `until` outside the lane reads the
+    // same truth there, and joins the hold it folded into — its posture over
+    // a foreign hold (D-31), which the truth read alone would not take.
+        const l = e !== null && t.folded;
+    if (l) {
+        const s = l(e, n);
+        if (s !== NOT_PENDING) return s;
+    }
     if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.rn(n);
-    const t = n.m;
+    const u = n.m;
     // An errored member's lane value predates its error; the error is the answer (#4106).
-        if (!s && t & STATUS_ERROR) return NOT_PENDING;
+        if (!s && u & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
-    const l = txOf(n);
     if (!tracking || e.l & CONFIG_CHILDREN_FORBIDDEN) {
         // An untracked read inside lane work derives from the lane like a
         // tracked one, minus the subscription — `untrack` is about
@@ -475,33 +484,33 @@ function supersede(e, n, s) {
         // lanes read by one pass link, as for tracked reads). Outside lane
         // work, the screen.
         if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(l, e);
-        if (!s && t & STATUS_PENDING) return NOT_PENDING;
+        enterLane(t, e);
+        if (!s && u & STATUS_PENDING) return NOT_PENDING;
         return laneValueOf(n);
     }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, l))) {
+    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, t))) {
         if (!s) {
             // A flight whose value has never shown: nothing to show — the leaf
             // waits on it, and its own frame holds (A15, #3334), not the lane's
             // parent. The landing lands the frame: its own pass (the flush
             // joined its transaction) reads the answer it waited on — the lane's
             // staging, revealed at this seam.
-            if (t & STATUS_PENDING && n.T.V === NOT_PENDING) return NOT_PENDING;
+            if (u & STATUS_PENDING && n.T.V === NOT_PENDING) return NOT_PENDING;
             if (n.ue !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ue;
         }
-        if (l.ln || !s && t & STATUS_PENDING) {
-            if (!s && !l.It && t & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (t.ln || !s && u & STATUS_PENDING) {
+            if (!s && !t.It && u & STATUS_UNINITIALIZED) throw new NotReadyError(null);
             // Re-derived at the reveal; once per pass (the pass may also be a stale
             // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
                         if (!(e.R & REACTIVE_SCREEN_READ)) {
                 e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
-                l.En.push(e);
+                t.En.push(e);
             }
             return display(n);
         }
     }
-    enterLane(l, e);
-    if (!s && t & STATUS_PENDING) return NOT_PENDING;
+    enterLane(t, e);
+    if (!s && u & STATUS_PENDING) return NOT_PENDING;
     return laneValueOf(n);
 }
 
@@ -626,10 +635,12 @@ function laneSeam(e, n) {
         // question is the one being asked (`question`: a slice's, a derive's
         // continuation's — the flight's); unstamped writes and mainline are
         // current.
-        if (stale(e, question)) {
+        // A store re-bases a keyed arrangement guess over an older truth, and
+        // folds a current one beneath it (D-34): true.
+        const s = stale(e, question);
+        if (GlobalQueue.an?.(e, n, s) || s) {
             e.ue = n;
             e.l |= CONFIG_HELD;
-            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }