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

package/dist/dev.attribution.js

@@ -1,24 +1,24 @@
 import {
-  bN as OBSERVE,
-  bY as setAttributionHooks,
-  bZ as liveRootOwners,
+  bP as OBSERVE,
+  b_ as setAttributionHooks,
+  b$ as liveRootOwners,
   N as NOT_PENDING,
   as as emitDiagnostic,
-  b_ as ownerPath,
+  c0 as ownerPath,
   aJ as reportDiagnostic,
-  b$ as isSuppressed,
-  c0 as blockersOf,
-  c1 as CONFIG_PLUMBING,
-  c2 as anyExcluded,
-  c3 as isExcluded,
-  c4 as CONFIG_WIDE,
+  c1 as isSuppressed,
+  c2 as blockersOf,
+  c3 as CONFIG_PLUMBING,
+  c4 as anyExcluded,
+  c5 as isExcluded,
+  c6 as CONFIG_WIDE,
   c as CONFIG_OVERRIDE,
   C as CONFIG_GUESS,
   G as GlobalQueue,
   f as CONFIG_VERDICT,
-  c5 as GRAPH_SIZE_WARN_AT,
-  c6 as noteFanOut,
-  c7 as CONFIG_SUPERSEDES,
+  c7 as GRAPH_SIZE_WARN_AT,
+  c8 as noteFanOut,
+  c9 as CONFIG_SUPERSEDES,
   b0 as $REFRESH
 } from "./dev-shared.js";
 

package/dist/dev.js

@@ -105,7 +105,7 @@ import {
   aN as EFFECT_TRACKED,
   aO as heldRunHook,
   aP as unwrapStatusError,
-  aQ as haltReactivity,
+  aQ as haltReactivityAt,
   aR as setStrictRead,
   aS as StatusError,
   aT as trimStaleDeps,
@@ -154,31 +154,33 @@ import {
   by as propagateStatus,
   bz as forEachDependent,
   bA as settlePendingSource,
-  bB as notifyEpoch,
-  bC as SUPPORTS_PROXY,
-  bD as releaseMarksHook,
-  bE as installMarkHooks,
-  bF as CONFIG_LAGS,
-  bG as REACTIVE_REASK,
-  bH as heldUnder,
-  bI as unhold,
-  bJ as laneStageHook,
-  bK as REACTIVE_ZOMBIE,
-  bL as installBoundaryHooks,
-  bM as CAUGHT_REARMED,
-  bN as OBSERVE$1
+  bB as joinPassAt,
+  bC as notifyEpoch,
+  bD as SUPPORTS_PROXY,
+  bE as releaseMarksHook,
+  bF as installMarkHooks,
+  bG as CONFIG_LAGS,
+  bH as REACTIVE_REASK,
+  bI as haltReactivity,
+  bJ as heldUnder,
+  bK as unhold,
+  bL as laneStageHook,
+  bM as REACTIVE_ZOMBIE,
+  bN as installBoundaryHooks,
+  bO as CAUGHT_REARMED,
+  bP as OBSERVE$1
 } from "./dev-shared.js";
 export {
-  bO as clearSnapshots,
-  bP as enforceLoadingBoundary,
-  bQ as getNextChildId,
-  bR as markSnapshotScope,
-  bS as peekNextChildId,
-  bT as releaseSnapshotScope,
-  bU as resetErrorHalt,
-  bV as setConsoleFooter,
-  bW as setSnapshotCapture,
-  bX as setWriteHook
+  bQ as clearSnapshots,
+  bR as enforceLoadingBoundary,
+  bS as getNextChildId,
+  bT as markSnapshotScope,
+  bU as peekNextChildId,
+  bV as releaseSnapshotScope,
+  bW as resetErrorHalt,
+  bX as setConsoleFooter,
+  bY as setSnapshotCapture,
+  bZ as setWriteHook
 } from "./dev-shared.js";
 
 // Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
@@ -696,12 +698,21 @@ function dissolveLane(l, into, except) {
  * member throws like any. */
 function laneRead(c, el) {
   const guess = el._config & CONFIG_GUESS;
+  const l = txOf(el);
+  // 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 folded = c !== null && l.folded;
+  if (folded) {
+    const v = folded(c, el);
+    if (v !== NOT_PENDING) return v;
+  }
   if (c !== null && c._config & CONFIG_AUTHORITATIVE) return GlobalQueue._truth(el);
   const status = el._statusFlags;
   // An errored member's lane value predates its error; the error is the answer (#4106).
   if (!guess && status & STATUS_ERROR) return NOT_PENDING;
   if (c === null) return laneValueOf(el);
-  const l = txOf(el);
   if (!tracking || c._config & CONFIG_CHILDREN_FORBIDDEN) {
     // An untracked read inside lane work derives from the lane like a
     // tracked one, minus the subscription — `untrack` is about
@@ -869,10 +880,12 @@ function laneWrite(el, v) {
     // 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(el, question)) {
+    // A store re-bases a keyed arrangement guess over an older truth, and
+    // folds a current one beneath it (D-34): true.
+    const older = stale(el, question);
+    if (GlobalQueue._laneRebase?.(el, v, older) || older) {
       el._pendingValue = v;
       el._config |= CONFIG_HELD;
-      GlobalQueue._laneRebase?.(el, v);
       schedule();
       return v;
     }
@@ -1325,6 +1338,9 @@ function verdictValue(el, c) {
             (!el._equals || !el._equals(el._x._lane, el._pendingValue))))
       )
         probeFound = true;
+      // A lane a correction folded under (D-34): `latest()` shows the hold's
+      // world whole — the truth beneath each guess, else what it covered.
+      if (latestActive && l.folded) return l.folded(null, el);
       return el._x._lane;
     }
     if (probing && flying) probeFound = true;
@@ -1776,6 +1792,10 @@ function setReadWatch(watch) {
  * via a `setContext` call.
  */
 function createContext(defaultValue, description) {
+  // Dev: an explicit `undefined` default is still no default (`undefined`
+  // means "not provided"); remembered so a failed read can say so (#4181).
+  if (arguments.length && defaultValue === undefined)
+    return { id: Symbol(description), defaultValue, _undefinedDefault: true };
   return { id: Symbol(description), defaultValue };
 }
 /**
@@ -1796,7 +1816,9 @@ function getContext(context, owner = getOwner()) {
   let value = owner._context[context.id];
   if (value === undefined) value = context.defaultValue;
   if (value === undefined) {
-    throw new ContextNotFoundError();
+    // 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(context, context.id in owner._context);
   }
   return value;
 }
@@ -1886,7 +1908,12 @@ function notifyEffectStatus(status, error) {
       return;
     }
     if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-      haltReactivity(unwrapStatusError(actualError));
+      // Dev locates the halt at the node that threw: the StatusError's
+      // source, upstream of this effect when a computed failed.
+      haltReactivityAt(
+        unwrapStatusError(actualError),
+        actualError instanceof StatusError ? actualError.source : this
+      );
       throw actualError;
     }
   } else if (this._type === EFFECT_RENDER) {
@@ -1952,7 +1979,7 @@ function runEffect(node, type) {
         : console.error(err);
     } catch (error) {
       if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-        haltReactivity(error);
+        haltReactivityAt(error, node);
         throw error;
       }
     }
@@ -1988,7 +2015,7 @@ function runEffect(node, type) {
     ext(node)._error = new StatusError(node, error);
     node._statusFlags |= STATUS_ERROR;
     if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-      haltReactivity(error);
+      haltReactivityAt(error, node);
       throw error;
     }
   } finally {
@@ -2617,7 +2644,12 @@ function createReaction(effectFn, options) {
     }
     runWithOwner(owner, () => {
       effect(
-        () => (tracking(), (arm = getOwner())),
+        () => {
+          const node = getOwner();
+          arm = node;
+          tracking();
+          return node;
+        },
         node => {
           arm = undefined;
           cl?.();
@@ -3355,7 +3387,7 @@ function updateKeyedMap() {
         this._rows && (this._rows = []);
         this._indexes && (this._indexes = []);
       }
-      if (this._fallback && !this._mappings[0]) {
+      if (this._fallback && !this._mappings.length) {
         // an aborted fallback attempt leaves an owner without a mapping;
         // dispose it before re-creating
         this._nodes[0]?.dispose();
@@ -3636,7 +3668,7 @@ function updateRepeat() {
         // Reset offset to match the cleared data (#2767, repro 2).
         this._offset = 0;
       }
-      if (this._fallback && !this._mappings[0]) {
+      if (this._fallback && !this._mappings.length) {
         // an aborted fallback attempt leaves an owner without a mapping;
         // dispose it before re-creating
         this._nodes[0]?.dispose();
@@ -3941,9 +3973,13 @@ function bornStaged(target, node, staged, key) {
   if (k === null) return; // a node-less staging holds nothing (`stageOn`)
   // Held by the container's transaction only for a key the HELD staging
   // changed — a mainline layer's change above it stages mainline. (A
-  // container carrying a guess is a lane's: the flush's park decides.)
-  if ((k._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(target, key))
-    holdNode(node, txOf(k));
+  // container carrying a guess is a lane's: the flush's park decides —
+  // unless a correction folded under the guess, D-34: the key is that
+  // correction's hold's.)
+  if (k._config & CONFIG_HELD && heldKeyChanged(target, key)) {
+    const l = txOf(k);
+    if (!(k._config & CONFIG_OVERRIDE) || l.folded) holdNode(node, resolveTx(l._parent ?? l));
+  }
   // A28 (4): a batch written inside a creation-time pass is promoted — its
   // late-materialized leaf with it.
   if (k._config & CONFIG_PROMOTED) notePromotedWrite(node);
@@ -5371,6 +5407,47 @@ function touch(target, key) {
   }
   if (wk !== WK_ALL) (target.wk ??= new Set()).add(key);
 }
+/** Dev: targets (and their keys) already warned about for a write outside
+ * the setter — #4179's once-per-target+key memory. */
+let warnedOutsideWrites;
+/** Dev: set while the runtime itself writes through a proxy it knows the
+ * trap ignores (`registerGraph`'s `_owner` stamp). */
+let internalOutsideWrite = false;
+/** Dev: a write, defineProperty or delete on a store proxy outside its
+ * setter's draft is ignored (the trap returns `true` so strict-mode code
+ * does not throw) — say so once per target+key instead of silently dropping
+ * it (#4179). */
+function warnWriteOutsideSetter(target, key, operation) {
+  if (internalOutsideWrite) return;
+  warnedOutsideWrites ??= new WeakMap();
+  let keys = warnedOutsideWrites.get(target);
+  if (keys === undefined) warnedOutsideWrites.set(target, (keys = new Set()));
+  if (keys.has(key)) return;
+  keys.add(key);
+  const name = String(key);
+  const access =
+    typeof key === "string" && /^[A-Za-z_$][\w$]*$/.test(key)
+      ? `.${key}`
+      : typeof key === "string" && /^\d+$/.test(key)
+        ? `[${key}]`
+        : `[${typeof key === "string" ? JSON.stringify(key) : name}]`;
+  const hint =
+    operation === "deleteProperty"
+      ? `setStore(s => { delete s${access} })`
+      : `setStore(s => { s${access} = value })`;
+  reportDiagnostic(
+    emitDiagnostic({
+      code: "STORE_WRITE_OUTSIDE_SETTER",
+      kind: "write",
+      severity: "warn",
+      message:
+        `[STORE_WRITE_OUTSIDE_SETTER] ${operation === "deleteProperty" ? "Deleting" : "Writing"} store property "${name}" outside its setter was ignored. ` +
+        `Stores are read-only outside the setter's draft: use \`${hint}\`.`,
+      nodeName: name,
+      data: { operation, property: name }
+    })
+  );
+}
 const traps = {
   get(target, key, receiver) {
     // One typeof gates every brand-symbol compare off the hot string path.
@@ -5614,7 +5691,10 @@ const traps = {
   set(target, key, value) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "set");
+      return true;
+    }
     if (key === "__proto__") return true; // pollution guard (core R30)
     const uv = target.s ? value : unwrapValue(value);
     const pb = ensurePB(target);
@@ -5663,7 +5743,10 @@ const traps = {
   defineProperty(target, key, desc) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "defineProperty");
+      return true;
+    }
     if (key === "__proto__") return true;
     if (desc.get || desc.set) target.a = true;
     if ("value" in desc) desc = { ...desc, value: unwrapValue(desc.value) };
@@ -5678,7 +5761,10 @@ const traps = {
   deleteProperty(target, key) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "deleteProperty");
+      return true;
+    }
     const pb = ensurePB(target);
     touch(target, key);
     // The key count (`kc`, the overlay gate and the rebuild cap) follows a
@@ -5836,8 +5922,11 @@ function createStore$1(initialValue, options) {
   {
     const owner = getOwner();
     // Dev-tier graph registration (owner signal lists, onGraph); the
-    // `_owner` write itself never reaches the proxy, see storeOwners.
+    // `_owner` write itself never reaches the proxy, see storeOwners — an
+    // internal ignored write, not the user's (#4179's warning skips it).
+    internalOutsideWrite = true;
     registerGraph(proxy, owner);
+    internalOutsideWrite = false;
     // Only once the engine is installed, like the node stamping it feeds: a
     // WeakMap.set per fresh store is a growing ephemeron table and,
     // disabled, buys nothing.
@@ -6809,10 +6898,12 @@ function notifyOptimisticWrites(t, pb) {
   if (structural) {
     const rows = isArr ? pb.map(unwrapValue) : shallowKeys(pb);
     // The rows the setter removed from the view it saw, by key: a later
-    // re-base over another action's truth must not bring them back.
+    // re-base over another action's truth must not bring them back. A set
+    // (empty or not) marks a keyed arrangement guess (`fold`).
     let removed = null;
     const keyFn = t.fam.key;
     if (isArr && keyFn !== null && keyFn !== undefined) {
+      removed = new Set();
       const kept = new Set();
       for (let i = 0; i < rows.length; i++) {
         const k = isWrappable(rows[i]) ? keyFn(rows[i]) : undefined;
@@ -6821,7 +6912,7 @@ function notifyOptimisticWrites(t, pb) {
       for (let i = 0; i < old.length; i++) {
         const r = unwrapValue(old[i]);
         const k = isWrappable(r) ? keyFn(r) : undefined;
-        if (k !== undefined && !kept.has(k)) (removed ??= new Set()).add(k);
+        if (k !== undefined && !kept.has(k)) removed.add(k);
       }
     }
     optimisticWrite(getContainerNode(t), new LaneView(rows, base, removed));
@@ -6957,7 +7048,8 @@ function reconcileDraft(draft, incoming, keyFn) {
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
  * positionally — the guess stands as written (the documented residue). */
-GlobalQueue._laneRebase = (el, truth) => {
+GlobalQueue._laneRebase = (el, truth, older) => {
+  if (!older) return fold(el, truth);
   const t = el._host;
   if (t === undefined || el._key !== $TRACK) return;
   const view = el._x._lane;
@@ -7018,6 +7110,51 @@ GlobalQueue._laneRebase = (el, truth) => {
       laneSet(len, rows.length, lane);
   }
 };
+/** D-34 for a keyed arrangement guess: rows by key, not positions. A
+ * current truth that differs folds into the hold beneath it instead of
+ * voiding the lane: the guess stays the lane's value and the screen's until
+ * the hold commits, where rows match by key, and the graph outside the lane
+ * re-derives from the truth now (`foldedRead`). A confirmation is silent
+ * (A17): only truth readers are told. True: the lane stages the truth
+ * beneath (`laneWrite`). */
+function fold(el, truth) {
+  const k = el._host?.k;
+  const l = txOf(el);
+  // A guess the screen never showed is void at the correction (D-34); a
+  // keyed arrangement guess's view carries its removed-keys set.
+  if (!l._shown || !(k?._config & CONFIG_OVERRIDE) || !k._x._lane?.removed) return false;
+  const guess = el._x._lane;
+  if ((!el._equals || !el._equals(guess, truth)) && !GlobalQueue._echoes(guess, truth)) {
+    l.folded = foldedRead;
+    insertSubs(el);
+  } else GlobalQueue._confirmed?.(l);
+  joinFuture(resolveTx(l._parent ?? l));
+  return true;
+}
+/** A folded lane's guess read by a deriving pass outside the lane, tracked
+ * or not (`untrack` is about dependencies, not about which world a pass
+ * derives from), or by `latest()` (`c` null): the hold's world — the truth
+ * staged beneath the guess, else the value it covered — and the pass joins
+ * the hold. Lane passes and the screen keep the guess: held truth is masked
+ * from lane passes only (#3164). The store's own derive reconciles its
+ * landings against the arrangement the guesses made: it is the author, not
+ * a reader. */
+function foldedRead(c, el) {
+  if (c !== null) {
+    if (
+      !(el._config & CONFIG_GUESS) ||
+      passLane !== null ||
+      c._type === EFFECT_RENDER ||
+      c._config & CONFIG_CHILDREN_FORBIDDEN ||
+      el._host?.fam?.node === c
+    )
+      return NOT_PENDING;
+    const l = txOf(el);
+    joinPassAt(c, resolveTx(l._parent ?? l));
+  }
+  if (el._pendingValue !== NOT_PENDING) return el._pendingValue;
+  return el._config & CONFIG_SLOT_NODE ? GlobalQueue._slotCovered(el) : el._value;
+}
 function sameRow(a, b, keyFn) {
   if (a === b) return true;
   if (!isWrappable(a) || !isWrappable(b)) return false;
@@ -9310,7 +9447,7 @@ function createBoundary(type, fn, show, onFn) {
         } catch (e) {
           if (!(e instanceof NotReadyError)) {
             if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
-              haltReactivity(e);
+              if (true) haltReactivityAt(e, getOwner());
               throw e;
             }
             return;

package/dist/observe/boundaries.js

@@ -14,7 +14,7 @@ import { enqueueSub } from "./core/heap.js";
 
 import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
-import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, schedule, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
+import { globalQueue, haltReactivityAt, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, schedule, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
 
 import { attrHooks } from "./core/attribution-hooks.js";
 
@@ -353,7 +353,7 @@ function createBoundary(e, r, n, t) {
             } catch (e) {
                 if (!(e instanceof NotReadyError)) {
                     if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
-                        haltReactivity(e);
+                        if (false) ; else haltReactivity(e);
                         throw e;
                     }
                     return;

package/dist/observe/core/async.js

@@ -148,7 +148,9 @@ function releaseSettledDependents(e) {
     // Staged whether or not the flush has joined a hold yet: a pass that runs
     // before its async sibling joins is the seam's to decide, like a value
     // (#4109). A flush that parks nothing publishes it at its commit (S-38).
-    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q) || passLane) return false;
+    // Not a projection's derive: its readers learn its error through the
+    // family, which the commit's publish never reaches (#4189).
+    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q && !e.fam) || passLane) return false;
     // The node answered (an error ends the wait — no longer pending, nor
     // blocked); a shown error stays its display until the commit.
         clearPendingSources(e);

package/dist/observe/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/observe/core/core.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
@@ -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,8 +242,8 @@ 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?.fe : 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
@@ -332,7 +334,7 @@ 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?.fe?.has(t)) settlePendingSource(e, t);
         }
     } finally {
         tracking = d;
@@ -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.
@@ -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
@@ -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
@@ -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

@@ -50,6 +50,8 @@ function notifyEffectStatus(t, e) {
             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;
         }

package/dist/observe/core/graph.js

@@ -2,7 +2,7 @@ import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIV
 
 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?.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
@@ -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.dt;
+    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    const t = n._ = e.dt = {
         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();
 }