@solidjs/signals 0.11.3 → 0.13.0

package/dist/dev.js

@@ -151,6 +151,14 @@ let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
+let _enforceLoadingBoundary = false;
+let _hitUnhandledAsync = false;
+function resetUnhandledAsync() {
+  _hitUnhandledAsync = false;
+}
+function enforceLoadingBoundary(enabled) {
+  _enforceLoadingBoundary = enabled;
+}
 function runLaneEffects(type) {
   for (const lane of activeLanes) {
     if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
@@ -167,7 +175,7 @@ function setProjectionWriteActive(value) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue._running) queueMicrotask(flush);
+  if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
 class Queue {
   _parent = null;
@@ -297,6 +305,7 @@ class GlobalQueue extends Queue {
           activeTransition._asyncNodes.push(actualError.source);
           schedule();
         }
+        if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
       }
       return true;
     }
@@ -380,35 +389,40 @@ function insertSubs(node, optimistic = false) {
     insertIntoHeap(s._sub, queue);
   }
 }
+function commitPendingNodes() {
+  const pendingNodes = globalQueue._pendingNodes;
+  for (let i = 0; i < pendingNodes.length; i++) {
+    const n = pendingNodes[i];
+    if (n._pendingValue !== NOT_PENDING) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
+      if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
+    }
+    if (!(n._statusFlags & STATUS_PENDING)) n._statusFlags &= ~STATUS_UNINITIALIZED;
+    if (n._fn) GlobalQueue._dispose(n, false, true);
+  }
+  pendingNodes.length = 0;
+}
 function finalizePureQueue(completingTransition = null, incomplete = false) {
   let resolvePending = !incomplete;
+  if (resolvePending) commitPendingNodes();
   if (!incomplete) checkBoundaryChildren(globalQueue);
   if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
-    const pendingNodes = globalQueue._pendingNodes;
-    for (let i = 0; i < pendingNodes.length; i++) {
-      const n = pendingNodes[i];
-      if (n._pendingValue !== NOT_PENDING) {
-        n._value = n._pendingValue;
-        n._pendingValue = NOT_PENDING;
-        if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
-      }
-      if (!(n._statusFlags & STATUS_PENDING)) n._statusFlags &= ~STATUS_UNINITIALIZED;
-      if (n._fn) GlobalQueue._dispose(n, false, true);
-    }
-    pendingNodes.length = 0;
+    commitPendingNodes();
     const optimisticNodes = completingTransition
       ? completingTransition._optimisticNodes
       : globalQueue._optimisticNodes;
     for (let i = 0; i < optimisticNodes.length; i++) {
       const n = optimisticNodes[i];
-      const original = n._pendingValue;
       n._optimisticLane = undefined;
-      if (original !== NOT_PENDING && n._value !== original) {
-        n._value = original;
-        insertSubs(n, true);
+      if (n._pendingValue !== NOT_PENDING) {
+        n._value = n._pendingValue;
+        n._pendingValue = NOT_PENDING;
       }
-      n._pendingValue = NOT_PENDING;
+      const prevOverride = n._overrideValue;
+      n._overrideValue = NOT_PENDING;
+      if (prevOverride !== NOT_PENDING && n._value !== prevOverride) insertSubs(n, true);
       n._transition = null;
     }
     optimisticNodes.length = 0;
@@ -515,7 +529,7 @@ function getOrCreateLane(signal) {
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
-  signal._laneVersion = signal._overrideVersion || 0;
+  signal._overrideSinceLane = false;
   return lane;
 }
 function findLane(lane) {
@@ -541,7 +555,7 @@ function resolveLane(el) {
   return undefined;
 }
 function hasActiveOverride(el) {
-  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
+  return !!(el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING);
 }
 function assignOrMergeLane(el, sourceLane) {
   const sourceRoot = findLane(sourceLane);
@@ -588,10 +602,10 @@ function handleAsync(el, result, setter) {
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
     if (setter) setter(value);
-    else if (el._optimistic) {
-      const hadOverride = el._pendingValue !== NOT_PENDING;
-      if (el._fn) el._pendingValue = value;
-      if (!hadOverride) {
+    else if (el._overrideValue !== undefined) {
+      if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
+        el._pendingValue = value;
+      else {
         el._value = value;
         insertSubs(el);
       }
@@ -647,6 +661,10 @@ function handleAsync(el, result, setter) {
             syncResult = r;
             resolved = true;
           } else if (!r.done) asyncWrite(r.value, iterate);
+          else {
+            schedule();
+            flush();
+          }
         },
         e => {
           if (!isSync) handleError(e);
@@ -682,7 +700,8 @@ function notifyStatus(el, status, error, blockStatus, lane) {
   )
     error = new StatusError(el, error);
   const isSource = error instanceof NotReadyError && error.source === el;
-  const isOptimisticBoundary = status === STATUS_PENDING && el._optimistic && !isSource;
+  const isOptimisticBoundary =
+    status === STATUS_PENDING && el._overrideValue !== undefined && !isSource;
   const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
   if (!blockStatus) {
     el._statusFlags =
@@ -833,7 +852,6 @@ function disposeChildren(node, self = false, zombie) {
     node._pendingFirstChild = null;
   } else {
     node._firstChild = null;
-    node._nextSibling = null;
     node._childCount = 0;
   }
   runDisposal(node, zombie);
@@ -967,8 +985,14 @@ function effect(compute, effect, error, initialValue, options) {
         }
       }
       if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-    } else if (node._type === EFFECT_RENDER)
+    } else if (node._type === EFFECT_RENDER) {
       node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
+      if (_hitUnhandledAsync) {
+        resetUnhandledAsync();
+        const err = new Error("An async value must be rendered inside a Loading boundary.");
+        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+      }
+    }
   };
   recompute(node, true);
   !options?.defer &&
@@ -982,6 +1006,10 @@ function effect(compute, effect, error, initialValue, options) {
 }
 function runEffect() {
   if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
+  let prevStrictRead = false;
+  {
+    prevStrictRead = setStrictRead("an effect callback");
+  }
   this._cleanup?.();
   this._cleanup = undefined;
   try {
@@ -989,6 +1017,7 @@ function runEffect() {
   } catch (error) {
     if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
   } finally {
+    setStrictRead(prevStrictRead);
     this._prevValue = this._value;
     this._modified = false;
   }
@@ -1022,6 +1051,29 @@ function trackedEffect(fn, options) {
   if (!node._parent)
     console.warn("Effects created outside a reactive context will never be disposed");
 }
+let externalSourceConfig = null;
+function enableExternalSource(config) {
+  const { factory: factory, untrack: untrackFn = fn => fn() } = config;
+  if (externalSourceConfig) {
+    const { factory: oldFactory, untrack: oldUntrack } = externalSourceConfig;
+    externalSourceConfig = {
+      factory: (fn, trigger) => {
+        const oldSource = oldFactory(fn, trigger);
+        const source = factory(x => oldSource.track(x), trigger);
+        return {
+          track: x => source.track(x),
+          dispose() {
+            source.dispose();
+            oldSource.dispose();
+          }
+        };
+      },
+      untrack: fn => oldUntrack(() => untrackFn(fn))
+    };
+  } else {
+    externalSourceConfig = { factory: factory, untrack: untrackFn };
+  }
+}
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
 let tracking = false;
@@ -1101,7 +1153,7 @@ function recompute(el, create = false) {
     }
   }
   const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
-  const hasOverride = hasActiveOverride(el);
+  const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
   const oldcontext = context;
   context = el;
@@ -1163,24 +1215,24 @@ function recompute(el, create = false) {
       else el._deps = null;
     }
     const compareValue = hasOverride
-      ? el._value
+      ? el._overrideValue
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
     const valueChanged = !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
-      const prevVisible = hasOverride ? el._value : undefined;
-      if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty)
+      const prevVisible = hasOverride ? el._overrideValue : undefined;
+      if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
         el._value = value;
-      else el._pendingValue = value;
-      if (hasOverride && !isOptimisticDirty && wasPending) {
-        const ov = el._overrideVersion || 0;
-        const lv = el._laneVersion || 0;
-        if (ov <= lv) el._value = value;
-      }
-      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
+        if (hasOverride && isOptimisticDirty) {
+          el._overrideValue = value;
+          el._pendingValue = value;
+        }
+      } else el._pendingValue = value;
+      if (hasOverride && !isOptimisticDirty && wasPending && !el._overrideSinceLane)
+        el._overrideValue = value;
+      if (!hasOverride || isOptimisticDirty || el._overrideValue !== prevVisible)
         insertSubs(el, isOptimisticDirty || hasOverride);
-      }
     } else if (hasOverride) {
       el._pendingValue = value;
     } else if (el._height != oldHeight) {
@@ -1192,7 +1244,7 @@ function recompute(el, create = false) {
   currentOptimisticLane = prevLane;
   (!create || el._statusFlags & STATUS_PENDING) &&
     !el._transition &&
-    !(activeTransition && el._optimistic) &&
+    !(activeTransition && hasOverride) &&
     globalQueue._pendingNodes.push(el);
   el._transition &&
     isEffect &&
@@ -1212,7 +1264,10 @@ function updateIfNecessary(el) {
       }
     }
   }
-  if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (el._error && el._time < clock)) {
+  if (
+    el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) ||
+    (el._error && el._time < clock && !el._inFlight)
+  ) {
     recompute(el);
   }
   el._flags = REACTIVE_NONE | (el._flags & REACTIVE_SNAPSHOT_STALE);
@@ -1270,6 +1325,17 @@ function computed(fn, initialValue, options) {
   }
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
+  if (externalSourceConfig) {
+    const bridgeSignal = signal(undefined, { equals: false, pureWrite: true });
+    const source = externalSourceConfig.factory(self._fn, () => {
+      setSignal(bridgeSignal, undefined);
+    });
+    onCleanup(() => source.dispose());
+    self._fn = prev => {
+      read(bridgeSignal);
+      return source.track(prev);
+    };
+  }
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
     if (!(self._statusFlags & STATUS_PENDING)) {
@@ -1294,7 +1360,7 @@ function signal(v, options, firewall = null) {
   };
   s._name = options?.name ?? "signal";
   firewall && (firewall._child = s);
-  if (snapshotCaptureActive && !s._pureWrite) {
+  if (snapshotCaptureActive && !s._pureWrite && !((firewall?._statusFlags ?? 0) & STATUS_PENDING)) {
     s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
     snapshotSources.add(s);
   }
@@ -1302,12 +1368,12 @@ function signal(v, options, firewall = null) {
 }
 function optimisticSignal(v, options) {
   const s = signal(v, options);
-  s._optimistic = true;
+  s._overrideValue = NOT_PENDING;
   return s;
 }
 function optimisticComputed(fn, initialValue, options) {
   const c = computed(fn, initialValue, options);
-  c._optimistic = true;
+  c._overrideValue = NOT_PENDING;
   return c;
 }
 function isEqual(a, b) {
@@ -1319,23 +1385,18 @@ function setStrictRead(v) {
   strictRead = v;
   return prev;
 }
-function untrack(fn) {
-  if (!tracking && !strictRead) return fn();
+function untrack(fn, strictReadLabel) {
+  if (!externalSourceConfig && !tracking && !strictRead && !strictReadLabel) return fn();
+  const prevTracking = tracking;
+  const prevStrictRead = strictRead;
   tracking = false;
-  if (strictRead) {
-    const prev = strictRead;
-    strictRead = false;
-    try {
-      return fn();
-    } finally {
-      tracking = true;
-      strictRead = prev;
-    }
-  }
+  strictRead = strictReadLabel || false;
   try {
+    if (externalSourceConfig) return externalSourceConfig.untrack(fn);
     return fn();
   } finally {
-    tracking = true;
+    tracking = prevTracking;
+    strictRead = prevStrictRead;
   }
 }
 function read(el) {
@@ -1343,21 +1404,25 @@ function read(el) {
     const pendingComputed = getLatestValueComputed(el);
     const prevPending = latestReadActive;
     latestReadActive = false;
+    const visibleValue =
+      el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING
+        ? el._overrideValue
+        : el._value;
     let value;
     try {
       value = read(pendingComputed);
     } catch (e) {
-      if (!context && e instanceof NotReadyError) return el._value;
+      if (!context && e instanceof NotReadyError) return visibleValue;
       throw e;
     } finally {
       latestReadActive = prevPending;
     }
-    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
+    if (pendingComputed._statusFlags & STATUS_PENDING) return visibleValue;
     if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
       const pcLane = findLane(pendingComputed._optimisticLane);
       const curLane = findLane(currentOptimisticLane);
       if (pcLane !== curLane && pcLane._pendingAsync.size > 0) {
-        return el._value;
+        return visibleValue;
       }
     }
     return value;
@@ -1383,8 +1448,8 @@ function read(el) {
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
     throw new Error(
-      `Reading a pending async value in ${strictRead}. ` +
-        `Async values must be read within a tracking scope (JSX, computations, effects).`
+      `Reading a pending async value directly in ${strictRead}. ` +
+        `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`
     );
   }
   if (c && tracking) {
@@ -1409,11 +1474,11 @@ function read(el) {
         const pendingLane = owner._optimisticLane;
         const lane = findLane(currentOptimisticLane);
         if (pendingLane && findLane(pendingLane) === lane && !hasActiveOverride(owner)) {
-          if (!tracking) link(el, c);
+          if (!tracking && el !== c) link(el, c);
           throw owner._error;
         }
       } else {
-        if (!tracking) link(el, c);
+        if (!tracking && el !== c) link(el, c);
         throw owner._error;
       }
     } else if (!c && owner._statusFlags & STATUS_UNINITIALIZED) {
@@ -1435,13 +1500,19 @@ function read(el) {
       return snapshot;
     }
   }
-  if (strictRead && !tracking)
+  if (strictRead)
     console.warn(
-      `Reactive value read at the top level of ${strictRead} will not update. ` +
-        `Move it into a tracking scope (JSX, computations, effects).`
+      `Reactive value read directly in ${strictRead} will not update. ` +
+        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
     );
+  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
+    return el._overrideValue;
   return !c ||
-    currentOptimisticLane !== null ||
+    (currentOptimisticLane !== null &&
+      (el._overrideValue !== undefined ||
+        el._optimisticLane ||
+        owner === el ||
+        !!(owner._statusFlags & STATUS_PENDING))) ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
     ? el._value
@@ -1452,9 +1523,12 @@ function setSignal(el, v) {
     console.warn("A Signal was written to in an owned scope.");
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
-  const isOptimistic = el._optimistic && !projectionWriteActive;
+  const isOptimistic = el._overrideValue !== undefined && !projectionWriteActive;
+  const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
   const currentValue = isOptimistic
-    ? el._value
+    ? hasOverride
+      ? el._overrideValue
+      : el._value
     : el._pendingValue === NOT_PENDING
       ? el._value
       : el._pendingValue;
@@ -1462,27 +1536,23 @@ function setSignal(el, v) {
   const valueChanged =
     !el._equals || !el._equals(currentValue, v) || !!(el._statusFlags & STATUS_UNINITIALIZED);
   if (!valueChanged) {
-    if (isOptimistic && el._pendingValue !== NOT_PENDING && el._fn) {
+    if (isOptimistic && hasOverride && el._fn) {
       insertSubs(el, true);
       schedule();
     }
     return v;
   }
   if (isOptimistic) {
-    const alreadyTracked = globalQueue._optimisticNodes.includes(el);
-    if (el._transition && alreadyTracked) {
-      globalQueue.initTransition(el._transition);
-    }
-    if (el._pendingValue === NOT_PENDING) {
+    const firstOverride = el._overrideValue === NOT_PENDING;
+    if (!firstOverride && el._transition) globalQueue.initTransition(el._transition);
+    if (firstOverride) {
       el._pendingValue = el._value;
-    }
-    if (!alreadyTracked) {
       globalQueue._optimisticNodes.push(el);
     }
-    el._overrideVersion = (el._overrideVersion || 0) + 1;
+    el._overrideSinceLane = true;
     const lane = getOrCreateLane(el);
     el._optimisticLane = lane;
-    el._value = v;
+    el._overrideValue = v;
   } else {
     if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
     el._pendingValue = v;
@@ -1520,7 +1590,7 @@ function getPendingSignal(el) {
 }
 function computePendingState(el) {
   const comp = el;
-  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
       return true;
     if (el._parentSource) {
@@ -1690,17 +1760,22 @@ function action(genFn) {
       step();
     });
 }
+function accessor(node) {
+  const fn = read.bind(null, node);
+  fn.$r = true;
+  return fn;
+}
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node = computed(first, second, third);
-    return [read.bind(null, node), setSignal.bind(null, node)];
+    return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
-  return [read.bind(null, node), setSignal.bind(null, node)];
+  return [accessor(node), setSignal.bind(null, node)];
 }
 function createMemo(compute, value, options) {
   let node = computed(compute, value, options);
-  return read.bind(null, node);
+  return accessor(node);
 }
 function createEffect(compute, effectFn, value, options) {
   effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
@@ -1757,7 +1832,7 @@ function createOptimistic(first, second, third) {
     typeof first === "function"
       ? optimisticComputed(first, second, third)
       : optimisticSignal(first, second);
-  return [read.bind(null, node), setSignal.bind(null, node)];
+  return [accessor(node), setSignal.bind(null, node)];
 }
 function onSettled(callback) {
   getOwner()
@@ -1779,7 +1854,7 @@ function getAllKeys(value, override, next) {
   const nextKeys = Object.keys(next);
   return Array.from(new Set([...keys, ...nextKeys]));
 }
-function applyState(next, state, keyFn, all) {
+function applyState(next, state, keyFn) {
   const target = state?.[$TARGET];
   if (!target) return;
   const previous = target[STORE_VALUE];
@@ -1802,7 +1877,7 @@ function applyState(next, state, keyFn, all) {
           (item && next[start] && keyFn(item) === keyFn(next[start])));
         start++
       ) {
-        applyState(next[start], wrap(item, target), keyFn, all);
+        applyState(next[start], wrap(item, target), keyFn);
       }
       const temp = new Array(next.length),
         newIndices = new Map();
@@ -1825,7 +1900,7 @@ function applyState(next, state, keyFn, all) {
           changed = true;
           const wrapped = wrap(temp[j], target);
           target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn, all);
+          applyState(next[j], wrapped, keyFn);
         }
         changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
         prevLength !== next.length &&
@@ -1855,7 +1930,7 @@ function applyState(next, state, keyFn, all) {
         if (j in temp) {
           const wrapped = wrap(temp[j], target);
           target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn, all);
+          applyState(next[j], wrapped, keyFn);
         } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
       }
       if (start < next.length) changed = true;
@@ -1863,7 +1938,7 @@ function applyState(next, state, keyFn, all) {
       for (let i = 0, len = next.length; i < len; i++) {
         const item = getOverrideValue(previous, override, nodes, i, optOverride);
         isWrappable(item)
-          ? applyState(next[i], wrap(item, target), keyFn, all)
+          ? applyState(next[i], wrap(item, target), keyFn)
           : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
       }
     }
@@ -1876,7 +1951,7 @@ function applyState(next, state, keyFn, all) {
   }
   if (nodes) {
     const tracked = nodes[$TRACK];
-    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
+    const keys = tracked ? getAllKeys(previous, override, next) : Object.keys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const node = nodes[key];
@@ -1891,7 +1966,7 @@ function applyState(next, state, keyFn, all) {
       ) {
         tracked && setSignal(tracked, void 0);
         node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else applyState(nextValue, wrap(previousValue, target), keyFn, all);
+      } else applyState(nextValue, wrap(previousValue, target), keyFn);
     }
   }
   if ((nodes = target[STORE_HAS])) {
@@ -1902,14 +1977,14 @@ function applyState(next, state, keyFn, all) {
     }
   }
 }
-function reconcile(value, key, all = false) {
+function reconcile(value, key) {
   return state => {
     if (state == null) throw new Error("Cannot reconcile null or undefined state");
     const keyFn = typeof key === "string" ? item => item[key] : key;
     const eq = keyFn(state);
     if (eq !== undefined && keyFn(value) !== keyFn(state))
       throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn, all);
+    applyState(value, state, keyFn);
   };
 }
 function createProjectionInternal(fn, initialValue = {}, options) {
@@ -1939,12 +2014,9 @@ function createProjectionInternal(fn, initialValue = {}, options) {
       const value = handleAsync(owner, fn(s), value => {
         value !== s &&
           value !== undefined &&
-          storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
-        setSignal(owner, undefined);
+          storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
       });
-      value !== s &&
-        value !== undefined &&
-        reconcile(value, options?.key || "id", options?.all)(wrappedStore);
+      value !== s && value !== undefined && reconcile(value, options?.key || "id")(wrappedStore);
     });
   });
   node._preventAutoDisposal = true;
@@ -1990,11 +2062,9 @@ const writeTraps = {
   }
 };
 const $TRACK = Symbol("STORE_TRACK"),
-  $DEEP = Symbol("STORE_DEEP"),
   $TARGET = Symbol("STORE_TARGET"),
   $PROXY = Symbol("STORE_PROXY"),
   $DELETED = Symbol("STORE_DELETED");
-const PARENTS = new WeakMap();
 const STORE_VALUE = "v",
   STORE_OVERRIDE = "o",
   STORE_OPTIMISTIC_OVERRIDE = "x",
@@ -2047,7 +2117,9 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     },
     firewall
   );
-  if (optimistic) s._optimistic = true;
+  if (optimistic) {
+    s._overrideValue = NOT_PENDING;
+  }
   if (snapshotProps && property in snapshotProps) {
     const sv = snapshotProps[property];
     s._snapshotValue = sv === undefined ? NO_SNAPSHOT : sv;
@@ -2093,8 +2165,8 @@ const storeTraps = {
     if (property === $TARGET) return target;
     if (property === $PROXY) return receiver;
     if (property === $REFRESH) return target[STORE_FIREWALL];
-    if (property === $TRACK || property === $DEEP) {
-      trackSelf(target, property);
+    if (property === $TRACK) {
+      trackSelf(target);
       return receiver;
     }
     const nodes = getNodes(target, STORE_NODE);
@@ -2116,11 +2188,11 @@ const storeTraps = {
     if (writeOnly(receiver)) {
       let value =
         tracked && (overridden || !proxySource)
-          ? tracked._pendingValue !== NOT_PENDING
-            ? tracked._optimistic
-              ? tracked._value
-              : tracked._pendingValue
-            : tracked._value
+          ? tracked._overrideValue !== undefined && tracked._overrideValue !== NOT_PENDING
+            ? tracked._overrideValue
+            : tracked._pendingValue !== NOT_PENDING
+              ? tracked._pendingValue
+              : tracked._value
           : storeValue[property];
       value === $DELETED && (value = undefined);
       if (!isWrappable(value)) return value;
@@ -2156,10 +2228,10 @@ const storeTraps = {
         );
       }
     }
-    if (strictRead && !tracking && typeof property === "string")
+    if (strictRead && typeof property === "string")
       console.warn(
-        `Reactive value read at the top level of ${strictRead} will not update. ` +
-          `Move it into a tracking scope (JSX, computations, effects).`
+        `Reactive value read directly in ${strictRead} will not update. ` +
+          `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
       );
     return isWrappable(value) ? wrap(value, target) : value;
   },
@@ -2196,7 +2268,11 @@ const storeTraps = {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
-        if (snapshotCaptureActive && typeof property !== "symbol") {
+        if (
+          snapshotCaptureActive &&
+          typeof property !== "symbol" &&
+          !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
+        ) {
           if (!target[STORE_SNAPSHOT_PROPS]) {
             target[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(target);
@@ -2223,11 +2299,6 @@ const storeTraps = {
         if (value !== undefined && value === base) delete target[overrideKey][property];
         else (target[overrideKey] || (target[overrideKey] = Object.create(null)))[property] = value;
         const wrappable = isWrappable(value);
-        if (isWrappable(prev)) {
-          const parents = PARENTS.get(prev);
-          parents && (parents instanceof Set ? parents.delete(store) : PARENTS.delete(prev));
-        }
-        if (recursivelyNotify(store, storeLookup) && wrappable) recursivelyAddParent(value, store);
         target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
         const nodes = getNodes(target, STORE_NODE);
         nodes[property] &&
@@ -2267,10 +2338,6 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        if (isWrappable(prev)) {
-          const parents = PARENTS.get(prev);
-          parents && (parents instanceof Set ? parents.delete(target) : PARENTS.delete(prev));
-        }
         if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], false);
         const nodes = getNodes(target, STORE_NODE);
         nodes[property] && setSignal(nodes[property], undefined);
@@ -2341,59 +2408,6 @@ function createStore(first, second, options) {
     wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
   return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
 }
-function recursivelyNotify(state, lookup) {
-  let target = state[$TARGET] || lookup?.get(state)?.[$TARGET];
-  let notified = false;
-  if (target) {
-    const deep = getNodes(target, STORE_NODE)[$DEEP];
-    if (deep) {
-      setSignal(deep, undefined);
-      notified = true;
-    }
-    lookup = target[STORE_LOOKUP] || lookup;
-  }
-  const parents = PARENTS.get(target?.[STORE_VALUE] || state);
-  if (!parents) return notified;
-  if (parents instanceof Set) {
-    for (let parent of parents) notified = recursivelyNotify(parent, lookup) || notified;
-  } else notified = recursivelyNotify(parents, lookup) || notified;
-  return notified;
-}
-function recursivelyAddParent(state, parent) {
-  let override;
-  const target = state[$TARGET];
-  if (target) {
-    override = target[STORE_OVERRIDE];
-    state = target[STORE_VALUE];
-  }
-  if (parent) {
-    let parents = PARENTS.get(state);
-    if (!parents) PARENTS.set(state, parent);
-    else if (parents !== parent) {
-      if (!(parents instanceof Set)) PARENTS.set(state, (parents = new Set([parents])));
-      else if (parents.has(parent)) return;
-      parents.add(parent);
-    } else return;
-  }
-  if (Array.isArray(state)) {
-    const len = override?.length || state.length;
-    for (let i = 0; i < len; i++) {
-      const item = override && i in override ? override[i] : state[i];
-      isWrappable(item) && recursivelyAddParent(item, state);
-    }
-  } else {
-    const keys = getKeys(state, override);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const item = override && key in override ? override[key] : state[key];
-      isWrappable(item) && recursivelyAddParent(item, state);
-    }
-  }
-}
-function deep(store) {
-  recursivelyAddParent(store);
-  return store[$DEEP];
-}
 function createOptimisticStore(first, second, options) {
   GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
   const derived = typeof first === "function";
@@ -2464,14 +2478,14 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
             try {
               value !== s &&
                 value !== undefined &&
-                storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
+                storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
             } finally {
               setProjectionWriteActive(false);
             }
           });
           value !== s &&
             value !== undefined &&
-            reconcile(value, options?.key || "id", options?.all)(wrappedStore);
+            reconcile(value, options?.key || "id")(wrappedStore);
         });
       } finally {
         setProjectionWriteActive(false);
@@ -2546,12 +2560,13 @@ const storePath = Object.assign(
   },
   { DELETE: DELETE }
 );
-function snapshot(item, map, lookup) {
+function snapshotImpl(item, track, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
   if (!isWrappable(item)) return item;
   if (map && map.has(item)) return map.get(item);
   if (!map) map = new Map();
   if ((target = item[$TARGET] || lookup?.get(item)?.[$TARGET])) {
+    if (track) trackSelf(target, $TRACK);
     override = target[STORE_OVERRIDE];
     isArray = Array.isArray(target[STORE_VALUE]);
     map.set(
@@ -2571,7 +2586,8 @@ function snapshot(item, map, lookup) {
     for (let i = 0; i < len; i++) {
       v = override && i in override ? override[i] : item[i];
       if (v === $DELETED) continue;
-      if ((unwrapped = snapshot(v, map, lookup)) !== v || result) {
+      if (track && isWrappable(v)) wrap(v, target);
+      if ((unwrapped = snapshotImpl(v, track, map, lookup)) !== v || result) {
         if (!result) map.set(item, (result = [...item]));
         result[i] = unwrapped;
       }
@@ -2583,7 +2599,8 @@ function snapshot(item, map, lookup) {
       const desc = getPropertyDescriptor(item, override, prop);
       if (desc.get) continue;
       v = override && prop in override ? override[prop] : item[prop];
-      if ((unwrapped = snapshot(v, map, lookup)) !== item[prop] || result) {
+      if (track && isWrappable(v)) wrap(v, target);
+      if ((unwrapped = snapshotImpl(v, track, map, lookup)) !== item[prop] || result) {
         if (!result) {
           result = Object.create(Object.getPrototypeOf(item));
           Object.assign(result, item);
@@ -2594,6 +2611,12 @@ function snapshot(item, map, lookup) {
   }
   return result || item;
 }
+function snapshot(item, map, lookup) {
+  return snapshotImpl(item, false, map, lookup);
+}
+function deep(store) {
+  return snapshotImpl(store, true);
+}
 function trueFn() {
   return true;
 }
@@ -2769,15 +2792,15 @@ function updateKeyedMap() {
             this._rows[j] = signal(newItems[j], pureOptions);
             this._indexes && (this._indexes[j] = signal(j, pureOptions));
             return this._map(
-              read.bind(null, this._rows[j]),
-              this._indexes ? read.bind(null, this._indexes[j]) : undefined
+              accessor(this._rows[j]),
+              this._indexes ? accessor(this._indexes[j]) : undefined
             );
           }
         : this._indexes
           ? () => {
               const item = newItems[j];
               this._indexes[j] = signal(j, pureOptions);
-              return this._map(() => item, read.bind(null, this._indexes[j]));
+              return this._map(() => item, accessor(this._indexes[j]));
             }
           : () => {
               const item = newItems[j];
@@ -2981,11 +3004,14 @@ function createBoundChildren(owner, fn, queue, mask) {
     return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
   });
 }
+const ON_INIT = Symbol();
 class CollectionQueue extends Queue {
   _collectionType;
   _sources = new Set();
   _disabled = signal(false, { pureWrite: true });
   _initialized = false;
+  _onFn;
+  _prevOn = ON_INIT;
   constructor(type) {
     super();
     this._collectionType = type;
@@ -2995,10 +3021,22 @@ class CollectionQueue extends Queue {
     return super.run(type);
   }
   notify(node, type, flags, error) {
-    if (
-      !(type & this._collectionType) ||
-      (this._collectionType & STATUS_PENDING && this._initialized)
-    )
+    if (!(type & this._collectionType)) return super.notify(node, type, flags, error);
+    if (this._initialized && this._onFn) {
+      const currentOn = untrack(() => {
+        try {
+          return this._onFn();
+        } catch {
+          return ON_INIT;
+        }
+      });
+      if (currentOn !== this._prevOn) {
+        this._prevOn = currentOn;
+        this._initialized = false;
+        this._sources.clear();
+      }
+    }
+    if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
       const source = error?.source || node._error?.source;
@@ -3015,12 +3053,20 @@ class CollectionQueue extends Queue {
     for (const source of this._sources) {
       if (!(source._statusFlags & this._collectionType)) this._sources.delete(source);
     }
-    if (!this._sources.size) setSignal(this._disabled, false);
+    if (!this._sources.size) {
+      setSignal(this._disabled, false);
+      if (this._onFn) {
+        try {
+          this._prevOn = untrack(() => this._onFn());
+        } catch {}
+      }
+    }
   }
 }
-function createCollectionBoundary(type, fn, fallback) {
+function createCollectionBoundary(type, fn, fallback, onFn) {
   const owner = createOwner();
   const queue = new CollectionQueue(type);
+  if (onFn) queue._onFn = onFn;
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = computed(() => {
     if (!read(queue._disabled)) {
@@ -3032,10 +3078,10 @@ function createCollectionBoundary(type, fn, fallback) {
     }
     return fallback(queue);
   });
-  return read.bind(null, decision);
+  return accessor(decision);
 }
-function createLoadBoundary(fn, fallback) {
-  return createCollectionBoundary(STATUS_PENDING, fn, () => fallback());
+function createLoadingBoundary(fn, fallback, options) {
+  return createCollectionBoundary(STATUS_PENDING, fn, () => fallback(), options?.on);
 }
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(STATUS_ERROR, fn, queue => {
@@ -3105,6 +3151,7 @@ function flattenArray(children, results = [], options) {
 }
 export {
   $PROXY,
+  $REFRESH,
   $TARGET,
   $TRACK,
   ContextNotFoundError,
@@ -3116,7 +3163,7 @@ export {
   createContext,
   createEffect,
   createErrorBoundary,
-  createLoadBoundary,
+  createLoadingBoundary,
   createMemo,
   createOptimistic,
   createOptimisticStore,
@@ -3129,6 +3176,8 @@ export {
   createStore,
   createTrackedEffect,
   deep,
+  enableExternalSource,
+  enforceLoadingBoundary,
   flatten,
   flush,
   getContext,
@@ -3156,7 +3205,6 @@ export {
   runWithOwner,
   setContext,
   setSnapshotCapture,
-  setStrictRead,
   snapshot,
   storePath,
   untrack