@solidjs/signals 2.0.0-rc.17 → 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,
@@ -64,123 +64,130 @@ import {
   a8 as link,
   a9 as pullComputed,
   aa as strictRead,
-  ab as warnStrictReadUntracked,
-  ac as staleReader,
-  ad as globalQueue,
-  ae as joinPass,
-  af as markLateLinker,
-  ag as spectating,
-  ah as unflushedValue,
-  ai as CONFIG_STAGED_ERROR,
-  aj as stagedReaders,
-  ak as bornInto,
-  al as enterAction,
-  am as setEffectCallback,
-  an as exitAction,
-  ao as isThenable,
-  ap as actionDepth,
-  aq as flush,
-  ar as setQuestion,
-  as as emitDiagnostic,
-  at as enterCallback,
-  au as exitCallback,
-  av as getOwner,
-  aw as inEffectCallback,
-  ax as setExternalHooks,
-  ay as signal,
-  az as setSignal,
-  aA as cleanup,
-  aB as read,
-  aC as DEV$1,
-  aD as CONFIG_TRANSPARENT,
-  aE as NoOwnerError,
-  aF as ContextNotFoundError,
-  aG as createEffectNode,
-  aH as recompute,
-  aI as EFFECT_USER,
-  aJ as reportDiagnostic,
-  aK as computed,
-  aL as staleValues,
-  aM as CONFIG_AUTO_DISPOSE,
-  aN as EFFECT_TRACKED,
-  aO as heldRunHook,
-  aP as unwrapStatusError,
-  aQ as haltReactivityAt,
-  aR as setStrictRead,
-  aS as StatusError,
-  aT as trimStaleDeps,
-  aU as setTrackedQueueCallback,
-  aV as setEffectStatusNotify,
-  aW as _hitUnhandledAsync,
-  aX as resetUnhandledAsync,
-  aY as ROOT_ERROR_HOOK,
-  aZ as registerGraph,
-  a_ as runWithOwner,
-  a$ as setMemo,
-  b0 as $REFRESH,
-  b1 as markRefresh,
-  b2 as createRoot,
-  b3 as getObserver,
-  b4 as dispose,
-  b5 as TimeoutError,
-  b6 as untrack,
-  b7 as dirtyQueue,
-  b8 as CONFIG_REDERIVE,
-  b9 as passTx,
-  ba as CONFIG_FRESH_READ,
-  bb as createOwner,
-  bc as writeHook,
-  bd as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
-  be as ownedScopeWriteMessage,
-  bf as isEqual,
-  bg as CONFIG_MANUAL_WRITE,
-  bh as snapshotCaptureActive,
-  bi as captureWriteSnapshot,
-  bj as notePromotedWrite,
-  bk as slotSignal,
-  bl as stagedScreen,
-  bm as CONFIG_PROMOTED,
-  bn as setSlotUnobserved,
-  bo as installStoreHooks,
-  bp as joinPassTx,
-  bq as asyncTailFlights,
-  br as untrackDepth,
-  bs as checkPostAwaitRead,
-  bt as disposalDepth,
-  bu as insertIntoHeap,
-  bv as isDisposed,
-  bw as handleAsync,
-  bx as addPendingSource,
-  by as propagateStatus,
-  bz as forEachDependent,
-  bA as settlePendingSource,
-  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
+  ab as strictReadActive,
+  ac as warnStrictReadUntracked,
+  ad as staleReader,
+  ae as globalQueue,
+  af as joinPass,
+  ag as markLateLinker,
+  ah as spectating,
+  ai as unflushedValue,
+  aj as CONFIG_STAGED_ERROR,
+  ak as stagedReaders,
+  al as bornInto,
+  am as enterAction,
+  an as setEffectCallback,
+  ao as exitAction,
+  ap as isThenable,
+  aq as actionDepth,
+  ar as flush,
+  as as setQuestion,
+  at as emitDiagnostic,
+  au as enterCallback,
+  av as exitCallback,
+  aw as getOwner,
+  ax as inEffectCallback,
+  ay as effectCallbackEvent,
+  az as setExternalHooks,
+  aA as signal,
+  aB as setSignal,
+  aC as cleanup,
+  aD as read,
+  aE as DEV$1,
+  aF as CONFIG_TRANSPARENT,
+  aG as NoOwnerError,
+  aH as ContextNotFoundError,
+  aI as createEffectNode,
+  aJ as recompute,
+  aK as EFFECT_USER,
+  aL as reportDiagnostic,
+  aM as computed,
+  aN as staleValues,
+  aO as CONFIG_AUTO_DISPOSE,
+  aP as EFFECT_TRACKED,
+  aQ as heldRunHook,
+  aR as unwrapStatusError,
+  aS as setStrictRead,
+  aT as queueEvent,
+  aU as StatusError,
+  aV as trimStaleDeps,
+  aW as haltReactivityAt,
+  aX as strictReadEvent,
+  aY as setTrackedQueueCallback,
+  aZ as setEffectStatusNotify,
+  a_ as _hitUnhandledAsync,
+  a$ as resetUnhandledAsync,
+  b0 as ROOT_ERROR_HOOK,
+  b1 as registerGraph,
+  b2 as runWithOwner,
+  b3 as setMemo,
+  b4 as $REFRESH,
+  b5 as markRefresh,
+  b6 as createRoot,
+  b7 as getObserver,
+  b8 as dispose,
+  b9 as TimeoutError,
+  ba as untrack,
+  bb as dirtyQueue,
+  bc as CONFIG_REDERIVE,
+  bd as passTx,
+  be as CONFIG_FRESH_READ,
+  bf as createOwner,
+  bg as writeHook,
+  bh as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
+  bi as ownedScopeWriteMessage,
+  bj as isEqual,
+  bk as CONFIG_MANUAL_WRITE,
+  bl as snapshotCaptureActive,
+  bm as captureWriteSnapshot,
+  bn as notePromotedWrite,
+  bo as slotSignal,
+  bp as stagedScreen,
+  bq as CONFIG_PROMOTED,
+  br as setSlotUnobserved,
+  bs as installStoreHooks,
+  bt as joinPassTx,
+  bu as asyncTailFlights,
+  bv as untrackDepth,
+  bw as checkPostAwaitRead,
+  bx as disposalDepth,
+  by as insertIntoHeap,
+  bz as isDisposed,
+  bA as handleAsync,
+  bB as addPendingSource,
+  bC as propagateStatus,
+  bD as forEachDependent,
+  bE as settlePendingSource,
+  bF as joinPassAt,
+  bG as notifyEpoch,
+  bH as SUPPORTS_PROXY,
+  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 {
-  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
+  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.
@@ -695,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);
@@ -713,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
@@ -721,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). */
@@ -987,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,
@@ -1350,7 +1379,7 @@ function verdictValue(el, c) {
   // verdict read as on any untracked read; the pending throw they add for a
   // plain read does not apply — a verdict read is a sanctioned read of a
   // pending node (an uninitialized one still throws NotReady below).
-  if (strictRead)
+  if (strictRead && strictReadActive())
     warnStrictReadUntracked(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
@@ -1505,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.)
  *
@@ -1583,21 +1620,23 @@ function action(genFn) {
         // it may have been called from — a root created in it (`until`,
         // `resolve`) is deliberate (PRIMITIVE_IN_EFFECT_CALLBACK is off).
         let effectCallback = false;
+        let effectEvent;
         {
           enterCallback();
           effectCallback = inEffectCallback;
+          effectEvent = effectCallbackEvent;
           setEffectCallback(false);
         }
         try {
           r = err ? it.throw(v) : it.next(v);
         } catch (e) {
           exitAction();
-          (exitCallback(), setEffectCallback(effectCallback));
+          (exitCallback(), setEffectCallback(effectCallback, effectEvent));
           if (attrHooks !== null) attrHooks.actionStepEnd(it);
           return done(undefined, e, true);
         }
         exitAction();
-        (exitCallback(), setEffectCallback(effectCallback));
+        (exitCallback(), setEffectCallback(effectCallback, effectEvent));
         if (attrHooks !== null) attrHooks.actionStepEnd(it);
         // A rejected iterator result (async generators) means the error already
         // escaped the generator body — it is completed, and throwing back in
@@ -1887,10 +1926,9 @@ function effect(compute, effect, error, options) {
     );
   }
 }
-function notifyEffectStatus(status, error) {
-  // Use passed values if provided, otherwise read from node
-  const actualStatus = status !== undefined ? status : this._statusFlags;
-  const actualError = error !== undefined ? error : this._x?._error;
+function notifyEffectStatus() {
+  const actualStatus = this._statusFlags;
+  const actualError = this._x?._error;
   if (actualStatus & STATUS_ERROR) {
     globalQueue.notify(this, STATUS_PENDING, 0);
     if (this._type === EFFECT_USER) {
@@ -1898,24 +1936,22 @@ function notifyEffectStatus(status, error) {
       // queue it like the effect function. It runs in the same imperative,
       // writable scope and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
       // and the runner dispatches on them, so a recovery before the effect
-      // phase takes the success arm instead. Blocked forwards (explicit
-      // `status` arg without node-state writes) don't queue: the status
-      // re-propagates unblocked at commit.
+      // phase takes the success arm instead. (Re-read: the boundary
+      // notify above can run a redraw.)
       if (this._statusFlags & STATUS_ERROR) {
         this._modified = true;
         globalQueue.enqueue(this._type, (this._boundRunEffect ??= runEffect.bind(null, this)));
       }
       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.
-      haltReactivityAt(
-        unwrapStatusError(actualError),
-        actualError instanceof StatusError ? actualError.source : this
-      );
-      throw actualError;
-    }
+    // Dev locates the halt at the node that threw: the StatusError's
+    // source, upstream of this effect when a computed failed.
+    escalate(
+      this,
+      unwrapStatusError(actualError),
+      actualError,
+      actualError instanceof StatusError ? actualError.source : this
+    );
   } else if (this._type === EFFECT_RENDER) {
     globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
     if (_hitUnhandledAsync && resetUnhandledAsync()) {
@@ -1944,6 +1980,14 @@ function notifyEffectStatus(status, error) {
     }
   }
 }
+/** An effect's error no boundary takes halts the system (boundary-or-halt):
+ * halted with `cause`, `thrown` rethrown; dev locates it at `subject`. */
+function escalate(node, cause, thrown = cause, subject = node) {
+  if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+    haltReactivityAt(cause, subject);
+    throw thrown;
+  }
+}
 function runEffect(node, type) {
   if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
   // A queued run behind a fallback (boundaries.ts) waits for the reveal: a
@@ -1978,10 +2022,7 @@ function runEffect(node, type) {
           })
         : console.error(err);
     } catch (error) {
-      if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-        haltReactivityAt(error, node);
-        throw error;
-      }
+      escalate(node, error);
     }
     return;
   }
@@ -1989,9 +2030,13 @@ function runEffect(node, type) {
   // the compute pass that produced `_value` was clean, so its tail still goes.
   const cleanPass = node._x?._error == null;
   let prevStrictRead = false;
+  let prevStrictReadEvent;
   {
-    prevStrictRead = setStrictRead("an effect callback");
-    setEffectCallback(true);
+    prevStrictReadEvent = strictReadEvent;
+    // A run outside a queue (a render effect's first run at creation) records
+    // no event: its callback is the compiler's DOM writes.
+    prevStrictRead = setStrictRead("an effect callback", queueEvent);
+    setEffectCallback(true, queueEvent);
     enterCallback();
   }
   // Observe tier, like its `effectRunEnd` twin below: the frame the engine
@@ -2014,13 +2059,10 @@ function runEffect(node, type) {
   } catch (error) {
     ext(node)._error = new StatusError(node, error);
     node._statusFlags |= STATUS_ERROR;
-    if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-      haltReactivityAt(error, node);
-      throw error;
-    }
+    escalate(node, error);
   } finally {
     {
-      setStrictRead(prevStrictRead);
+      setStrictRead(prevStrictRead, prevStrictReadEvent);
       setEffectCallback(false);
       exitCallback();
     }
@@ -2210,9 +2252,6 @@ function lookupTarget(raw, fam) {
   const owner = raw[$OWNER];
   return owner !== undefined && owner.fam === fam ? owner : (fam?.map ?? storeLookup).get(raw);
 }
-function devAssertNeverUserMutation(target) {
-  return;
-}
 /** Sticky descendants flag up the parent chain (§6d): adoption descends
  * into a changed child pair only where a target with nodes exists below. */
 function markDescendants(target) {
@@ -3086,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;
@@ -3714,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;
@@ -3835,7 +3936,7 @@ function wrap(value, parent = null, parentKey = null, fam = parent?.fam ?? null)
   const existing = lookupTarget(value, fam);
   if (existing !== undefined) return existing.px;
   const t = value[$TARGET];
-  if (t !== undefined && t.px === value) {
+  if (t?.px === value) {
     // Foreign-family proxies re-wrap into THIS family (writes stay isolated);
     // same-family and plain-store proxies pass through.
     if (fam === null || t.fam === fam) return value;
@@ -3907,7 +4008,7 @@ function asBacking(v) {
  * pending backing is never "equal" to the committed one); a lane value is
  * an arrangement (`LaneView`), judged by the optimistic machinery. */
 const containerEquals = function (a, b) {
-  return a === b || (optHooks !== null && optHooks.arrangement(this._host, a, b));
+  return a === b || !!optHooks?.arrangement(this._host, a, b);
 };
 function sameLogicalSlot(target, a, b) {
   if (a === null || typeof a !== "object" || b === null || typeof b !== "object") return false;
@@ -3924,10 +4025,10 @@ function releaseSlot(node) {
     if (t.k === node) t.k = null;
   } else if (key === $DEEP) {
     if (t.dk === node) t.dk = null;
-  } else if (t.n !== null && t.n[key] === node) {
+  } else if (t.n?.[key] === node) {
     delete t.n[key];
     t.nc--;
-  } else if (t.h !== null && t.h[key] === node) delete t.h[key];
+  } else if (t.h?.[key] === node) delete t.h[key];
   // The family's index keeps only targets that still carry a node.
   if (
     t.fam !== null &&
@@ -4008,12 +4109,7 @@ function getNode(
       accKnown === -1 ? isOwnAccessor(pb ?? target.v, key) : accKnown === 1
     ));
     if (pb !== null && !created.acc)
-      bornStaged(
-        target,
-        created,
-        target.del !== null && target.del.has(key) ? undefined : pb[key],
-        key
-      );
+      bornStaged(target, created, target.del?.has(key) ? undefined : pb[key], key);
     // Attribution-only: name store property nodes by path segment so
     // attribution chains and wide-scope warnings read "store.todos" (or
     // "todos.title" when the store was declared with a name), not
@@ -4038,8 +4134,7 @@ function getHasNode(target, key) {
   if (node === undefined) {
     const created = (node = slotSignal(key in committed(target), isEqual, target, key, false));
     const pb = target.pb;
-    if (pb !== null)
-      bornStaged(target, created, key in pb && !(target.del !== null && target.del.has(key)), key);
+    if (pb !== null) bornStaged(target, created, key in pb && !target.del?.has(key), key);
     if (attrHooks !== null) stampNodeOwner(created, target);
     nodes[key] = node;
     noteNode(target, created, key);
@@ -4213,7 +4308,7 @@ function scanAccessorsOnce(target) {
   const keys = Reflect.ownKeys(src);
   let plain = Object.getPrototypeOf(src) === Object.prototype;
   for (const key of keys) {
-    if (lookupGetter.call(src, key) !== undefined || lookupSetter.call(src, key) !== undefined) {
+    if (isOwnAccessor(src, key)) {
       target.a = true;
       plain = false;
       break;
@@ -4238,7 +4333,7 @@ const plainProto = o => {
  * container at flatten so its shape stays fast (#3689). */
 function overlayRebuilds(t, pb) {
   if (t.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
-  if (t.del !== null && t.del.size !== 0) return true;
+  if (t.del?.size) return true;
   const wk = t.wk;
   if (wk !== null && wk !== WK_ALL && wk.u === undefined && wk.size <= OVERLAY_REBUILD_MIN_ADDS)
     return false;
@@ -4252,18 +4347,14 @@ function overlayRebuilds(t, pb) {
 function materializePB(target) {
   const pb = target.pb;
   if (!target.ovl) return pb;
-  const clone = target.sc === 2 ? wideClone(target.v, target) : cloneRaw(target.v, target);
-  if (target.del !== null) {
-    for (const key of target.del) delete clone[key];
-    target.kc -= target.del.size;
-    target.del = null;
-  }
-  for (const key of Reflect.ownKeys(pb))
-    target.sc === 2 ? (clone[key] = pb[key]) : copyOwn(clone, pb, key);
+  const clone = overlayOnto(
+    target,
+    target.sc === 2 ? wideClone(target.v, target) : cloneRaw(target.v, target),
+    pb
+  );
   target.pb = clone;
-  target.ovl = false;
   // The staging IS the pending backing: re-point the container node.
-  if (target.k !== null && target.k._pendingValue === pb) target.k._pendingValue = clone;
+  if (target.k?._pendingValue === pb) target.k._pendingValue = clone;
   return clone;
 }
 /** The batch's pending backing, created on the first draft write: an overlay
@@ -4275,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
@@ -4315,7 +4406,6 @@ function privatizeCommitted(target) {
   target.ch = false;
   if (target.u) {
     privatizeCommitted(target.u);
-    devAssertNeverUserMutation(target.u.v);
     const pv = target.u.v;
     const slot = parentSlotKey(target, before);
     if (pv[slot] === before) pv[slot] = target.v;
@@ -4339,16 +4429,19 @@ function parentSlotKey(target, expected) {
  * place — the backing keeps its identity. */
 function flattenOverlay(t, pb) {
   privatizeCommitted(t);
-  const v = t.v;
-  for (const key of Reflect.ownKeys(pb)) t.sc === 2 ? (v[key] = pb[key]) : copyOwn(v, pb, key);
+  overlayOnto(t, t.v, pb); // the caller (`foldTarget`) closes the staging
+}
+/** An overlay's own keys and deletions onto `to` (the two are disjoint: a
+ * write un-deletes its key); the overlay is closed. */
+function overlayOnto(t, to, pb) {
+  for (const key of Reflect.ownKeys(pb)) t.sc === 2 ? (to[key] = pb[key]) : copyOwn(to, pb, key);
   if (t.del !== null) {
-    for (const key of t.del) delete v[key];
+    for (const key of t.del) delete to[key];
     t.kc -= t.del.size;
     t.del = null;
   }
-  t.pb = null;
   t.ovl = false;
-  t.wk = null; // written-keys window closes with the commit
+  return to;
 }
 /** Adoption (a setter's returned replacement; reconcile and projection
  * landings in S3): the incoming object becomes the backing by reference at
@@ -4387,7 +4480,7 @@ function adoptPB(target, incoming, notify = true) {
   target.a = false;
   target.wk = null; // adoption supersedes staged trap writes
   const owner = incoming[$OWNER];
-  if (owner !== undefined && owner.fam === target.fam) incoming[$OWNER] = target;
+  if (owner?.fam === target.fam) incoming[$OWNER] = target;
   else setLookup(incoming, target);
   if (notify && base !== incoming) notifyFold(target, base, incoming);
 }
@@ -4484,7 +4577,7 @@ function drainFolds() {
  * landing) read it. */
 GlobalQueue._slotFlight = n => {
   const fam = n._host?.fam;
-  return fam != null && fam.node !== null && (fam.node._statusFlags & STATUS_PENDING) !== 0;
+  return (fam?.node?._statusFlags & STATUS_PENDING) !== 0;
 };
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
  * A chained link's committed value is the inner store's at the last
@@ -4495,8 +4588,8 @@ GlobalQueue._slotCovered = n => {
   if (t.ch) {
     const key = n._key;
     const inner = t.v;
-    if (t.h !== null && t.h[key] === n) n._value = untrack(() => key in inner);
-    else if (t.n !== null && t.n[key] === n) n._value = untrack(() => unwrapValue(inner[key]));
+    if (t.h?.[key] === n) n._value = untrack(() => key in inner);
+    else if (t.n?.[key] === n) n._value = untrack(() => unwrapValue(inner[key]));
   }
   return n._value;
 };
@@ -4529,12 +4622,8 @@ function foldTarget(t, old) {
       const k = t.k;
       const pb = t.pb;
       if (pb !== null) {
-        if (pb === t.v) {
-          // An eager adoption nothing wrote after: the backing is already
-          // the adopted object (shared ownership — never cloned).
-          t.pb = null;
-          t.wk = null;
-        } else if (
+        if (pb === t.v);
+        else if (
           t.ovl &&
           (t.v !== old || (!overlayRebuilds(t, pb) && k?._x?._snapshotValue !== old))
         ) {
@@ -4557,26 +4646,19 @@ function foldTarget(t, old) {
                 else delete v[key];
               }
           } else {
-            for (const key of Reflect.ownKeys(pb)) {
-              const d = Object.getOwnPropertyDescriptor(pb, key);
-              if (d.get || d.set || !d.enumerable || !d.writable || !d.configurable)
-                Object.defineProperty(v, key, d);
-              else if (d.value !== old[key] || !hasOwn$1.call(old, key)) v[key] = d.value;
-            }
+            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];
             }
           }
-          t.pb = null;
-          t.wk = null;
         } else {
           // The clone (or adopted object) becomes the committed backing
           // (path copy below).
           t.v = t.ovl ? materializePB(t) : pb;
           t.ch = t.v[$TARGET] !== undefined;
-          t.pb = null;
-          t.wk = null;
         }
+        t.pb = null;
+        t.wk = null; // the written-keys window closes with the commit
       }
       if (k !== null) {
         // The node's committed value is the backing. A container nobody
@@ -4591,7 +4673,6 @@ function foldTarget(t, old) {
         const slot = parentSlotKey(t, old);
         if (t.u.v[slot] === old) {
           privatizeCommitted(t.u);
-          devAssertNeverUserMutation(t.u.v);
           t.u.v[slot] = t.v;
         }
       }
@@ -4617,9 +4698,12 @@ 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 !== null && t.del.has(key)) continue;
+    if (t.del?.has(key)) continue;
     const ov = unwrapValue(old[key]);
     const nv = unwrapValue(pb[key]);
     if (
@@ -4631,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;
@@ -4692,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;
@@ -4767,7 +4858,7 @@ function notifyWrites(t) {
         if (od?.get || od?.set || !isEqual(od?.value, nd.value)) setSignal(node, () => nd.value);
         continue;
       }
-      const nv = t.del !== null && t.del.has(key) ? undefined : pb[key];
+      const nv = t.del?.has(key) ? undefined : pb[key];
       setSignal(node, () => nv);
       if (t.fam !== null) {
         // The derive's write is a derivation; a user setter's is a proposal
@@ -4785,13 +4876,13 @@ function notifyWrites(t) {
     for (const key of keys) {
       const node = has[key];
       if (node !== undefined) {
-        setSignal(node, key in pb && !(t.del !== null && t.del.has(key)));
+        setSignal(node, key in pb && !t.del?.has(key));
         if (t.fam !== null) holdWithDerive(t, node);
       }
     }
   }
   if (t.dk !== null) {
-    if (t.del !== null && t.del.size !== 0) bumpDeep(t);
+    if (t.del?.size) bumpDeep(t);
     else
       for (const key of writtenKeys ?? Reflect.ownKeys(pb)) {
         if (key === $OWNER) continue;
@@ -4811,7 +4902,7 @@ function notifyWrites(t) {
   if (k !== null && (k._subs !== null || k._config & CONFIG_OVERRIDE)) {
     let changed;
     if (t.ovl) {
-      changed = t.del !== null && t.del.size !== 0;
+      changed = !!t.del?.size;
       if (!changed) {
         for (const key of Reflect.ownKeys(pb)) {
           if (!hasOwn$1.call(old, key)) {
@@ -4966,7 +5057,7 @@ function serveShallow(target, key, v) {
 function draftServe(target, proxy) {
   if (writeScopes !== null && inDraft(target)) {
     const ct = proxy?.[$TARGET];
-    if (ct !== undefined && ct.v !== undefined) writeScopes.add(scopeKey(ct));
+    if (ct?.v !== undefined) writeScopes.add(scopeKey(ct));
   }
   return proxy;
 }
@@ -5009,13 +5100,7 @@ function readSource(target, key, shape = false) {
   // sees — the lanes' values and the tick's own guesses over the truth
   // (#3665), never a staging awaiting its fold: the draft is born on the
   // read (and notified at the setter's exit like any).
-  if (
-    userWrite &&
-    target.fam !== null &&
-    target.fam.opt === true &&
-    !pendingNotify.has(target) &&
-    inDraft(target)
-  ) {
+  if (userWrite && target.fam?.opt === true && !pendingNotify.has(target) && inDraft(target)) {
     const draft = ensurePB(target);
     pendingNotify.add(target);
     return draft;
@@ -5054,7 +5139,7 @@ function readSource(target, key, shape = false) {
   // it).
   if (key !== undefined) {
     const leaf = target.n?.[key];
-    if (leaf !== undefined && leaf._config & CONFIG_OVERRIDE) return committed(target);
+    if (leaf?._config & CONFIG_OVERRIDE) return committed(target);
   }
   const held = k !== null && (k._config & CONFIG_HELD) !== 0;
   // A held container: the hold's unit is the key (#3706). A key the HELD
@@ -5168,18 +5253,14 @@ function adoptChild(target, key) {
   // A raw-marked value wraps to itself, a proxy to its own target: neither
   // is a fresh target around `ov`.
   const ct = wrap(ov, target, key)[$TARGET];
-  if (ct === undefined || ct.v !== ov) return false;
+  if (ct?.v !== ov) return false;
   adoptPB(ct, nv, false);
   holdNode(getContainerNode(ct), txOf(k));
   return true;
 }
 /** A family target's unheld staging, read with no pass (a handler). */
 function familyAhead(target) {
-  return (
-    target.fam !== null &&
-    context === null &&
-    !(target.k !== null && target.k._config & CONFIG_HELD)
-  );
+  return target.fam !== null && context === null && !(target.k?._config & CONFIG_HELD);
 }
 /** Did this batch change `key` — value (slot equality), presence, and (for
  * a `shape` reader — a descriptor read, a node's hold) enumerability or
@@ -5204,7 +5285,7 @@ function changedBetween(target, v, pb, key, shape) {
     !plainProto(v)
   )
     return true;
-  if (target.del !== null && target.del.has(key)) return key in v;
+  if (target.del?.has(key)) return key in v;
   const inNew = hasOwn$1.call(pb, key) || (target.ovl && hasOwn$1.call(target.v, key));
   if (inNew !== hasOwn$1.call(v, key)) return true;
   if (!inNew) return false;
@@ -5376,16 +5457,16 @@ 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
  * derive composes on the truth). */
 function optRead(target) {
-  return target.fam !== null && target.fam.opt === true && !inDraft(target) && !writeOverride;
+  return target.fam?.opt === true && !inDraft(target) && !writeOverride;
 }
 /** Pollution keys are never served from the prototype (core R30). */
 const UNSAFE_KEYS = new Set(["__proto__", "prototype", "constructor"]);
@@ -5511,7 +5592,7 @@ const traps = {
     const src = readSource(target, key);
     // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
     // deleted keys are tracked aside and read as absent in the pending view.
-    if (target.del !== null && src === target.pb && target.del.has(key)) {
+    if (src === target.pb && target.del?.has(key)) {
       if (!inDraft(target) && getObserver() !== null) read(getNode(target, key));
       return undefined;
     }
@@ -5539,7 +5620,8 @@ const traps = {
       !inDraft(target) &&
       typeof key === "string" &&
       key !== "then" &&
-      getObserver() === null
+      getObserver() === null &&
+      strictReadActive()
     ) {
       warnStrictReadUntracked(strictRead, {
         nodeName: key,
@@ -5638,12 +5720,12 @@ 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;
       }
     }
-    return key in src && !(target.del !== null && src === target.pb && target.del.has(key));
+    return key in src && !(src === target.pb && target.del?.has(key));
   },
   ownKeys(target) {
     if (verdict !== null && affectsHooks !== null && getObserver() === null)
@@ -5678,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;
@@ -5690,8 +5772,7 @@ const traps = {
   },
   set(target, key, value) {
     const draft = inDraft(target);
-    const override = !draft && writeOverride;
-    if (!draft && !override) {
+    if (!draft && !writeOverride) {
       warnWriteOutsideSetter(target, key, "set");
       return true;
     }
@@ -5717,17 +5798,8 @@ const traps = {
       touch(target, key);
       if (!(key in pb)) target.kc++;
     }
-    if (UNSAFE_KEYS.has(key)) {
-      Object.defineProperty(pb, key, {
-        value: uv,
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
-      if (target.del !== null) target.del.delete(key);
-      return true;
-    }
-    if (target.ovl && target.sc !== 2 && !hasOwn$1.call(pb, key)) {
+    const unsafe = UNSAFE_KEYS.has(key);
+    if (unsafe || (target.ovl && target.sc !== 2 && !hasOwn$1.call(pb, key))) {
       Object.defineProperty(pb, key, {
         value: uv,
         writable: true,
@@ -5735,15 +5807,15 @@ const traps = {
         configurable: true
       });
     } else pb[key] = uv;
-    if (target.del !== null) target.del.delete(key);
+    target.del?.delete(key);
+    if (unsafe) return true;
     if (target.s && uv !== null && typeof uv === "object") markRawOne(uv);
-    if (override) notifyWrites(target);
+    if (!draft) notifyWrites(target); // a write-override write
     return true;
   },
   defineProperty(target, key, desc) {
     const draft = inDraft(target);
-    const override = !draft && writeOverride;
-    if (!draft && !override) {
+    if (!draft && !writeOverride) {
       warnWriteOutsideSetter(target, key, "defineProperty");
       return true;
     }
@@ -5754,14 +5826,13 @@ const traps = {
     if (target.a || !(desc.enumerable && desc.writable && desc.configurable)) target.sc = 1;
     touch(target, key);
     Object.defineProperty(pb, key, desc);
-    if (target.del !== null) target.del.delete(key);
-    if (override) notifyWrites(target);
+    target.del?.delete(key);
+    if (!draft) notifyWrites(target); // a write-override write
     return true;
   },
   deleteProperty(target, key) {
     const draft = inDraft(target);
-    const override = !draft && writeOverride;
-    if (!draft && !override) {
+    if (!draft && !writeOverride) {
       warnWriteOutsideSetter(target, key, "deleteProperty");
       return true;
     }
@@ -5782,7 +5853,7 @@ const traps = {
       committed || target.kc--;
     }
     if (committed) (target.del ??= new Set()).add(key);
-    if (override) notifyWrites(target);
+    if (!draft) notifyWrites(target); // a write-override write
     return true;
   }
 };
@@ -5883,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));
   }
@@ -5943,17 +6014,17 @@ function createStore$1(initialValue, options) {
  * slot-patch channel (collected row bodies) over per-record registration. */
 function storeIsShallow(proxy) {
   const t = proxy?.[$TARGET];
-  return t !== undefined && t.s === true;
+  return t?.s === true;
 }
 /** True when `proxy` belongs to a projection family (S3). */
 function storeHasFamily(proxy) {
   const t = proxy?.[$TARGET];
-  return t !== undefined && t.fam !== null;
+  return t?.fam != null;
 }
 /** True when `proxy` belongs to an OPTIMISTIC family (S4). */
 function storeHasOptimisticFamily(proxy) {
   const t = proxy?.[$TARGET];
-  return t !== undefined && t.fam?.opt === true;
+  return t?.fam?.opt === true;
 }
 // ---------------------------------------------------------------------------
 // enumeration views (one visibility rule for the traps AND the deep walk)
@@ -5962,7 +6033,7 @@ function visibleKeys(target, src) {
   if (target.ovl && src === target.pb) {
     keys = Reflect.ownKeys(target.v);
     const del = target.del;
-    if (del !== null && del.size !== 0) keys = keys.filter(key => !del.has(key));
+    if (del?.size) keys = keys.filter(key => !del.has(key));
     for (const key of Reflect.ownKeys(src)) {
       if (!hasOwn$1.call(target.v, key)) keys.push(key);
     }
@@ -5979,7 +6050,7 @@ function visibleKeys(target, src) {
 function visibleDescriptor(target, src, key) {
   let desc = Object.getOwnPropertyDescriptor(src, key);
   if (target.ovl && src === target.pb) {
-    if (target.del !== null && target.del.has(key)) return undefined;
+    if (target.del?.has(key)) return undefined;
     if (desc === undefined) desc = Object.getOwnPropertyDescriptor(target.v, key);
   }
   return desc;
@@ -5990,7 +6061,7 @@ function visibleDescriptor(target, src, key) {
  * witness (one node per record, not one per path), then snapshots. */
 function deep$1(value) {
   const t0 = value?.[$TARGET];
-  if (t0 === undefined || t0.px !== value) return value;
+  if (t0?.px !== value) return value;
   const visited = new Set();
   const childTarget = (t, child, key) => {
     let ct = lookupTarget(child, t.fam);
@@ -6063,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;
   }
@@ -6232,14 +6303,14 @@ const storePath = /* @__PURE__ */ Object.assign(
  */
 function reconcileState(value, state, key, replace = false) {
   if (state == null) throw new Error("Cannot reconcile null or undefined state");
-  const t = state?.[$TARGET];
-  if (t === undefined || t.px !== state) throw new Error("reconcile target is not a store proxy");
+  const t = state[$TARGET];
+  if (t?.px !== state) throw new Error("reconcile target is not a store proxy");
   const keyFn = key === null ? null : typeof key === "string" ? item => item?.[key] : key;
   // A user's reconcile on an optimistic family (S4): not an adoption of
   // 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;
   }
@@ -6258,9 +6329,8 @@ function reconcileState(value, state, key, replace = false) {
       if (!replace) throw new Error("Cannot reconcile states with different identity");
       // A different entity at the root: the old backing is disowned (wraps
       // fresh if re-handed) and the new one adopted whole.
-      const out = t.pb ?? t.v;
-      if (isOwned(out)) delete out[$OWNER];
-      else (t.fam?.map ?? storeLookup).delete(out);
+      if (isOwned(prev)) delete prev[$OWNER];
+      else (t.fam?.map ?? storeLookup).delete(prev);
       adoptPB(t, incoming);
       return;
     }
@@ -6276,50 +6346,42 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   // as present through its prototype; materialized first — `adoptPB` does
   // so anyway, after the base was taken — so a deletion the draft made is
   // a deletion here (#3743: the presence and value diffs both read `old`).
-  const prev = t.ovl ? materializePB(t) : (t.pb ?? t.v);
-  if (incoming === prev && !isOwned(prev)) return;
-  const fam = t.fam;
+  const old = t.ovl ? materializePB(t) : (t.pb ?? t.v);
+  if (incoming === old && !isOwned(old)) return;
   // 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 = fam?.opt === true ? optHooks.view(t, prev) : prev;
+  const prevView = optHooks && t.fam?.opt === true ? optHooks.view(t, old) : old;
   const nextArr = Array.isArray(incoming);
   const shallow = t.s === true;
-  const old = prev;
   adoptPB(t, incoming, false);
   if (shallow) markRawIngest(incoming);
+  // The deep witness is bumped once per adoption (none to bump: done).
+  let bumped = t.dk === null;
   if (Array.isArray(prevView) !== nextArr) {
     notifyFold(t, old, incoming);
     return;
   }
   if (nextArr) {
-    const prevRows = prevView;
-    const nextRows = incoming;
     const nodes = t.n;
     let nodesHit = 0;
     if (keyFn && !shallow) {
-      const plen = prevRows.length;
-      const nlen = nextRows.length;
-      let dkBumpedA = false;
+      const plen = prevView.length;
+      const nlen = incoming.length;
       let i = 0;
       // Aligned prefix: same row (by reference or key) at the same index.
       for (const end = Math.min(plen, nlen); i < end; i++) {
-        const nv = nextRows[i];
-        const pvRaw = prevRows[i];
+        const nv = incoming[i];
+        const pvRaw = prevView[i];
         if (pvRaw !== nv && !sameRow$1(pvRaw, nv, keyFn)) break; // misaligned: fall to the keyed remainder below
+        if (nv !== null && typeof nv === "object" && (pvRaw !== nv || isOwned(nv)))
+          descend(unwrapValue(pvRaw), nv, keyFn, proj, t, i);
         if (
-          (pvRaw !== nv || (nv !== null && typeof nv === "object" && isOwned(nv))) &&
-          nv !== null &&
-          typeof nv === "object"
-        )
-          descend(unwrapValue(pvRaw), nv, keyFn, fam, proj);
-        if (
-          t.dk !== null &&
-          !dkBumpedA &&
+          !bumped &&
           !(nv !== null && typeof nv === "object" ? targetsEqual(pvRaw, nv) : isEqual(pvRaw, nv))
         ) {
           bumpDeep(t);
-          dkBumpedA = true;
+          bumped = true;
         }
         if (nodes !== null) {
           const node = nodes[i];
@@ -6329,19 +6391,19 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
           }
         }
       }
-      if (t.dk !== null && !dkBumpedA && i < nextRows.length) bumpDeep(t);
+      if (!bumped && i < incoming.length) bumpDeep(t);
       const structStart = i; // misalignment point (== nlen on aligned ticks)
       let prevByKey = null;
-      for (; i < nextRows.length; i++) {
-        const nv = nextRows[i];
+      for (; i < incoming.length; i++) {
+        const nv = incoming[i];
         if (nv !== null && typeof nv === "object") {
           const nk = keyFn(nv);
           let pv;
           if (nk !== undefined) {
             if (prevByKey === null) {
               prevByKey = new Map();
-              for (let j = structStart; j < prevRows.length; j++) {
-                const p = unwrapValue(prevRows[j]);
+              for (let j = structStart; j < prevView.length; j++) {
+                const p = unwrapValue(prevView[j]);
                 if (p !== null && typeof p === "object") {
                   const pk = keyFn(p);
                   if (pk === undefined) continue;
@@ -6355,16 +6417,16 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
             const m = prevByKey.get(nk);
             if (m === undefined) pv = undefined;
             else if (Array.isArray(m)) {
-              pv = unwrapValue(prevRows[m.shift()]);
+              pv = unwrapValue(prevView[m.shift()]);
               if (m.length === 1) prevByKey.set(nk, m[0]);
             } else {
-              pv = unwrapValue(prevRows[m]);
+              pv = unwrapValue(prevView[m]);
               prevByKey.delete(nk);
             }
           } else {
-            pv = unwrapValue(prevRows[i]); // keyless item: positional fallback
+            pv = unwrapValue(prevView[i]); // keyless item: positional fallback
           }
-          descend(pv, nv, keyFn, fam, proj);
+          descend(pv, nv, keyFn, proj, t, i);
         }
         if (nodes !== null) {
           const node = nodes[i];
@@ -6375,22 +6437,20 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
         }
       }
     } else {
-      const dlen = Math.min(prevRows.length, nextRows.length);
-      const nlen = nextRows.length;
-      let dkBumpedP = false;
+      const dlen = Math.min(prevView.length, incoming.length);
+      const nlen = incoming.length;
       for (let i = 0; i < nlen; i++) {
-        const nvP = nextRows[i];
+        const nvP = incoming[i];
         if (!shallow && i < dlen && nvP !== null && typeof nvP === "object")
-          descend(unwrapValue(prevRows[i]), nvP, keyFn, fam, proj);
+          descend(unwrapValue(prevView[i]), nvP, keyFn, proj, t, i);
         if (
-          t.dk !== null &&
-          !dkBumpedP &&
+          !bumped &&
           !(nvP !== null && typeof nvP === "object"
-            ? targetsEqual(prevRows[i], nvP)
-            : isEqual(prevRows[i], nvP))
+            ? targetsEqual(prevView[i], nvP)
+            : isEqual(prevView[i], nvP))
         ) {
           bumpDeep(t);
-          dkBumpedP = true;
+          bumped = true;
         }
         if (nodes !== null) {
           const node = nodes[i];
@@ -6405,7 +6465,7 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
     if (nodes !== null && nodesHit < t.nc) {
       for (const key of Reflect.ownKeys(nodes)) {
         const idx = typeof key === "string" ? +key : NaN;
-        if (!(idx >= 0 && idx < nextRows.length))
+        if (!(idx >= 0 && idx < incoming.length))
           notifyKeyDiff(nodes[key], key, old, incoming, false);
       }
     }
@@ -6414,7 +6474,6 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   }
   const nodes = t.n;
   let nodesHit = 0;
-  let dkBumped = false;
   for (const k in incoming) {
     const nv = incoming[k];
     const ov = old[k];
@@ -6424,13 +6483,13 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
       (!isObj || !isOwned(nv)) &&
       (nodes === null || nodes[k] === undefined || !hasAccessorFlag(nodes[k]))
     ) {
-      if (nodes !== null && nodes[k] !== undefined) nodesHit++;
+      if (nodes?.[k] !== undefined) nodesHit++;
       continue;
     }
-    if (isObj && !shallow) descend(unwrapValue(prevView[k]), nv, keyFn, fam, proj);
-    if (t.dk !== null && !dkBumped && !(isObj ? targetsEqual(ov, nv) : isEqual(ov, nv))) {
+    if (isObj && !shallow) descend(unwrapValue(prevView[k]), nv, keyFn, proj, t, k);
+    if (!bumped && !(isObj ? targetsEqual(ov, nv) : isEqual(ov, nv))) {
       bumpDeep(t);
-      dkBumped = true;
+      bumped = true;
     }
     if (nodes !== null) {
       const node = nodes[k];
@@ -6446,7 +6505,7 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
     if (k === $OWNER) continue;
     const nv = incoming[k];
     if (!shallow && nv !== null && typeof nv === "object")
-      descend(unwrapValue(old[k]), nv, keyFn, fam, proj);
+      descend(unwrapValue(old[k]), nv, keyFn, proj, t, k);
     if (nodes !== null) {
       const node = nodes[k];
       if (node !== undefined) {
@@ -6466,16 +6525,39 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
 const hasOwnP = Object.prototype.hasOwnProperty;
 /** Descend into a changed child pair — only where something is proxied
  * below (§6d), never into a raw-marked leaf, never across array/object or a
- * key mismatch (that is a replacement, handled by the parent's slot). */
-function descend(pv, nv, keyFn, fam, proj = false) {
-  if (pv === null || typeof pv !== "object" || nv === null || typeof nv !== "object") return;
-  const ct = lookupTarget(pv, fam);
+ * key mismatch (that is a replacement, handled by the parent's slot).
+ *
+ * A raw in both frames (the same objects swapped, reordered or shifted,
+ * #4001) must not leave two slots on one row. A raw already a live row keeps
+ * it at the slot it moved to; a row's `pk` follows the slot it sits at (a
+ * move or a pairing writes it), so a row whose raw is at that slot of the
+ * incoming frame is spoken for and not paired again here; a raw still
+ * resolving to a row that moved on drops the lookup (it wraps fresh, or is
+ * paired here). One lookup of `nv` on the common path, no allocation. */
+function descend(pv, nv, keyFn, proj, t, k) {
+  // `nv` is an object at every call site.
+  if (pv === null || typeof pv !== "object") return;
+  const fam = t.fam;
+  nv = unwrapValue(nv);
+  let ct = lookupTarget(pv, fam);
+  const nt = lookupTarget(nv, fam);
+  if (ct !== undefined && ct.pk !== k) {
+    if (ct.pk != k && t.v[ct.pk] === ct.v) ct = undefined;
+    else if (ct.u === t) ct.pk = k;
+  }
+  if (nt !== undefined && nt !== ct) {
+    if (nt.v === nv) {
+      if (nt.u === t) nt.pk = k;
+      return;
+    }
+    (fam?.map ?? storeLookup).delete(nv);
+  }
   if (ct === undefined) return; // nothing proxied below this pair
   if (!isWrappable(nv)) return;
   if (rawValuesUsed && isRawValue(nv)) return;
-  nv = unwrapValue(nv);
   if (Array.isArray(pv) !== Array.isArray(nv)) return;
-  if (keyFn) {
+  // An array slot was paired by key already (or both rows are keyless).
+  if (typeof k !== "number" && keyFn) {
     const pk = keyFn(pv);
     const nk = keyFn(nv);
     if (pk !== undefined && nk !== undefined && !sameKey(pk, nk)) return;
@@ -6585,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;
@@ -6624,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;
@@ -6710,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);
@@ -6725,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):
@@ -6738,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) {
@@ -6750,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.
@@ -8289,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;
     }
@@ -8596,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))
@@ -8904,46 +9002,282 @@ 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.
         if (open && e instanceof NotReadyError) ask(e);
+        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);
+    }, options)
+  );
+}
+
+// `from` — a push source (callback subscription, Observable, AsyncIterable)
+// as an AsyncIterable a computation can return or `for await` over:
+//
+//   const value = createMemo(() => from(source));
+//
+// A subscription keeps the latest value: values that arrive between pulls
+// coalesce. An AsyncIterable streams through unchanged. Either way the source
+// opens when the result is iterated and closes on return(), on supersede (the
+// owning computation re-runs) and on owner disposal, whichever comes first.
+function toSubscribe(source) {
+  if (typeof source === "function") return source;
+  // TC39 / RxJS interop: `Symbol.observable` (or "@@observable") returns the observable.
+  // Read per call, not at module scope, so the module stays side-effect free.
+  const $$observable = Symbol.observable;
+  const interop = ($$observable && source?.[$$observable]) ?? source?.["@@observable"];
+  const obs = typeof interop === "function" ? interop.call(source) : source;
+  if (obs && typeof obs.subscribe === "function")
+    return (next, error, complete) => obs.subscribe({ next, error, complete });
+  return null;
+}
+const DONE = { value: undefined, done: true };
+/**
+ * Ties an iterator's `finish` to the computation iterating it. Solid reaches
+ * an iterator's return() only when the compute returns the iterable directly.
+ * Inside an async generator the generator's own return() is queued behind its
+ * pending `await`, and owner cleanups wait for the replacing pass to commit,
+ * so close on supersede, with owner disposal as the backstop. No owner (an
+ * async compute iterating it after its first `await`, or plain iteration):
+ * no registration and no diagnostic, so only return() closes it. Scopes that
+ * forbid cleanups rely on supersede and return().
+ */
+function bindToOwner(finish) {
+  const owner = getOwner();
+  if (!owner) return;
+  onSupersede(finish);
+  if (!(owner._config & CONFIG_CHILDREN_FORBIDDEN)) cleanup(finish);
+}
+/**
+ * An AsyncIterable as a stream bound to the iterating computation: every
+ * value passes through (no coalescing). `finish` calls the inner return()
+ * once and settles pending pulls as done, so a `for await` over it exits as
+ * soon as the computation re-runs — even when the inner iterator is an async
+ * generator whose own return() the language queues behind its pending
+ * `await`.
+ */
+function wrapIterable(source) {
+  return {
+    [Symbol.asyncIterator]() {
+      const it = source[Symbol.asyncIterator]();
+      let closed = false;
+      const pending = new Set();
+      const finish = () => {
+        if (closed) return DONE;
+        closed = true;
+        for (const resolve of pending) resolve(DONE);
+        pending.clear();
+        try {
+          const returned = it.return?.();
+          if (isThenable(returned)) returned.then(undefined, () => {});
+        } catch {}
+        return DONE;
+      };
+      bindToOwner(finish);
+      return {
+        next(...args) {
+          if (closed) return Promise.resolve(DONE);
+          const step = it.next(...args);
+          // A bare result (the producer's buffered fast path) passes through.
+          if (!isThenable(step)) return step;
+          return new Promise((resolve, reject) => {
+            pending.add(resolve);
+            step.then(
+              r => pending.delete(resolve) && resolve(r),
+              e => pending.delete(resolve) && reject(e)
+            );
+          });
+        },
+        return() {
+          return Promise.resolve(finish());
         }
-        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), p.then(done, done));
-              return p;
-            },
-            return: v => it.return?.(v) ?? Promise.resolve({ done: true, value: v })
-          };
-          ask(s);
-          return serve({ [Symbol.asyncIterator]: () => s });
+      };
+    }
+  };
+}
+const toCleanup = t =>
+  typeof t === "function"
+    ? t
+    : t && typeof t.unsubscribe === "function"
+      ? () => t.unsubscribe()
+      : () => {};
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */
+function from(source) {
+  const subscribe = toSubscribe(source);
+  if (!subscribe) {
+    if (source && typeof source[Symbol.asyncIterator] === "function") return wrapIterable(source);
+    throw new TypeError("from(): expected a subscribe function, an Observable or an AsyncIterable");
+  }
+  return {
+    [Symbol.asyncIterator]() {
+      let latest;
+      let has = false;
+      let done = false;
+      let failed = false;
+      let failure;
+      let waiting = null;
+      let unsubscribe = null;
+      let closed = false;
+      const close = () => {
+        if (closed) return;
+        closed = true;
+        done = true;
+        const c = unsubscribe;
+        unsubscribe = null;
+        // A throwing unsubscribe must not escape: at supersede this runs
+        // inside flush(), ahead of the replacing pass (the returned-iterator
+        // path swallows it the same way).
+        try {
+          c?.();
+        } catch {}
+      };
+      const settle = () => {
+        if (!waiting) return;
+        const w = waiting;
+        if (has) {
+          waiting = null;
+          has = false;
+          w.resolve({ value: latest, done: false });
+        } else if (failed) {
+          waiting = null;
+          failed = false;
+          w.reject(failure);
+        } else if (done) {
+          waiting = null;
+          w.resolve({ value: undefined, done: true });
         }
+      };
+      const teardown = subscribe(
+        value => {
+          if (done) return;
+          latest = value;
+          has = true;
+          settle();
+        },
+        err => {
+          if (done) return;
+          failed = true;
+          failure = err;
+          done = true;
+          settle();
+          close();
+        },
+        () => {
+          if (done) return;
+          done = true;
+          settle();
+          close();
+        }
+      );
+      unsubscribe = toCleanup(teardown);
+      // Completed or errored during subscribe: release what it just returned.
+      if (closed) {
+        const c = unsubscribe;
+        unsubscribe = null;
+        try {
+          c();
+        } catch {}
       }
-      land(flight);
-      return r;
-    }, options)
-  );
+      // Idempotent: return(), supersede and disposal may all reach it.
+      const finish = () => {
+        close();
+        has = false;
+        if (waiting) {
+          const w = waiting;
+          waiting = null;
+          w.resolve(DONE);
+        }
+        return DONE;
+      };
+      bindToOwner(finish);
+      return {
+        next() {
+          // A buffered value is returned as a bare result, not a promise: the
+          // iterator consumer lands it in the same pass, so a source that
+          // emits during subscribe (BehaviorSubject-style) shows its value
+          // with no loading frame. `for await` accepts either form.
+          if (has) {
+            has = false;
+            return { value: latest, done: false };
+          }
+          if (failed) {
+            failed = false;
+            return Promise.reject(failure);
+          }
+          if (done) return Promise.resolve({ value: undefined, done: true });
+          return new Promise((resolve, reject) => {
+            waiting = { resolve, reject };
+          });
+        },
+        return() {
+          return Promise.resolve(finish());
+        }
+      };
+    }
+  };
 }
 
 // CARVE 4: `flatten` lived in boundaries.ts but is the general children
@@ -9062,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;
@@ -9099,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
@@ -9111,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))) {
@@ -9139,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;
   }
@@ -9273,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);
     }
   }
 }
@@ -9352,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
@@ -9431,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.
@@ -9470,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
@@ -9483,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;
@@ -9502,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);
@@ -9528,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 &&
@@ -9569,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);
@@ -9594,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);
 }
@@ -9962,6 +10318,7 @@ export {
   TimeoutError,
   action,
   affects,
+  clock,
   configureClientErrors,
   createContext,
   createDeferred,
@@ -9984,6 +10341,7 @@ export {
   enableExternalSource,
   flatten,
   flush,
+  from,
   getContext,
   getObserver,
   getOwner,
@@ -10002,6 +10360,7 @@ export {
   omit,
   omitView,
   onCleanup,
+  onFlush,
   onSettled,
   reconcile,
   refresh,