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

package/dist/dev-shared.js

@@ -283,10 +283,30 @@ const CONFIG_WIDE = 1 << 26;
  * creation by dev builds only (the observe artifact mangles the option name,
  * as it does `_wide`). */
 const CONFIG_SUPERSEDES = 1 << 27;
+/** Observe tiers only: the memo `merge()` creates for a function source — a
+ * key bag readers consume key by key, built by the framework (a compiled
+ * component spread) with options no user can reach. The attribution engine's
+ * UNSTABLE_MEMO_OUTPUT skips it: a fresh-but-equal bag is the idiom
+ * (`{...(on() ? { a } : {})}`), and the advice (`equals`) cannot be applied
+ * (#4256). Set through `_extraConfig` by observe builds only. */
+const CONFIG_KEY_BAG = 1 << 28;
+/** The frame (rule 3, D-3): a render effect (set at creation, as
+ * `EFFECT_RENDER << 23` — keep the two in step), and a boundary's tree and
+ * output (boundaries.ts) — structure between the content and the render
+ * effect that shows it, not a user derivation of the content. Outside a
+ * hold's own flush it reads that hold's values as committed and is
+ * re-derived at its landing, and a re-pass of it publishes mainline: it
+ * joins nothing, so two mounts under one boundary made in separate flushes
+ * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
+const CONFIG_FRAME = 1 << 23;
 const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
+/** An error that answered a node's first read (no value has ever landed):
+ * the error, not UNINITIALIZED, is its status while shown, but a re-ask
+ * makes it uninitialized-pending again — it still has no value (#4244). */
+const STATUS_NO_VALUE = 1 << 3;
 /** `catchHook`'s answer when the catcher is a boundary re-armed by
  * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
 const CAUGHT_REARMED = 2;
@@ -306,6 +326,8 @@ const defaultContext = {};
  */
 const $REFRESH = Symbol("refresh");
 
+const NewSet = Set;
+
 let attrHooks = null;
 /**
  * The installed engine, registered on `globalThis` as well (the records
@@ -1212,10 +1234,12 @@ function disposeChildren(node, self = false, zombie) {
     // A death that can unblock the future (L2, `futureBlocked`): a held
     // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
     // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
+    // An idle pending queue would also pin it until an unrelated flush.
     // Nothing else re-examines a dead node, so make sure a seam comes.
     if (
       (node._statusFlags & STATUS_PENDING && node._x?._transaction != null) ||
-      flags & REACTIVE_FRAME_READ
+      flags & REACTIVE_FRAME_READ ||
+      pendingNodes.length
     )
       schedule();
   }
@@ -2032,8 +2056,18 @@ function nextQuestion() {
 }
 const MAINLINE_QUESTION = 0x7fffffff;
 let inEffectCallback = false;
-function setEffectCallback(value) {
-  inEffectCallback = value;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+const ANY_EVENT = {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+let effectCallbackEvent = ANY_EVENT;
+function setEffectCallback(value, event = ANY_EVENT) {
+  {
+    inEffectCallback = value;
+    effectCallbackEvent = event;
+  }
 }
 function schedule() {
   if (halted) {
@@ -2059,12 +2093,13 @@ function schedule() {
  * hook machinery (pay-for-use).
  */
 const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
+const HALTED = "[REACTIVITY_HALTED]";
 function haltReactivity(cause) {
   if (halted) return;
   halted = true;
   // A cleanup error collected before the halt is dropped (owner.ts).
   rethrowCleanupError(true);
-  let message = "[REACTIVITY_HALTED]";
+  let message = HALTED;
   {
     message +=
       " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with <Errored> or treat this as a crash.";
@@ -2290,11 +2325,12 @@ class GlobalQueue {
     // This flush's own runs, the lanes' reveals, and the landings' held runs
     // are collected apart and ordered below.
     const own = this._queues;
-    const lanes = (this._queues = [[], []]);
+    const lanes = [[], []];
     // The passes that read this frame's stagings as the screen read held
     // writes if it parked: the lane seam re-derives them on the committed
     // world (a lane's runs wait this round).
     if (laneSeamsHook) {
+      this._queues = lanes;
       laneSeamsHook(t !== null ? stagedReaders : null);
       if (stagedReaders.length) stagedReaders.length = 0;
     }
@@ -2421,8 +2457,9 @@ class GlobalQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */
+ * it. Truthy when an effect re-derives (`land`). */
 function reruns(u) {
+  let frame;
   for (let i = 0; i < u._reruns.length; i++) {
     const r = u._reruns[i];
     // An errored reader's display is its error (D-39): the landing gives it
@@ -2430,6 +2467,7 @@ function reruns(u) {
     // errored source (#3945).
     if (r._flags & REACTIVE_DISPOSED || r._statusFlags & STATUS_ERROR) continue;
     if (r._flags & REACTIVE_FRAME_READ || r._config & CONFIG_VERDICT) {
+      frame ||= r._type;
       r._flags &= ~REACTIVE_FRAME_READ;
       r._modified = false;
       // Its frame is replaced by the re-derivation: a run one of its
@@ -2440,14 +2478,15 @@ function reruns(u) {
     }
   }
   u._reruns.length = 0;
+  return frame;
 }
 /** The landing: the held frame becomes the frame. */
 function land(u) {
   // Attribution hook: judged complete — its held writes commit next
   // (`_nodes` still lists them).
   if (attrHooks !== null) attrHooks.transitionSettled(u);
-  reruns(u);
-  if (u._marks !== null) releaseMarksHook(u._marks);
+  const frame = reruns(u);
+  if (releaseMarksHook && u._marks !== null) releaseMarksHook(u._marks);
   // Old children die in the commits (cleanups first), then the stashed
   // effects run ahead of this flush's own. A node a lane took over since
   // (a guess written over the staged truth) is the lane's to land.
@@ -2461,7 +2500,16 @@ function land(u) {
   // `u`, which has left `transactions`: the write is this landing's, and
   // the next flush must not park in it (#4089).
   if (flushTransaction === u) flushTransaction = null;
-  releaseQueues(u);
+  // An effect re-derives next round (`reruns`): the held runs wait for it
+  // (D-9, the A15 reveal corollary, #4071). Its re-derivation can discover a
+  // flight — a stale reader whose mainline pass stopped reading it, now
+  // reading the landed world — and a landing that showed its runs first
+  // would reveal the held write beside a frame that can only show its old
+  // value. Queued last in this effect phase, the release hands them to the
+  // next round's own runs, ahead of the re-derivation's: they show with it,
+  // or park with it in the hold its pending opens. The commits stand.
+  if (frame) globalQueue._queues[1].push(() => releaseQueues(u));
+  else releaseQueues(u);
 }
 /** The held runs join this flush's effect phase after its own runs (the
  * landing's re-passes, in height order): the frame's effects run as one
@@ -2720,8 +2768,22 @@ function flush(fn) {
   // (owner.ts).
   rethrowCleanupError();
 }
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+let queueEvent = ANY_EVENT;
 function runQueue(queue, type) {
-  for (let i = 0; i < queue.length; i++) queue[i](type);
+  {
+    const prev = queueEvent;
+    queueEvent = dispatchingEvent();
+    try {
+      for (let i = 0; i < queue.length; i++) queue[i](type);
+    } finally {
+      queueEvent = prev;
+    }
+    return;
+  }
 }
 
 /**
@@ -2943,7 +3005,7 @@ function unobserved(el) {
  * 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;
   for (const el of dormantNodes) {
@@ -3011,7 +3073,7 @@ function link(dep, sub) {
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(el, source) {
   if (el._x?._pendingSources?.has(source)) return false;
-  (ext(el)._pendingSources ??= new Set()).add(source);
+  (ext(el)._pendingSources ??= new NewSet()).add(source);
   return true;
 }
 function removePendingSource(el, source) {
@@ -3094,7 +3156,7 @@ function releaseIfSettledUnobserved(node) {
 // Collect-then-release so unobserved() never unlinks under the walk.
 function releaseSettledDependents(el) {
   let candidates;
-  const visited = new Set();
+  const visited = new NewSet();
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
@@ -3160,7 +3222,7 @@ function stageError(el, error, inPass) {
 }
 function settleErroredDependents(el, error) {
   let scheduled = false;
-  const visited = new Set();
+  const visited = new NewSet();
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
@@ -3237,7 +3299,7 @@ function settlePendingSource(el, source = el) {
   removePendingSource(el, source);
   let scheduled = false;
   let released;
-  const visited = new Set();
+  const visited = new NewSet();
   const settle = node => {
     if (
       visited.has(node) ||
@@ -3304,6 +3366,37 @@ function releaseFlightTeardown(el) {
     teardown();
   }
 }
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */
+function onSupersede(fn) {
+  const el = context;
+  if (el === null || el._fn === undefined || !(el._flags & REACTIVE_RECOMPUTING_DEPS)) return;
+  const fresh = el._x === null;
+  const x = ext(el);
+  // Allocating the extension mid-run turns `_x?._inFlight` from undefined into
+  // null, which recompute would read as a flight this body registered itself.
+  // Restore undefined here, so the fix costs nothing for code that never
+  // calls onSupersede.
+  if (fresh) x._inFlight = undefined;
+  const prev = x._flightTeardown;
+  x._flightTeardown =
+    prev === null
+      ? fn
+      : () => {
+          try {
+            prev();
+          } finally {
+            fn();
+          }
+        };
+}
 function handleAsync(
   el,
   result,
@@ -3407,8 +3500,14 @@ function handleAsync(
     // D-41: a held node's error is staged (`stageError`). A derived store's
     // readers learn its error through the family, not the derive's
     // dependents: it publishes now.
-    if (stillPending || setter || !stageError(el, error))
+    if (stillPending || setter || !stageError(el, error)) {
       notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
+      // The error is this pass's answer, published now: it replaces the shown
+      // frame as a value's commit would (`commitPendingNode`), so the frame
+      // the pass parked goes instead of waiting for a later success. A no-op
+      // when nothing is parked.
+      if (!stillPending) disposeChildren(el, false, true);
+    }
     // A NotReady rejection is a landing into another pending source. The
     // rejected flight will never settle its self entry, so transfer ownership
     // after notifyStatus has propagated the replacement source.
@@ -3440,8 +3539,14 @@ function handleAsync(
         return;
       }
       // A store derive's landing commits through its setter: unheld, the
-      // shown error leaves now; held, at the derive's commit.
-      if (!(el._config & CONFIG_HELD)) el._x._shownError = undefined;
+      // shown error leaves now, and so does a commit-beneath-a-flight's
+      // CONFIG_INPUTS_PUBLISHED (its first flight's, #4269) — left standing,
+      // a verdict reader of the next flight would suspend instead of being
+      // served the screen; held, both at the derive's commit.
+      if (!(el._config & CONFIG_HELD)) {
+        el._x._shownError = undefined;
+        el._config &= ~CONFIG_INPUTS_PUBLISHED;
+      }
       if (wasUninitialized) landStatus(el, true);
       // Attribution hook: this path landed through the setter (derived
       // stores, projections), which does not go through setSignal, so the
@@ -3523,7 +3628,11 @@ function handleAsync(
     cleanup(close, owner);
     // Flight-identity cancellation (#3122): the registration above is the
     // owner-death backstop; the teardown slot fires at the _inFlight release
-    // sites so supersede stops this stream immediately.
+    // sites so supersede stops this stream immediately. Assigned, not
+    // chained (chaining here costs every app bytes): it replaces any
+    // `onSupersede` teardown this run registered earlier, which then falls
+    // back to the owner-cleanup channel. A returned `from()` is unaffected:
+    // `close` calls its `return()`, which runs its own teardown.
     ext(el)._flightTeardown = close;
     // Release check before each next pull: an unobserved lazy node must tear
     // down (its close above runs via disposal, closing the iterator) instead
@@ -3686,12 +3795,12 @@ function handleAsync(
       handleError(syncError);
       throw syncError;
     } else if (!resolved) {
-      // Loading window: serve commit #0 instead of suspending — first-flight
-      // work on a loadingValue node is loading-class (invisible to
-      // boundaries); the flight itself is already registered in _inFlight and
-      // lands through asyncWrite.
-      if (el._loading) return el._value;
-      throw new NotReadyError(context);
+      // Not landed: the shared tail below suspends, or — loading window —
+      // serves commit #0 (first-flight work on a loadingValue node is
+      // loading-class, invisible to boundaries; the flight itself is already
+      // registered in _inFlight and lands through asyncWrite). A promise is
+      // never an iterator, so nothing between here and there runs.
+      liveLanded = false;
     } else if (!flattenIfIterable(syncValue)) {
       // Synchronously-resolved promise: the first real answer landed.
       el._loading = false;
@@ -3703,7 +3812,7 @@ function handleAsync(
   if (iterator) flattenIfIterable(result);
   if (liveLanded !== null) {
     if (!liveLanded) {
-      // Loading window: serve commit #0 (see the promise branch above).
+      // Loading window: serve commit #0 instead of suspending.
       if (el._loading) return el._value;
       throw new NotReadyError(context);
     }
@@ -3715,7 +3824,7 @@ function handleAsync(
 }
 function clearStatus(el, clearUninitialized = false) {
   if (el._x?._pendingSources) clearPendingSources(el);
-  if (el._x?._blocked) if (el._x !== null) el._x._blocked = false;
+  if (el._x?._blocked) el._x._blocked = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
   if (el._x?._error) setPendingError(el);
   const notify = statusNotifierOf(el);
@@ -3755,7 +3864,7 @@ function landStatus(el, clearUninitialized = false) {
     setPendingError(el, sources.values().next().value);
   } else clearStatus(el, clearUninitialized);
 }
-function notifyStatus(el, status, error, blockStatus) {
+function notifyStatus(el, status, error) {
   // Wrap regular errors to track source node
   if (
     status === STATUS_ERROR &&
@@ -3766,21 +3875,33 @@ function notifyStatus(el, status, error, blockStatus) {
   const pendingSource =
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
   // (CARVE 2: the lane assignment went with the engine.)
-  {
-    if (status === STATUS_PENDING && pendingSource) {
-      // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
-      if (el._statusFlags & STATUS_ERROR) el._x._shownError = el._x._error;
-      addPendingSource(el, pendingSource);
-      el._statusFlags = STATUS_PENDING | (el._statusFlags & STATUS_UNINITIALIZED);
-      // Preserve the current source on this propagation so readers park on
-      // the distinct pending source.
-      setPendingError(el, pendingSource, error);
-    } else {
-      clearPendingSources(el);
-      el._statusFlags =
-        status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-      ext(el)._error = error;
-    }
+  if (status === STATUS_PENDING && pendingSource) {
+    // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
+    if (el._statusFlags & STATUS_ERROR) el._x._shownError = el._x._error;
+    addPendingSource(el, pendingSource);
+    // A re-ask of an error that answered the first read: still no value.
+    el._statusFlags =
+      STATUS_PENDING |
+      (el._statusFlags & STATUS_NO_VALUE
+        ? STATUS_UNINITIALIZED
+        : el._statusFlags & STATUS_UNINITIALIZED);
+    // Preserve the current source on this propagation so readers park on
+    // the distinct pending source.
+    setPendingError(el, pendingSource, error);
+  } else {
+    clearPendingSources(el);
+    // An error answering a node with no value marks it so; a re-ask of it
+    // (pending) is uninitialized again; a write (STATUS_NONE) gives it one.
+    el._statusFlags =
+      status |
+      (status === STATUS_ERROR
+        ? el._statusFlags & (STATUS_UNINITIALIZED | STATUS_NO_VALUE)
+          ? STATUS_NO_VALUE
+          : 0
+        : status === STATUS_PENDING && el._statusFlags & STATUS_NO_VALUE
+          ? STATUS_UNINITIALIZED
+          : el._statusFlags & STATUS_UNINITIALIZED);
+    ext(el)._error = error;
   }
   // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
   // future value until we know otherwise"). Its own source in flight is its
@@ -3794,9 +3915,7 @@ function notifyStatus(el, status, error, blockStatus) {
   }
   const elNotify = statusNotifierOf(el);
   if (elNotify) {
-    {
-      elNotify.call(el);
-    }
+    elNotify.call(el);
     return;
   }
   propagateStatus(el, status, error);
@@ -3806,7 +3925,7 @@ function notifyStatus(el, status, error, blockStatus) {
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
-function propagateStatus(el, status, error, downstreamBlockStatus) {
+function propagateStatus(el, status, error) {
   const pendingSource =
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
   forEachDependent(el, (sub, link) => {
@@ -3863,25 +3982,26 @@ function propagateStatus(el, status, error, downstreamBlockStatus) {
       // bookkeeping (loading window, uninitialized clear) runs with the flush
       // — with the lane, when the pass propagating is the lane's work and
       // the dependent's pending is the lane's own flight (`laneStage`).
-      {
-        // (No answer: a pending propagation leaves a written guess a guess.)
-        if (laneStageHook && passLane !== null) laneStageHook(sub, passLane, true, el);
-        else {
-          queuePendingNode(sub);
-          // A15 (#3443): pending propagates onto a held memo without
-          // recomputing it, and the propagation itself enters the memo's
-          // transaction — the flight flows into a memo that transaction
-          // holds, so the write that started it is held with it. A render
-          // effect's membership is its pass's (`notify`), never sticky.
-          if (
-            status === STATUS_PENDING &&
-            (sub._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD &&
-            !sub._type
-          )
-            joinFuture(txOf(sub));
-        }
+      // (No answer: a pending propagation leaves a written guess a guess.)
+      if (laneStageHook && passLane !== null) laneStageHook(sub, passLane, true, el);
+      else {
+        queuePendingNode(sub);
+        // A15 (#3443): pending propagates onto a held memo without
+        // recomputing it, and the propagation itself enters the memo's
+        // transaction — the flight flows into a memo that transaction
+        // holds, so the write that started it is held with it. A render
+        // effect's membership is its pass's (`notify`), never sticky.
+        if (
+          status === STATUS_PENDING &&
+          (sub._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD &&
+          !sub._type
+        )
+          joinFuture(txOf(sub));
       }
       notifyStatus(sub, status, error);
+      // A derived store's derive (store/projection.ts): marked, not re-run —
+      // its leaves' readers are not its dependents, so the family walks them.
+      sub.fam?.st(status);
     }
   });
 }
@@ -3945,7 +4065,11 @@ const PRIMITIVE_IN_EFFECT_CALLBACK_MESSAGE =
  * created there is inert and harmless. Tracked effects and onSettled are
  * children-forbidden and refuse through PRIMITIVE_IN_FORBIDDEN_SCOPE. */
 function assertNotInEffectCallback() {
-  if (inEffectCallback && context === null) {
+  if (
+    inEffectCallback &&
+    context === null &&
+    (effectCallbackEvent === ANY_EVENT || dispatchingEvent() === effectCallbackEvent)
+  ) {
     emitDiagnostic({
       code: "PRIMITIVE_IN_EFFECT_CALLBACK",
       kind: "lifecycle",
@@ -3978,10 +4102,25 @@ function ownerInSnapshotScope(owner) {
 }
 function setSnapshotCapture(active) {
   snapshotCaptureActive = active;
-  if (active && !snapshotSources) snapshotSources = new Set();
+  if (active && !snapshotSources) snapshotSources = new NewSet();
 }
-function markSnapshotScope(owner) {
-  owner._snapshotScope = true;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */
+function markSnapshotScope(owner, served) {
+  if (arguments.length < 2) owner._snapshotScope = true;
+  else if (snapshotCaptureActive && owner._x?._snapshotValue === undefined)
+    takeSnapshot(owner, served);
 }
 function releaseSnapshotScope(owner) {
   owner._snapshotScope = false;
@@ -4094,6 +4233,8 @@ function recompute(el, create = false) {
     // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
     // staging: live writes keep it current, it effects at the swap (ruling
     // A).
+    // A boundary's structure (CONFIG_FRAME) is the frame like a render
+    // effect: it publishes mainline outside its transaction's flush (#4283).
     // A pending flight is the transition's own work (#3884). A probe on an
     // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
     // committed screen, settle the flight and drop the hold — a superseding
@@ -4107,8 +4248,10 @@ function recompute(el, create = false) {
       // world (`read`), and has left it otherwise.
       // An answered deferred node's re-pass is a lagging question (D-40):
       // it joins nothing, so the write that reached it commits mainline.
+      // `EFFECT_RENDER << 23` is CONFIG_FRAME (a render effect, a boundary's
+      // tree and output), spelled from the effect type as at creation.
       if (tx._lane || el._config & CONFIG_LAGS);
-      else if (isEffect !== EFFECT_RENDER && !(el._config & CONFIG_VERDICT))
+      else if (!(el._config & (CONFIG_VERDICT | (EFFECT_RENDER << 23))))
         joinPassTx(tx, freshHook?.(el, el._statusFlags & STATUS_UNINITIALIZED));
       else if (
         tx !== flushTransaction &&
@@ -4120,8 +4263,10 @@ function recompute(el, create = 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`).
+        // Not held any more, whichever frame reader it is: its readers read
+        // the value this pass publishes.
         el._pendingValue = NOT_PENDING;
-        if (isEffect === EFFECT_RENDER) el._config &= ~CONFIG_HELD;
+        el._config &= ~CONFIG_HELD;
       }
     }
     // The previous pass's frame. If that pass is still awaiting its commit
@@ -4405,7 +4550,9 @@ function recompute(el, create = 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`.)
+    // (The hook first: a build without lanes folds the arm away.)
     if (
+      laneOutcomeHook &&
       !create &&
       lane === null &&
       el._config & CONFIG_GUESS &&
@@ -4776,13 +4923,18 @@ function frameRead(c, el) {
   // read the screen. Lane work with no committed value yet reads a flight
   // as a mount's memo does: it enters, and the boundary it mounts catches
   // the pending (#3540).
+  // A boundary's tree and output (CONFIG_FRAME) read as a render effect
+  // does: structure, not a derivation of what it shows (#4283). A mount
+  // under a hold still enters it: the content memo it reads is born held,
+  // with no committed value to serve.
   // (Verdict readers and lanes exist only with their engines installed.)
   const verdict = observeFlightHook && c._config & CONFIG_VERDICT;
   const lane = laneStageHook && passLane !== null;
   if (
     (!lane || (c._statusFlags & STATUS_UNINITIALIZED && el._statusFlags & STATUS_PENDING)) &&
     !verdict &&
-    (c._type !== EFFECT_RENDER || el._config & CONFIG_INPUTS_PUBLISHED)
+    // CONFIG_FRAME, spelled as at the effect's creation.
+    (!(c._config & (EFFECT_RENDER << 23)) || el._config & CONFIG_INPUTS_PUBLISHED)
   )
     return false;
   const t = txOf(el);
@@ -4839,6 +4991,9 @@ function createEffectNode(fn, effectFn, errorFn, type, options) {
   const self = {
     id: inheritId(options, transparent, context),
     _config:
+      // CONFIG_FRAME for a render effect (EFFECT_RENDER = 1; a user
+      // effect's 1 << 24 is unused).
+      (type << 23) |
       (transparent ? CONFIG_TRANSPARENT : 0) |
       (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
       (options?.sync ? CONFIG_SYNC : 0) |
@@ -4907,7 +5062,7 @@ function setEffectStatusNotify(fn) {
  * 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(el) {
-  return el._type ? (effectStatusNotify ?? undefined) : undefined;
+  return el._type ? effectStatusNotify : null;
 }
 const lazyOptions = { lazy: true };
 function setupComputedNode(self, options) {
@@ -4931,11 +5086,8 @@ function setupComputedNode(self, options) {
   wireExternalSourceHook?.(self);
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
-    if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT)) {
-      ext(self)._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
-      self._config |= CONFIG_HAS_SNAPSHOT;
-      snapshotSources.add(self);
-    }
+    if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT))
+      takeSnapshot(self, self._value);
   }
 }
 function signal(v, options) {
@@ -4961,11 +5113,7 @@ function signal(v, options) {
   };
   s._internal = false;
   if (options?.unobserved) ext(s)._unobserved = options.unobserved;
-  if (snapshotCaptureActive && !(s._config & CONFIG_NO_SNAPSHOT)) {
-    ext(s)._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
-    s._config |= CONFIG_HAS_SNAPSHOT;
-    snapshotSources.add(s);
-  }
+  if (snapshotCaptureActive && !(s._config & CONFIG_NO_SNAPSHOT)) takeSnapshot(s, v);
   return s;
 }
 function isEqual(a, b) {
@@ -5056,11 +5204,31 @@ function exitDisposal() {
 function resetDisposalDepth() {
   disposalDepth = 0;
 }
-function setStrictRead(v) {
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+let strictReadEvent;
+// `?? null`: no current event must not read as a missing argument below.
+const dispatchingEvent = () => globalThis.event ?? null;
+function setStrictRead(v, event = ANY_EVENT) {
   const prev = strictRead;
   strictRead = v;
+  strictReadEvent = event;
   return prev;
 }
+/** Dev-only: is the strict-read window open for a read made now? */
+function strictReadActive() {
+  return !!strictRead && (strictReadEvent === ANY_EVENT || dispatchingEvent() === strictReadEvent);
+}
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.
@@ -5099,9 +5267,11 @@ function setStrictRead(v) {
 function untrack(fn, strictReadLabel) {
   const prevTracking = tracking;
   const prevStrictRead = strictRead;
+  const prevStrictReadEvent = strictReadEvent;
   tracking = false;
   {
     strictRead = strictReadLabel || false;
+    strictReadEvent = ANY_EVENT;
     untrackDepth++;
   }
   try {
@@ -5111,6 +5281,7 @@ function untrack(fn, strictReadLabel) {
     tracking = prevTracking;
     {
       strictRead = prevStrictRead;
+      strictReadEvent = prevStrictReadEvent;
       untrackDepth--;
     }
   }
@@ -5317,7 +5488,7 @@ function read(el) {
     stagedRead(c);
     return el._pendingValue;
   }
-  if (strictRead && owner._statusFlags & STATUS_PENDING)
+  if (strictRead && owner._statusFlags & STATUS_PENDING && strictReadActive())
     throwPendingUntrackedRead(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
@@ -5359,6 +5530,28 @@ function read(el) {
     const v = laneReadHook(c, el);
     if (v !== NOT_PENDING) return v;
   }
+  // Ahead of the snapshot serve below: a component body's direct read is
+  // wrong in the same way whether the pass is hydrating or not, and the
+  // hydration pass is the console nobody is watching (#3675).
+  if (strictRead && strictReadActive())
+    warnStrictReadUntracked(strictRead, {
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name
+    });
+  // A reader in a snapshot scope (a hydration claim) is served the value the
+  // server rendered with: a client write's recompute still in flight does
+  // not pull the claim off the markup it adopts — the reader replays at the
+  // scope's release. An errored node throws below as for any reader.
+  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
+    const sv = el._x?._snapshotValue;
+    if (sv !== undefined && !(owner._statusFlags & STATUS_ERROR)) {
+      const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
+      const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+      if (current !== snapshot) c._flags |= REACTIVE_SNAPSHOT_STALE;
+      return snapshot;
+    }
+  }
   // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
   // the committed value — coherent with the frame, whose inputs are the
   // committed ones too — and does not go pending on it. So is lane work
@@ -5435,24 +5628,6 @@ function read(el) {
       return read(el);
     } else throw owner._x?._error;
   }
-  // Ahead of the snapshot serve below: a component body's direct read is
-  // wrong in the same way whether the pass is hydrating or not, and the
-  // hydration pass is the console nobody is watching (#3675).
-  if (strictRead)
-    warnStrictReadUntracked(strictRead, {
-      ownerId: c?.id,
-      ownerName: c?._name,
-      nodeName: owner?._name
-    });
-  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
-    const sv = el._x?._snapshotValue;
-    if (sv !== undefined) {
-      const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
-      const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
-      if (current !== snapshot) c._flags |= REACTIVE_SNAPSHOT_STALE;
-      return snapshot;
-    }
-  }
   if (committed) return el._value;
   // D-41: an untracked read reads the screen, and a shown error is on it
   // until the answer that replaces it commits.
@@ -5579,7 +5754,10 @@ function captureWriteSnapshot(el, current) {
     el._x?._snapshotValue !== undefined
   )
     return;
-  ext(el)._snapshotValue = current === undefined ? NO_SNAPSHOT : current;
+  takeSnapshot(el, current);
+}
+function takeSnapshot(el, value) {
+  ext(el)._snapshotValue = value === undefined ? NO_SNAPSHOT : value;
   el._config |= CONFIG_HAS_SNAPSHOT;
   snapshotSources.add(el);
 }
@@ -5836,13 +6014,13 @@ function markRefresh(node) {
 }
 
 export {
-  setPassLane as $,
+  merge as $,
   tracking as A,
   CONFIG_CHILDREN_FORBIDDEN as B,
   CONFIG_GUESS as C,
   passLane as D,
-  STATUS_PENDING as E,
-  EFFECT_RENDER as F,
+  EFFECT_RENDER as E,
+  setPassLane as F,
   GlobalQueue as G,
   sameLane as H,
   flushTransaction as I,
@@ -5856,16 +6034,16 @@ export {
   REACTIVE_CHECK as Q,
   REACTIVE_DISPOSED as R,
   STATUS_UNINITIALIZED as S,
-  CONFIG_INPUTS_PUBLISHED as T,
-  releaseQueues as U,
-  CONFIG_SLOT_NODE as V,
-  holdNode as W,
-  joinFuture as X,
-  reruns as Y,
-  CONFIG_STAGED as Z,
-  merge as _,
+  STATUS_PENDING as T,
+  CONFIG_INPUTS_PUBLISHED as U,
+  releaseQueues as V,
+  CONFIG_SLOT_NODE as W,
+  holdNode as X,
+  joinFuture as Y,
+  reruns as Z,
+  CONFIG_STAGED as _,
   NotReadyError as a,
-  setMemo as a$,
+  resetUnhandledAsync as a$,
   REACTIVE_JOINED as a0,
   REACTIVE_STAGED_READ as a1,
   stagedRead as a2,
@@ -5876,135 +6054,142 @@ export {
   verdict as a7,
   link as a8,
   pullComputed as a9,
-  cleanup as aA,
-  read as aB,
-  DEV as aC,
-  CONFIG_TRANSPARENT as aD,
-  NoOwnerError as aE,
-  ContextNotFoundError as aF,
-  createEffectNode as aG,
-  recompute as aH,
-  EFFECT_USER as aI,
-  reportDiagnostic as aJ,
-  computed as aK,
-  staleValues as aL,
-  CONFIG_AUTO_DISPOSE as aM,
-  EFFECT_TRACKED as aN,
-  heldRunHook as aO,
-  unwrapStatusError as aP,
-  haltReactivityAt as aQ,
-  setStrictRead as aR,
-  StatusError as aS,
-  trimStaleDeps as aT,
-  setTrackedQueueCallback as aU,
-  setEffectStatusNotify as aV,
-  _hitUnhandledAsync as aW,
-  resetUnhandledAsync as aX,
-  ROOT_ERROR_HOOK as aY,
-  registerGraph as aZ,
-  runWithOwner as a_,
+  signal as aA,
+  setSignal as aB,
+  cleanup as aC,
+  read as aD,
+  DEV as aE,
+  CONFIG_TRANSPARENT as aF,
+  NoOwnerError as aG,
+  ContextNotFoundError as aH,
+  createEffectNode as aI,
+  recompute as aJ,
+  EFFECT_USER as aK,
+  reportDiagnostic as aL,
+  computed as aM,
+  staleValues as aN,
+  CONFIG_AUTO_DISPOSE as aO,
+  EFFECT_TRACKED as aP,
+  heldRunHook as aQ,
+  unwrapStatusError as aR,
+  setStrictRead as aS,
+  queueEvent as aT,
+  StatusError as aU,
+  trimStaleDeps as aV,
+  haltReactivityAt as aW,
+  strictReadEvent as aX,
+  setTrackedQueueCallback as aY,
+  setEffectStatusNotify as aZ,
+  _hitUnhandledAsync as a_,
   strictRead as aa,
-  warnStrictReadUntracked as ab,
-  staleReader as ac,
-  globalQueue as ad,
-  joinPass as ae,
-  markLateLinker as af,
-  spectating as ag,
-  unflushedValue as ah,
-  CONFIG_STAGED_ERROR as ai,
-  stagedReaders as aj,
-  bornInto as ak,
-  enterAction as al,
-  setEffectCallback as am,
-  exitAction as an,
-  isThenable as ao,
-  actionDepth as ap,
-  flush as aq,
-  setQuestion as ar,
-  emitDiagnostic as as,
-  enterCallback as at,
-  exitCallback as au,
-  getOwner as av,
-  inEffectCallback as aw,
-  setExternalHooks as ax,
-  signal as ay,
-  setSignal as az,
+  strictReadActive as ab,
+  warnStrictReadUntracked as ac,
+  staleReader as ad,
+  globalQueue as ae,
+  joinPass as af,
+  markLateLinker as ag,
+  spectating as ah,
+  unflushedValue as ai,
+  CONFIG_STAGED_ERROR as aj,
+  stagedReaders as ak,
+  bornInto as al,
+  enterAction as am,
+  setEffectCallback as an,
+  exitAction as ao,
+  isThenable as ap,
+  actionDepth as aq,
+  flush as ar,
+  setQuestion as as,
+  emitDiagnostic as at,
+  enterCallback as au,
+  exitCallback as av,
+  getOwner as aw,
+  inEffectCallback as ax,
+  effectCallbackEvent as ay,
+  setExternalHooks as az,
   CONFIG_AUTHORITATIVE as b,
-  liveRootOwners as b$,
-  $REFRESH as b0,
-  markRefresh as b1,
-  createRoot as b2,
-  getObserver as b3,
-  dispose as b4,
-  TimeoutError as b5,
-  untrack as b6,
-  dirtyQueue as b7,
-  CONFIG_REDERIVE as b8,
-  passTx as b9,
-  settlePendingSource as bA,
-  joinPassAt as bB,
-  notifyEpoch as bC,
-  SUPPORTS_PROXY as bD,
-  releaseMarksHook as bE,
-  installMarkHooks as bF,
-  CONFIG_LAGS as bG,
-  REACTIVE_REASK as bH,
-  haltReactivity as bI,
-  heldUnder as bJ,
-  unhold as bK,
-  laneStageHook as bL,
-  REACTIVE_ZOMBIE as bM,
-  installBoundaryHooks as bN,
-  CAUGHT_REARMED as bO,
-  OBSERVE as bP,
-  clearSnapshots as bQ,
-  enforceLoadingBoundary as bR,
-  getNextChildId as bS,
-  markSnapshotScope as bT,
-  peekNextChildId as bU,
-  releaseSnapshotScope as bV,
-  resetErrorHalt as bW,
-  setConsoleFooter as bX,
-  setSnapshotCapture as bY,
-  setWriteHook as bZ,
-  setAttributionHooks as b_,
-  CONFIG_FRESH_READ as ba,
-  createOwner as bb,
-  writeHook as bc,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bd,
-  ownedScopeWriteMessage as be,
-  isEqual as bf,
-  CONFIG_MANUAL_WRITE as bg,
-  snapshotCaptureActive as bh,
-  captureWriteSnapshot as bi,
-  notePromotedWrite as bj,
-  slotSignal as bk,
-  stagedScreen as bl,
-  CONFIG_PROMOTED as bm,
-  setSlotUnobserved as bn,
-  installStoreHooks as bo,
-  joinPassTx as bp,
-  asyncTailFlights as bq,
-  untrackDepth as br,
-  checkPostAwaitRead as bs,
-  disposalDepth as bt,
-  insertIntoHeap as bu,
-  isDisposed as bv,
-  handleAsync as bw,
-  addPendingSource as bx,
-  propagateStatus as by,
-  forEachDependent as bz,
+  peekNextChildId as b$,
+  ROOT_ERROR_HOOK as b0,
+  registerGraph as b1,
+  runWithOwner as b2,
+  setMemo as b3,
+  $REFRESH as b4,
+  markRefresh as b5,
+  createRoot as b6,
+  getObserver as b7,
+  dispose as b8,
+  TimeoutError as b9,
+  handleAsync as bA,
+  addPendingSource as bB,
+  propagateStatus as bC,
+  forEachDependent as bD,
+  settlePendingSource as bE,
+  joinPassAt as bF,
+  notifyEpoch as bG,
+  SUPPORTS_PROXY as bH,
+  CONFIG_KEY_BAG as bI,
+  releaseMarksHook as bJ,
+  installMarkHooks as bK,
+  CONFIG_LAGS as bL,
+  REACTIVE_REASK as bM,
+  onSupersede as bN,
+  haltReactivity as bO,
+  CONFIG_FRAME as bP,
+  heldUnder as bQ,
+  unhold as bR,
+  laneStageHook as bS,
+  REACTIVE_ZOMBIE as bT,
+  installBoundaryHooks as bU,
+  CAUGHT_REARMED as bV,
+  OBSERVE as bW,
+  clearSnapshots as bX,
+  enforceLoadingBoundary as bY,
+  getNextChildId as bZ,
+  markSnapshotScope as b_,
+  untrack as ba,
+  dirtyQueue as bb,
+  CONFIG_REDERIVE as bc,
+  passTx as bd,
+  CONFIG_FRESH_READ as be,
+  createOwner as bf,
+  writeHook as bg,
+  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bh,
+  ownedScopeWriteMessage as bi,
+  isEqual as bj,
+  CONFIG_MANUAL_WRITE as bk,
+  snapshotCaptureActive as bl,
+  captureWriteSnapshot as bm,
+  notePromotedWrite as bn,
+  slotSignal as bo,
+  stagedScreen as bp,
+  CONFIG_PROMOTED as bq,
+  setSlotUnobserved as br,
+  installStoreHooks as bs,
+  joinPassTx as bt,
+  asyncTailFlights as bu,
+  untrackDepth as bv,
+  checkPostAwaitRead as bw,
+  disposalDepth as bx,
+  insertIntoHeap as by,
+  isDisposed as bz,
   CONFIG_OVERRIDE as c,
-  ownerPath as c0,
-  isSuppressed as c1,
-  blockersOf as c2,
-  CONFIG_PLUMBING as c3,
-  anyExcluded as c4,
-  isExcluded as c5,
-  CONFIG_WIDE as c6,
-  GRAPH_SIZE_WARN_AT as c7,
-  noteFanOut as c8,
-  CONFIG_SUPERSEDES as c9,
+  releaseSnapshotScope as c0,
+  resetErrorHalt as c1,
+  setConsoleFooter as c2,
+  setSnapshotCapture as c3,
+  setWriteHook as c4,
+  setAttributionHooks as c5,
+  liveRootOwners as c6,
+  ownerPath as c7,
+  isSuppressed as c8,
+  blockersOf as c9,
+  CONFIG_PLUMBING as ca,
+  anyExcluded as cb,
+  isExcluded as cc,
+  CONFIG_WIDE as cd,
+  GRAPH_SIZE_WARN_AT as ce,
+  noteFanOut as cf,
+  CONFIG_SUPERSEDES as cg,
   newTransaction as d,
   enqueueSub as e,
   CONFIG_VERDICT as f,