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

package/dist/dev.js

@@ -64,123 +64,128 @@ 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 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
 } 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
+  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
 } from "./dev-shared.js";
 
 // Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
@@ -1350,7 +1355,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,
@@ -1583,21 +1588,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 +1894,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 +1904,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 +1948,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 +1990,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 +1998,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 +2027,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 +2220,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) {
@@ -3835,7 +3842,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 +3914,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 +3931,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 +4015,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 +4040,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 +4214,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 +4239,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 +4253,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
@@ -4315,7 +4312,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 +4335,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 +4386,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 +4483,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 +4494,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 +4528,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 +4552,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)) copyOwn(v, pb, key);
             for (const key of Reflect.ownKeys(old)) {
               if (!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 +4579,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;
         }
       }
@@ -4619,7 +4606,7 @@ function reportReplacedContainers(t, old, pb, writtenKeys) {
   const owner = storeRootOwner(t);
   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 (
@@ -4767,7 +4754,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 +4772,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 +4798,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 +4953,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 +4996,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 +5035,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 +5149,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 +5181,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;
@@ -5385,7 +5362,7 @@ function enumerationSource(target) {
  * 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 +5488,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 +5516,8 @@ const traps = {
       !inDraft(target) &&
       typeof key === "string" &&
       key !== "then" &&
-      getObserver() === null
+      getObserver() === null &&
+      strictReadActive()
     ) {
       warnStrictReadUntracked(strictRead, {
         nodeName: key,
@@ -5643,7 +5621,7 @@ const traps = {
         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)
@@ -5690,8 +5668,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 +5694,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 +5703,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 +5722,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 +5749,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;
   }
 };
@@ -5943,17 +5910,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 +5929,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 +5946,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 +5957,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);
@@ -6232,8 +6199,8 @@ 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
@@ -6258,9 +6225,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 +6242,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 = 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 +6287,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 +6313,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 +6333,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 +6361,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 +6370,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 +6379,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 +6401,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 +6421,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;
@@ -8911,6 +8889,7 @@ function createDeferred(fn, options) {
         // 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) {
@@ -8931,7 +8910,11 @@ function createDeferred(fn, options) {
             // 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));
+              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 })
@@ -8946,6 +8929,238 @@ function createDeferred(fn, 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 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 {}
+      }
+      // 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
 // resolver the renderers (`web`, `universal`, `solid`'s `children()`) walk
 // through — not a boundary feature. Moved verbatim so the boundary carve
@@ -9984,6 +10199,7 @@ export {
   enableExternalSource,
   flatten,
   flush,
+  from,
   getContext,
   getObserver,
   getOwner,