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

package/dist/dev.js

@@ -33,8 +33,8 @@ import {
   A as tracking,
   B as CONFIG_CHILDREN_FORBIDDEN,
   D as passLane,
-  E as STATUS_PENDING,
-  F as EFFECT_RENDER,
+  E as EFFECT_RENDER,
+  F as setPassLane,
   H as sameLane,
   I as flushTransaction,
   J as REACTIVE_SCREEN_READ,
@@ -44,15 +44,15 @@ import {
   O as REACTIVE_IN_HEAP,
   P as REACTIVE_DIRTY,
   Q as REACTIVE_CHECK,
-  T as CONFIG_INPUTS_PUBLISHED,
-  U as releaseQueues,
-  V as CONFIG_SLOT_NODE,
-  W as holdNode,
-  X as joinFuture,
-  Y as reruns,
-  Z as CONFIG_STAGED,
-  _ as merge$1,
-  $ as setPassLane,
+  T as STATUS_PENDING,
+  U as CONFIG_INPUTS_PUBLISHED,
+  V as releaseQueues,
+  W as CONFIG_SLOT_NODE,
+  X as holdNode,
+  Y as joinFuture,
+  Z as reruns,
+  _ as CONFIG_STAGED,
+  $ as merge$1,
   a0 as REACTIVE_JOINED,
   a1 as REACTIVE_STAGED_READ,
   a2 as stagedRead,
@@ -161,31 +161,33 @@ import {
   bF as joinPassAt,
   bG as notifyEpoch,
   bH as SUPPORTS_PROXY,
-  bI as releaseMarksHook,
-  bJ as installMarkHooks,
-  bK as CONFIG_LAGS,
-  bL as REACTIVE_REASK,
-  bM as onSupersede,
-  bN as haltReactivity,
-  bO as heldUnder,
-  bP as unhold,
-  bQ as laneStageHook,
-  bR as REACTIVE_ZOMBIE,
-  bS as installBoundaryHooks,
-  bT as CAUGHT_REARMED,
-  bU as OBSERVE$1
+  bI as CONFIG_KEY_BAG,
+  bJ as releaseMarksHook,
+  bK as installMarkHooks,
+  bL as CONFIG_LAGS,
+  bM as REACTIVE_REASK,
+  bN as onSupersede,
+  bO as haltReactivity,
+  bP as CONFIG_FRAME,
+  bQ as heldUnder,
+  bR as unhold,
+  bS as laneStageHook,
+  bT as REACTIVE_ZOMBIE,
+  bU as installBoundaryHooks,
+  bV as CAUGHT_REARMED,
+  bW as OBSERVE$1
 } from "./dev-shared.js";
 export {
-  bV as clearSnapshots,
-  bW as enforceLoadingBoundary,
-  bX as getNextChildId,
-  bY as markSnapshotScope,
-  bZ as peekNextChildId,
-  b_ as releaseSnapshotScope,
-  b$ as resetErrorHalt,
-  c0 as setConsoleFooter,
-  c1 as setSnapshotCapture,
-  c2 as setWriteHook
+  bX as clearSnapshots,
+  bY as enforceLoadingBoundary,
+  bZ as getNextChildId,
+  b_ as markSnapshotScope,
+  b$ as peekNextChildId,
+  c0 as releaseSnapshotScope,
+  c1 as resetErrorHalt,
+  c2 as setConsoleFooter,
+  c3 as setSnapshotCapture,
+  c4 as setWriteHook
 } from "./dev-shared.js";
 
 // Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
@@ -700,7 +702,11 @@ function dissolveLane(l, into, except) {
  * has shown, or one the seam has not judged yet (its run waits on the
  * verdict: released if the lane shows, held if it blocks) — and sees the
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
- * member throws like any. */
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */
 function laneRead(c, el) {
   const guess = el._config & CONFIG_GUESS;
   const l = txOf(el);
@@ -718,6 +724,7 @@ function laneRead(c, el) {
   // 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 pending = !guess && status & STATUS_PENDING;
   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
@@ -726,40 +733,47 @@ function laneRead(c, el) {
     // lanes read by one pass link, as for tracked reads). Outside lane
     // work, the screen.
     if (passLane === null || c._config & CONFIG_CHILDREN_FORBIDDEN) return display(el);
-    enterLane(l, c);
-    if (!guess && status & STATUS_PENDING) return NOT_PENDING;
-    return laneValueOf(el);
-  }
-  if (c._type === EFFECT_RENDER && (passLane === null || !sameLane(passLane, l))) {
-    if (!guess) {
-      // 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 (status & STATUS_PENDING && el._x._lane === NOT_PENDING) return NOT_PENDING;
+  } else if (c._type === EFFECT_RENDER) {
+    // 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.
+    const never = pending && el._x._lane === NOT_PENDING;
+    // D-28: a leaf a verdict read moved into the lane still throws on such
+    // a flight — the pass leaves the lane, and its frame holds as if the
+    // read had come first (S-39, #4275). Nor does a verdict lane's seat carry
+    // the leaf into another lane (no link): it reads that lane as from the
+    // frame's seat (#4284).
+    if ((never || passLane !== l) && passLane?._parent._verdict === passLane) setPassLane(null);
+    if (passLane === null || !sameLane(passLane, l)) {
+      // (A lane that has never shown: the screen is the committed value.)
+      if (never && l._shown) return NOT_PENDING;
       if (
+        !guess &&
         el._pendingValue !== NOT_PENDING &&
         c._config & CONFIG_HELD &&
         flushTransaction !== null &&
         resolveTx(flushTransaction) === txOf(c)
       )
         return el._pendingValue;
-    }
-    if (l._held || (!guess && status & STATUS_PENDING)) {
-      if (!guess && !l._shown && status & 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 (!(c._flags & REACTIVE_SCREEN_READ)) {
-        c._flags |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
-        l._reruns.push(c);
+      if (l._held || pending) {
+        if (!guess && !l._shown && status & 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 (!(c._flags & REACTIVE_SCREEN_READ)) {
+          c._flags |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
+          l._reruns.push(c);
+        }
+        return display(el);
       }
-      return display(el);
+      // A verdict reader reads ahead of the seam's verdict: re-derived on the
+      // screen if the lane holds (#4284).
+      if (c._config & CONFIG_VERDICT && l._parent._verdict !== l) entered.push(c);
     }
   }
   enterLane(l, c);
-  if (!guess && status & STATUS_PENDING) return NOT_PENDING;
-  return laneValueOf(el);
+  return pending ? NOT_PENDING : laneValueOf(el);
 }
 /** The value a guess covered: the node's committed value — a store slot's
  * asked of the store (a chained link follows the inner store's commits). */
@@ -992,7 +1006,17 @@ const laneSeams = leaks => {
     }
   for (let k = Math.min(judged, lanes.length) - 1; k >= 0; k--)
     laneSeam(lanes[k], leaked.indexOf(lanes[k]) !== -1);
+  // A verdict reader that entered a lane this seam held: its run waits with
+  // the lane, and the verdict beside it would freeze — it re-derives next
+  // round from the frame's seat, a stale reader of the lane (#4284).
+  for (let r; (r = entered.pop()); )
+    if (r._x._transaction?._held) {
+      r._flags &= ~REACTIVE_LANE_DIRTY;
+      enqueueSub(r);
+    }
 };
+/** Render effects that read a verdict and entered a lane before its seam (#4284). */
+const entered = [];
 installLaneHooks(
   laneRead,
   laneStage,
@@ -1510,6 +1534,14 @@ function inTransaction(t, q, fn) {
  * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
+ * The same holds inside an async helper the action yields
+ * (`yield (async () => { ... })()`): everything after its first `await` runs
+ * outside the transaction. An `await refresh(x)` or `await until(...)` there
+ * waits for this action's commit, which waits on the helper, so it hangs
+ * whenever `x` re-ran during the action (#4263) and works otherwise. Call
+ * `refresh(x)` in the generator once the helper returns; `yield` it only when
+ * the action needs the fresh value.
+ *
  * (For the same reason, don't call `flush()` inside an action body — it
  * cannot reveal the held writes and is refused.)
  *
@@ -3093,6 +3125,65 @@ function onSettled(callback) {
         }
       });
 }
+/**
+ * Schedules `callback` to run **once**, right after the pending flush
+ * finishes, in the same microtask checkpoint (before the browser paints).
+ * Unlike `onSettled`, it never waits on async work: if that flush is held by
+ * a pending transition, the callback still runs.
+ *
+ * Its main use is keeping a write out of another update's hold. Writes made
+ * in the same synchronous frame are applied together, so when one of them
+ * starts async work (a route change, a fetch), the others are held with it
+ * until it resolves. A write made in `onFlush` happens after that flush, so
+ * it is its own update: it commits on its own unless something it changes
+ * also derives from the held work (a memo or `createEffect` reading both),
+ * in which case it joins that hold as any later write would.
+ *
+ * Call it from event handlers and effect callbacks (including
+ * `createTrackedEffect` and `onSettled` bodies). In an owned scope such as a
+ * component body or a computation it warns in dev: use `onSettled` there.
+ *
+ * - A write in the callback lands after any write made inline in the same
+ *   frame. Don't write the same signal both inside and outside it; use a
+ *   functional setter if the order matters.
+ * - Several `onFlush` callbacks run in call order and batch into one flush.
+ * - `queueMicrotask` is not a substitute: called before the frame's first
+ *   write, it runs before that flush and its write joins it.
+ *
+ * @example
+ * ```tsx
+ * // A menu closes now even when the consumer's onSelect starts async work.
+ * const select = (id: string) => {
+ *   onFlush(() => setOpen(false));
+ *   props.onSelect?.(id);
+ * };
+ * ```
+ *
+ * @param callback Function to run once after the pending flush
+ */
+function onFlush(callback) {
+  {
+    const owner = getOwner();
+    if (owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)) {
+      const message =
+        "[ON_FLUSH_IN_OWNED_SCOPE] onFlush called in an owned scope (a component body or a computation). It is meant for event handlers and effect callbacks; to run work after this scope's first stable render, use onSettled.";
+      reportDiagnostic(
+        emitDiagnostic({
+          code: "ON_FLUSH_IN_OWNED_SCOPE",
+          kind: "lifecycle",
+          severity: "warn",
+          message,
+          ownerId: owner.id,
+          ownerName: owner._name
+        })
+      );
+    }
+  }
+  // The frame's flush is queued (or already draining) ahead of this
+  // microtask, so the callback's writes start a flush of their own.
+  schedule();
+  queueMicrotask(callback);
+}
 
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : undefined;
@@ -3721,6 +3812,9 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
+// Set before any family is optimistic (`fam.opt`): a call site checks the
+// hooks first, so a build that does not import optimistic.ts folds the arm
+// away.
 let optHooks = null;
 function installOptHooks(hooks) {
   optHooks = hooks;
@@ -4272,7 +4366,7 @@ function ensurePB(target) {
   // An optimistic edit composes on the view the user saw and becomes
   // guesses at the setter's exit: nothing is staged, nothing folds
   // (optimistic.ts).
-  if (userWrite && target.fam?.opt === true && !pendingNotify.has(target))
+  if (optHooks && userWrite && target.fam?.opt === true && !pendingNotify.has(target))
     return (target.pb = optHooks.draft(target));
   if (pb !== null && !isOwned(pb)) {
     // An adopted object awaiting its fold is the user's: the draft writes a
@@ -4552,9 +4646,9 @@ function foldTarget(t, old) {
                 else delete v[key];
               }
           } else {
-            for (const key of Reflect.ownKeys(pb)) copyOwn(v, pb, key);
+            for (const key of Reflect.ownKeys(pb)) if (key !== $OWNER) copyOwn(v, pb, key);
             for (const key of Reflect.ownKeys(old)) {
-              if (!hasOwn$1.call(pb, key)) delete v[key];
+              if (key !== $OWNER && !hasOwn$1.call(pb, key)) delete v[key];
             }
           }
         } else {
@@ -4604,6 +4698,9 @@ function reportReplacedContainers(t, old, pb, writtenKeys) {
   const keys = writtenKeys ?? Reflect.ownKeys(pb);
   const isArray = Array.isArray(pb);
   const owner = storeRootOwner(t);
+  // Items the array held before the write: an index that now holds one of
+  // them was moved into place (an in-place splice / shift), not replaced.
+  let oldArrayItems = null;
   for (const key of keys) {
     if ((isArray && key === "length") || key === $OWNER) continue;
     if (t.del?.has(key)) continue;
@@ -4618,6 +4715,13 @@ function reportReplacedContainers(t, old, pb, writtenKeys) {
       targetsEqual(ov, nv)
     )
       continue;
+    if (isArray) {
+      if (oldArrayItems === null) {
+        oldArrayItems = new Set();
+        for (const item of old) oldArrayItems.add(unwrapValue(item));
+      }
+      if (oldArrayItems.has(nv)) continue;
+    }
     const isArr = Array.isArray(nv);
     if (isArr !== Array.isArray(ov)) continue;
     let total;
@@ -4679,7 +4783,7 @@ function notifyWrites(t) {
   // Optimistic channel: a user's writes on an optimistic family become
   // guesses on the nodes (lanes); the draft is discarded, the committed
   // backing never touched.
-  if (userWrite && t.fam?.opt === true) {
+  if (optHooks && userWrite && t.fam?.opt === true) {
     // The draft is discarded first: the diff reads the target (its nodes
     // are born from the committed frame, not the draft).
     t.pb = null;
@@ -5353,10 +5457,10 @@ function enumerationSource(target) {
     // A container's arrangement guess is not a backing: the view composes
     // over the base it is shown over.
     const base = asBacking(read(getContainerNode(target)));
-    return target.fam?.opt === true ? optHooks.view(target, base) : base;
+    return optHooks && target.fam?.opt === true ? optHooks.view(target, base) : base;
   }
   const src = readSource(target);
-  return optRead(target) ? optHooks.view(target, src) : src;
+  return optHooks && optRead(target) ? optHooks.view(target, src) : src;
 }
 /** A read on an optimistic family that composes the lanes' values: not the
  * draft's (it composed already), not a derive's write-override read (the
@@ -5616,7 +5720,7 @@ const traps = {
         node._value = present; // the link follows the inner store (S4)
         if (node._config & CONFIG_OVERRIDE) return !!nv;
         return present;
-      } else if (optRead(target)) {
+      } else if (optHooks && optRead(target)) {
         const guessed = optHooks.has(target, key);
         if (guessed !== undefined) return guessed;
       }
@@ -5656,7 +5760,7 @@ const traps = {
         return undefined;
     } else src = readSource(target, key, true);
     let desc;
-    if (!enumerating && optRead(target)) {
+    if (optHooks && !enumerating && optRead(target)) {
       const guessed = optHooks.descriptor(target, key);
       if (guessed === null) return undefined;
       desc = guessed;
@@ -5850,7 +5954,7 @@ function storeSetter(proxy, fn, guard = true) {
     // A returned replacement: on an optimistic family a user's is itself an
     // optimistic edit — diffed against the view as guesses (`next` parity);
     // otherwise it is adopted as the incoming truth.
-    if (guard && target.fam?.opt === true && !writeOverride)
+    if (optHooks && guard && target.fam?.opt === true && !writeOverride)
       optHooks.writes(target, unwrapValue(result));
     else adoptPB(target, unwrapValue(result));
   }
@@ -6030,7 +6134,7 @@ function snapshotWalk(value, seen, fam) {
       if (t.ovl) materializePB(t);
       backing = t.pb;
     }
-    if (optRead(t)) backing = optHooks.view(t, backing);
+    if (optHooks && optRead(t)) backing = optHooks.view(t, backing);
     if (backing === src) break;
     src = backing;
   }
@@ -6206,7 +6310,7 @@ function reconcileState(value, state, key, replace = false) {
   // truth but an optimistic edit — the keyed diff is written into the draft
   // (a matched row keeps its proxy, its changed leaves become its guesses),
   // and the setter's exit turns the draft into guesses like any.
-  if (userWriting() && t.fam?.opt === true) {
+  if (optHooks && userWriting() && t.fam?.opt === true) {
     optHooks.reconcile(state, unwrapValue(value), keyFn);
     return;
   }
@@ -6247,7 +6351,7 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   // Q-D: a landing on an optimistic family is reconciled against the VIEW
   // — key matching from the arrangement the guesses made (R28), so a row
   // the guess added keeps its proxy when the server returns it.
-  const prevView = t.fam?.opt === true ? optHooks.view(t, old) : old;
+  const prevView = optHooks && t.fam?.opt === true ? optHooks.view(t, old) : old;
   const nextArr = Array.isArray(incoming);
   const shallow = t.s === true;
   adoptPB(t, incoming, false);
@@ -6563,8 +6667,14 @@ function cloneState(v, shallow) {
  * pending derivatively on the derive (its readers hold; it re-runs at the
  * landing). The leaves do not subscribe to the derive, so the family does
  * the walk. */
-function wakeFamily(fam, error) {
+function wakeFamily(fam) {
   const fw = fam.node;
+  // Pending on the derive itself, whatever source took it there (an upstream
+  // memo's flight reaches it as a NotReady of that memo, #4271): the leaves
+  // are not that source's dependents, so only the family's settle — which
+  // retires the derive (`settleFamily`) — reaches the readers parked here. A
+  // reader the landing leaves unchanged does not re-run to clear it (#4305).
+  const error = new NotReadyError(fw);
   fam.woke = true;
   forEachFamilyNode(fam, n => {
     if (n._subs === null) return;
@@ -6602,6 +6712,13 @@ function settleFamily(fam) {
     if (n._subs !== null) settlePendingSource(n, fw);
   });
 }
+/** A source's status reached the derive by propagation (core
+ * `propagateStatus`), its pass not re-run: the family learns it as from the
+ * pass's own throw. */
+function familyStatus(status) {
+  if (status & STATUS_PENDING) wakeFamily(this);
+  else if (status & STATUS_ERROR) errorFamily(this);
+}
 function forEachFamilyNode(fam, fn) {
   for (const t of fam.live) {
     const nodes = t.n;
@@ -6688,7 +6805,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
           // #2897) — and the flush that runs them advances the clock, so a
           // later tracked re-read may retry (core `read`).
           if (first && owner._statusFlags & STATUS_UNINITIALIZED) return;
-          if (pending) wakeFamily(fam, error);
+          if (pending) wakeFamily(fam);
           else errorFamily(fam);
         });
         if (!owner._loading) commit(sync);
@@ -6703,7 +6820,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
     // they do not subscribe to the derive.
     // A synchronous error the same way (#3956: a rerun that finds the
     // entry failed throws): every live reader re-derives and meets it.
-    if (!first) e instanceof NotReadyError ? wakeFamily(fam, e) : errorFamily(fam);
+    if (!first) e instanceof NotReadyError ? wakeFamily(fam) : errorFamily(fam);
     throw e;
   }
   // A pass that returned with a flight up (an iterator's sync first yield):
@@ -6716,7 +6833,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
     !owner._loading &&
     !first
   )
-    wakeFamily(fam, owner._x?._error);
+    wakeFamily(fam);
   return owner;
 }
 function createProjectionInternal(fn, seed, options) {
@@ -6728,6 +6845,7 @@ function createProjectionInternal(fn, seed, options) {
     map: new WeakMap(),
     node: null,
     live: new Set(),
+    st: familyStatus,
     shallow: !!options?.shallow,
     // The row key, for a child paired after the adoption (store.ts
     // `adoptChild`, #3712) as the adoption pairs them.
@@ -8267,7 +8385,9 @@ function merge(...sources) {
     count++;
     only = s;
     if (typeof s === "function") {
-      flattened[n] = createMemo(s);
+      // Observe tiers name it and exempt it from UNSTABLE_MEMO_OUTPUT (see
+      // CONFIG_KEY_BAG); prod passes no options.
+      flattened[n] = createMemo(s, { name: "merge", _extraConfig: CONFIG_KEY_BAG });
       kinds[n++] = SOURCE_MEMO;
       continue;
     }
@@ -8574,7 +8694,7 @@ function walk(value, entry, found, fam, visited) {
   if (t !== undefined) {
     if (t.pb !== null) entry._scope.add(t.v);
     // The writer's view: the tick's own unflushed guesses are in motion too.
-    if (t.fam?.opt === true) raw = optHooks.view(t, raw, true);
+    if (optHooks && t.fam?.opt === true) raw = optHooks.view(t, raw, true);
     const nodes = t.n;
     if (nodes !== null)
       for (const k of Reflect.ownKeys(nodes))
@@ -8882,9 +9002,41 @@ function createDeferred(fn, options) {
       // Sticky, and read before this wrapper ever opens the window itself.
       const open = (answered ||= !(node._statusFlags & STATUS_UNINITIALIZED) && !node._loading);
       if (open) ((node._loading = true), (node._config |= CONFIG_LAGS));
-      let r;
       try {
-        r = fn(prev);
+        const r = fn(prev);
+        if (open && typeof r === "object" && r !== null) {
+          if (isThenable(r)) {
+            ask(r);
+            const done = () => land(r, true);
+            r.then(done, done);
+            return serve(r);
+          }
+          const iterate = r[Symbol.asyncIterator];
+          if (iterate) {
+            // A stream's flight ends at its first yield (or its end).
+            const it = iterate.call(r);
+            let first = true;
+            const done = () => land(s, true);
+            const s = {
+              // Registered ahead of the engine's own reaction to the same
+              // promise, as for a plain flight: verdict and value in one flush.
+              next: v => {
+                const p = it.next(v);
+                if (first) {
+                  first = false;
+                  if (isThenable(p)) p.then(done, done);
+                  else done();
+                }
+                return p;
+              },
+              return: v => it.return?.(v) ?? Promise.resolve({ done: true, value: v })
+            };
+            ask(s);
+            return serve({ [Symbol.asyncIterator]: () => s });
+          }
+        }
+        land(flight);
+        return r;
       } catch (e) {
         // The wrapping form: an unready source parks the node in the window,
         // and the wait is its flight until the source's settle re-runs it.
@@ -8892,39 +9044,6 @@ function createDeferred(fn, options) {
         else land(flight);
         throw e;
       }
-      if (open && typeof r === "object" && r !== null) {
-        if (isThenable(r)) {
-          ask(r);
-          const done = () => land(r, true);
-          r.then(done, done);
-          return serve(r);
-        }
-        const iterate = r[Symbol.asyncIterator];
-        if (iterate) {
-          // A stream's flight ends at its first yield (or its end).
-          const it = iterate.call(r);
-          let first = true;
-          const done = () => land(s, true);
-          const s = {
-            // Registered ahead of the engine's own reaction to the same
-            // promise, as for a plain flight: verdict and value in one flush.
-            next: v => {
-              const p = it.next(v);
-              if (first) {
-                first = false;
-                if (isThenable(p)) p.then(done, done);
-                else done();
-              }
-              return p;
-            },
-            return: v => it.return?.(v) ?? Promise.resolve({ done: true, value: v })
-          };
-          ask(s);
-          return serve({ [Symbol.asyncIterator]: () => s });
-        }
-      }
-      land(flight);
-      return r;
     }, options)
   );
 }
@@ -9277,6 +9396,9 @@ const BOUNDARY = Symbol("boundary");
  * slot of (reveal.ts); a boundary clears it for its content — only direct
  * children are slots. */
 const REVEAL = Symbol("reveal");
+// Every call site checks the hooks themselves first (not only the slot or
+// controller, which are never set without them): a build that does not
+// import `createRevealOrder` folds the reveal-order arms away.
 let revealHooks = null;
 function setRevealHooks(h) {
   revealHooks = h;
@@ -9314,7 +9436,7 @@ function caught(b, node, error) {
   // nothing on screen. The fallback is instantiated once per show — a later
   // error reaches it through the `error` accessor, which is why it is one.
   if (!b._fallback) redraw(b);
-  if (b._reveal !== null) revealHooks._changed(b._reveal);
+  if (revealHooks && b._reveal !== null) revealHooks._changed(b._reveal);
 }
 /** A re-armed boundary found something pending: fresh again, and the swap
  * the arming pass asked for is that pass's lane's (if any): the output is
@@ -9326,7 +9448,8 @@ function flip(b) {
   b._lane = b._armLane;
   const o = b._output;
   if (!b._lane && o._config & CONFIG_HELD && txOf(o) !== flushTransaction) unhold(o);
-  if (b._lane !== null && b._output !== null) laneStageHook(b._output, b._lane, true, false);
+  if (laneStageHook && b._lane !== null && b._output !== null)
+    laneStageHook(b._output, b._lane, true, false);
 }
 function redraw(b) {
   if (b._output !== null && !(b._output._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
@@ -9354,7 +9477,7 @@ function catchStatus(node, flags, error) {
           b._readers.size === 0
         ) {
           if (b._fallback) redraw(b);
-          if (b._reveal !== null) revealHooks._changed(b._reveal);
+          if (revealHooks && b._reveal !== null) revealHooks._changed(b._reveal);
         }
     return false;
   }
@@ -9488,7 +9611,7 @@ function boundarySeam() {
     if (b._readers.size === 0) {
       collecting.delete(b);
       if (b._fallback) redraw(b);
-      if (b._reveal !== null) revealHooks._changed(b._reveal);
+      if (revealHooks && b._reveal !== null) revealHooks._changed(b._reveal);
     }
   }
 }
@@ -9567,6 +9690,8 @@ function arm(b) {
     return;
   }
   b._armed = true;
+  // The swap is the change's work: the output joins it (D-13, #3540).
+  b._output._config &= ~CONFIG_FRAME;
   // A verdict read in `on` (`isPending`, or a memo of one — #3528's
   // `createMemo(() => isPending(m2))`: the mark carries, core.ts `read`)
   // whose frame has no transaction yet: the swap is still display-ahead — the frame gets one now (it lands
@@ -9646,7 +9771,7 @@ function createBoundary(type, fn, show, onFn) {
   if (getOwner())
     cleanup(() => {
       collecting.delete(b);
-      if (controller) revealHooks._unregister(controller, b);
+      if (revealHooks && controller) revealHooks._unregister(controller, b);
     });
   // The `on` dependencies live OUTSIDE the boundary, as the condition of a
   // `<Show>` wrapping it would: created before the owner's context names it.
@@ -9685,9 +9810,16 @@ function createBoundary(type, fn, show, onFn) {
   b._tree = tree;
   // A slot of the reveal order in its context (reveal.ts): gated until the
   // controller releases it — before the output's first pass.
-  if (controller) revealHooks._register(controller, b);
+  if (revealHooks && controller) revealHooks._register(controller, b);
   const output = computed(
     () => {
+      // Structure, not a derivation of its content (CONFIG_FRAME, #4283): it
+      // reads a hold it is not part of as the screen, as the render effect
+      // flattening the same children without a boundary would. Not while a
+      // re-arm's swap is the change's work (`arm`), until that swap commits
+      // (D-13, #3540).
+      const self = getOwner();
+      if (!b._armed && !(self._config & CONFIG_HELD)) self._config |= CONFIG_FRAME;
       // Reveal order (reveal.ts): a gated slot shows its fallback — or, in a
       // collapsed tail, nothing — whatever its content's state; the
       // controller is told the pass ran (its readiness may have changed) and
@@ -9698,8 +9830,8 @@ function createBoundary(type, fn, show, onFn) {
         // It may release this very slot (the frontier whose content just
         // settled): the pass goes on to show it — the redraw it asks for is
         // refused mid-pass and not needed.
-        link(tree, getOwner());
-        if (b._reveal !== null) revealHooks._changed(b._reveal);
+        link(tree, self);
+        if (revealHooks && b._reveal !== null) revealHooks._changed(b._reveal);
         if (b._gated) {
           if (b._collapsed) {
             b._fallback = true;
@@ -9717,7 +9849,7 @@ function createBoundary(type, fn, show, onFn) {
       // once clean.
       const status = tree._statusFlags & (STATUS_PENDING | STATUS_ERROR);
       if (status !== 0) {
-        link(tree, getOwner());
+        link(tree, self);
         if (status & type) {
           if (isCollecting(b)) {
             caught(b, tree, undefined);
@@ -9743,7 +9875,6 @@ function createBoundary(type, fn, show, onFn) {
         // enters: the outside sees its committed value until the landing,
         // which reveals the content — a fallback staged earlier is replaced
         // ahead of the commit and never shown.
-        const self = getOwner();
         if (
           b._readers.size !== 0 &&
           self._statusFlags & STATUS_UNINITIALIZED &&
@@ -9784,19 +9915,27 @@ function createBoundary(type, fn, show, onFn) {
       // landing when the frame parks (the run is held with it, as the old
       // children of a held pass are) — not now: a held swap keeps the
       // fallback on screen, live, until it commits. A pass back to the
-      // fallback before then finds it still built and keeps it.
+      // fallback before then finds it still built and keeps it. A fallback
+      // the screen does not show (a swap staged with a held frame, replaced
+      // before it commits) dies now: what it reads holds nothing (S-22 row
+      // 3′, #4268).
       const fb = b._fb;
+      const drop = () => {
+        if (!b._fallback && b._fb === fb) {
+          // A fallback that threw (a rethrow the boundary does not
+          // handle) is what an enclosing boundary waits on: it died, and
+          // the seam of another round drops it there (#4270).
+          if (fb._statusFlags & STATUS_ERROR) schedule();
+          dispose(fb);
+          b._fb = null;
+        }
+      };
       if (fb !== null)
-        globalQueue.enqueue(EFFECT_RENDER, () => {
-          if (!b._fallback && b._fb === fb) {
-            dispose(fb);
-            b._fb = null;
-          }
-        });
+        b._output._value !== fb._value ? drop() : globalQueue.enqueue(EFFECT_RENDER, drop);
       release(b);
       // Shown: the slot leaves its reveal order (a later re-arm gates nobody
       // else; the frontier moves on).
-      if (b._reveal !== null) {
+      if (revealHooks && b._reveal !== null) {
         const controller = b._reveal;
         b._reveal = null;
         revealHooks._changed(controller);
@@ -9809,6 +9948,8 @@ function createBoundary(type, fn, show, onFn) {
     { name: "value", _noSnapshot: true }
   );
   output._config |= CONFIG_REDERIVE;
+  // The tree is structure too (the output's pass marks the output).
+  tree._config |= CONFIG_FRAME;
   b._output = output;
   return accessor(output);
 }
@@ -10177,6 +10318,7 @@ export {
   TimeoutError,
   action,
   affects,
+  clock,
   configureClientErrors,
   createContext,
   createDeferred,
@@ -10218,6 +10360,7 @@ export {
   omit,
   omitView,
   onCleanup,
+  onFlush,
   onSettled,
   reconcile,
   refresh,