@solidjs/signals 2.0.0-beta.15 → 2.0.0-beta.17

package/dist/dev.js

@@ -12,6 +12,9 @@ class StatusError extends Error {
     this.source = source;
   }
 }
+function unwrapStatusError(error) {
+  return error instanceof StatusError ? error.cause : error;
+}
 class NoOwnerError extends Error {
   constructor() {
     super("Context can only be accessed under a reactive root.");
@@ -140,6 +143,22 @@ function getObservers(node) {
   }
   return observers;
 }
+function createAsyncReporters() {
+  return new Map();
+}
+function devCheckActiveOverrides(isRegisteredForRevert) {
+  return;
+}
+function devCheckFlushStart() {
+  return;
+}
+typeof globalThis !== "undefined" && !!globalThis.process?.env?.COMPANION_CENSUS;
+function devCensusCompanions(isQueuedForCommit) {
+  return;
+}
+function devCheckQuiescent(isQueuedForCommit) {
+  return;
+}
 const signalLanes = new WeakMap();
 const activeLanes = new Set();
 function getOrCreateLane(signal) {
@@ -159,7 +178,6 @@ function getOrCreateLane(signal) {
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
-  signal._overrideSinceLane = false;
   return lane;
 }
 function findLane(lane) {
@@ -172,8 +190,11 @@ function mergeLanes(lane1, lane2) {
   if (lane1 === lane2) return lane1;
   lane2._mergedInto = lane1;
   for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
+  lane2._pendingAsync.clear();
   lane1._effectQueues[0].push(...lane2._effectQueues[0]);
   lane1._effectQueues[1].push(...lane2._effectQueues[1]);
+  lane2._effectQueues[0].length = 0;
+  lane2._effectQueues[1].length = 0;
   return lane1;
 }
 function resolveLane(el) {
@@ -217,6 +238,8 @@ const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _mi
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let halted = false;
+let haltNotified = false;
 let syncDepth = 0;
 let projectionWriteActive = false;
 let inTrackedQueueCallback = false;
@@ -305,19 +328,24 @@ function mergeTransitionState(target, outgoing) {
   for (const sub of outgoing._gatedSubs) target._gatedSubs.add(sub);
 }
 function resolveOptimisticNodes(nodes) {
-  for (let i = 0; i < nodes.length; i++) {
+  const len = nodes.length;
+  for (let i = 0; i < len; i++) {
     const node = nodes[i];
     node._optimisticLane = undefined;
-    if (node._pendingValue !== NOT_PENDING) {
-      node._value = node._pendingValue;
-      node._pendingValue = NOT_PENDING;
-    }
+    if (!(node._statusFlags & STATUS_PENDING)) node._statusFlags &= ~STATUS_UNINITIALIZED;
     const prevOverride = node._overrideValue;
     node._overrideValue = NOT_PENDING;
     if (prevOverride !== NOT_PENDING && node._value !== prevOverride) insertSubs(node, true);
     node._transition = null;
   }
-  nodes.length = 0;
+  for (let i = 0; i < len; i++) {
+    const node = nodes[i];
+    if (node._pendingSignal || node._latestValueComputed) snapCompanionsToState(node);
+    const owner = node._parentSource;
+    if (owner && (owner._pendingSignal === node || owner._latestValueComputed === node))
+      snapCompanionsToState(owner);
+  }
+  nodes.splice(0, len);
 }
 function cleanupCompletedLanes(completingTransition) {
   for (const lane of activeLanes) {
@@ -338,10 +366,41 @@ function cleanupCompletedLanes(completingTransition) {
   }
 }
 function schedule() {
+  if (halted) {
+    notifyHalted();
+    return;
+  }
   if (scheduled) return;
   scheduled = true;
   if (!syncDepth && !globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
+function haltReactivity() {
+  if (halted) return;
+  halted = true;
+  let message = "[REACTIVITY_HALTED] An uncaught error halted the reactive system.";
+  {
+    message +=
+      " No further updates will be processed. Handle errors with createErrorBoundary/<Errored> or treat this as a crash.";
+    emitDiagnostic({
+      code: "REACTIVITY_HALTED",
+      kind: "error",
+      severity: "error",
+      message: message
+    });
+  }
+  console.error(message);
+}
+function notifyHalted() {
+  if (haltNotified) return;
+  haltNotified = true;
+  console.error(
+    "[REACTIVITY_HALTED] Update ignored: the reactive system was halted by an earlier uncaught error."
+  );
+}
+function resetErrorHalt() {
+  halted = false;
+  haltNotified = false;
+}
 class Queue {
   _parent = null;
   _queues = [[], []];
@@ -419,6 +478,7 @@ class GlobalQueue extends Queue {
     if (this._running) return;
     this._running = true;
     try {
+      if (true) devCheckFlushStart();
       runHeap(dirtyQueue, GlobalQueue._update);
       if (activeTransition) {
         const isComplete = transitionComplete(activeTransition);
@@ -482,6 +542,24 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_RENDER);
       activeLanes.size && runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
+      if (true) {
+        devCheckActiveOverrides(n => {
+          if (this._optimisticNodes.includes(n)) return true;
+          if (activeTransition?._optimisticNodes.includes(n)) return true;
+          for (const t of transitions) if (t._optimisticNodes.includes(n)) return true;
+          return false;
+        });
+        devCensusCompanions(n => n === this._pendingNode || this._pendingNodes.includes(n));
+      }
+      if (
+        true &&
+        !scheduled &&
+        !activeTransition &&
+        transitions.size === 0 &&
+        activeLanes.size === 0
+      ) {
+        devCheckQuiescent(n => n === this._pendingNode || this._pendingNodes.includes(n));
+      }
       if (true) DEV$1.hooks.onUpdate?.();
     } finally {
       this._running = false;
@@ -513,7 +591,7 @@ class GlobalQueue extends Queue {
       activeTransition = transition ?? {
         _time: clock,
         _pendingNodes: [],
-        _asyncReporters: new Map(),
+        _asyncReporters: createAsyncReporters(),
         _optimisticNodes: [],
         _optimisticStores: new Set(),
         _actions: [],
@@ -609,6 +687,7 @@ function commitPendingNode(n) {
       n._value = n._pendingValue;
       n._pendingValue = NOT_PENDING;
     }
+    if (n._pendingSignal || n._latestValueComputed) snapCompanionsToState(n);
     return;
   }
   if (n._pendingValue !== NOT_PENDING) {
@@ -620,6 +699,7 @@ function commitPendingNode(n) {
   if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
   if (c._pendingFirstChild !== null || c._pendingDisposal !== null)
     GlobalQueue._dispose(c, false, true);
+  if (n._pendingSignal || n._latestValueComputed) snapCompanionsToState(n);
 }
 function commitPendingNodes() {
   if (globalQueue._pendingNode !== null) {
@@ -710,6 +790,7 @@ function flush(fn) {
     }
     return;
   }
+  if (halted) return;
   let count = 0;
   while (scheduled || activeTransition) {
     if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
@@ -761,8 +842,7 @@ function transitionComplete(transition) {
         hasActiveOverride(node) &&
         "_statusFlags" in node &&
         node._statusFlags & STATUS_PENDING &&
-        node._error instanceof NotReadyError &&
-        node._error.source !== node
+        node._error instanceof NotReadyError
       ) {
         done = false;
         break;
@@ -916,7 +996,11 @@ function dispose(node) {
 function disposeChildren(node, self = false, zombie) {
   const flags = node._flags;
   if (flags & REACTIVE_DISPOSED) return;
-  if (self) node._flags = flags | REACTIVE_DISPOSED;
+  if (self) {
+    node._flags = flags | REACTIVE_DISPOSED;
+    const n = node;
+    if (n._pendingSignal || n._latestValueComputed) snapCompanionsToState(n);
+  }
   if (self && true) clearSignals(node);
   if (self && node._fn) node._inFlight = null;
   let child = zombie ? node._pendingFirstChild : node._firstChild;
@@ -956,6 +1040,11 @@ function disposeChildren(node, self = false, zombie) {
     node._prevSibling = null;
   }
   runDisposal(node, zombie);
+  if (self && node._cleanup) {
+    const effectCleanup = node._cleanup;
+    node._cleanup = undefined;
+    effectCleanup();
+  }
 }
 function runDisposal(node, zombie) {
   let disposal = zombie ? node._pendingDisposal : node._disposal;
@@ -1097,42 +1186,49 @@ function unobserved(el) {
   el._depsTail = null;
   disposeChildren(el, true);
 }
-function link(dep, sub) {
+function link(dep, sub, pendingObserver = false) {
   const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) return;
+  if (prevDep !== null && prevDep._dep === dep) {
+    prevDep._pendingObserver = pendingObserver;
+    return;
+  }
   let nextDep = null;
   const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
   if (isRecomputing) {
     nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
     if (nextDep !== null && nextDep._dep === dep) {
+      nextDep._gen = sub._depGen;
       sub._depsTail = nextDep;
+      nextDep._pendingObserver = pendingObserver;
       return;
     }
   }
   const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
+  if (
+    prevSub !== null &&
+    prevSub._sub === sub &&
+    (!isRecomputing || prevSub._gen === sub._depGen)
+  ) {
+    prevSub._pendingObserver = pendingObserver;
     return;
+  }
   const newLink =
     (sub._depsTail =
     dep._subsTail =
-      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
+      {
+        _dep: dep,
+        _sub: sub,
+        _nextDep: nextDep,
+        _prevSub: prevSub,
+        _nextSub: null,
+        _gen: sub._depGen,
+        _pendingObserver: pendingObserver
+      });
   if (prevDep !== null) prevDep._nextDep = newLink;
   else sub._deps = newLink;
   if (prevSub !== null) prevSub._nextSub = newLink;
   else dep._subs = newLink;
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub._depsTail;
-  if (depsTail !== null) {
-    let link = sub._deps;
-    do {
-      if (link === checkLink) return true;
-      if (link === depsTail) break;
-      link = link._nextDep;
-    } while (link !== null);
-  }
-  return false;
-}
 function addPendingSource(el, source) {
   if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
   if (!el._pendingSource) {
@@ -1182,9 +1278,22 @@ function setPendingError(el, source, error) {
   }
 }
 function forEachDependent(el, fn) {
-  for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub);
+  for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub, s);
   for (let child = el._child; child !== null; child = child._nextChild) {
-    for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub);
+    for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub, s);
+  }
+}
+function enqueueForRerun(node) {
+  if (node._type === EFFECT_TRACKED) {
+    const tracked = node;
+    if (!tracked._modified) {
+      tracked._modified = true;
+      tracked._queue.enqueue(EFFECT_USER, tracked._run);
+    }
+  } else {
+    const queue = node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > node._height) queue._min = node._height;
+    insertIntoHeap(node, queue);
   }
 }
 function settlePendingSource(el) {
@@ -1203,17 +1312,7 @@ function settlePendingSource(el) {
       setPendingError(node);
       updatePendingSignal(node);
       if (node._blocked) {
-        if (node._type === EFFECT_TRACKED) {
-          const tracked = node;
-          if (!tracked._modified) {
-            tracked._modified = true;
-            tracked._queue.enqueue(EFFECT_USER, tracked._run);
-          }
-        } else {
-          const queue = node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-          if (queue._min > node._height) queue._min = node._height;
-          insertIntoHeap(node, queue);
-        }
+        enqueueForRerun(node);
         scheduled = true;
       }
       node._blocked = false;
@@ -1223,23 +1322,26 @@ function settlePendingSource(el) {
   forEachDependent(el, settle);
   if (scheduled) schedule();
 }
+function isThenable(value) {
+  return value != null && typeof value === "object" && typeof value.then === "function";
+}
 function handleAsync(el, result, setter) {
   let iterator = false;
-  let isThenable = false;
+  let thenable = false;
   if (typeof result === "object" && result !== null) {
     untrack(() => {
       iterator = result[Symbol.asyncIterator];
-      isThenable = !iterator && typeof result.then === "function";
+      thenable = !iterator && isThenable(result);
     });
   }
-  if (!isThenable && !iterator) {
+  if (!thenable && !iterator) {
     el._inFlight = null;
     return result;
   }
   if (el._config & CONFIG_SYNC) {
     const message =
       `[SYNC_NODE_RECEIVED_ASYNC] A computed/effect created with \`sync: true\` returned ` +
-      `${isThenable ? "a Promise" : "an AsyncIterable"}. The value would be stored as-is and ` +
+      `${thenable ? "a Promise" : "an AsyncIterable"}. The value would be stored as-is and ` +
       `never awaited in production; remove \`sync: true\` to use async-aware behavior, or ` +
       `unwrap the value before returning.`;
     emitDiagnostic({
@@ -1273,35 +1375,41 @@ function handleAsync(el, result, setter) {
       setter(value);
       if (wasUninitialized) clearStatus(el, true);
     } else if (el._overrideValue !== undefined) {
-      if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
-        el._pendingValue = value;
-      else {
-        el._value = value;
-        insertSubs(el);
-      }
+      if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
+      el._pendingValue = value;
+      syncCompanions(el, value);
+      if (!hasActiveOverride(el)) insertSubs(el);
       el._time = clock;
     } else if (lane) {
       const isEffect = el._type;
       const prevValue = el._value;
       const equals = el._equals;
-      if ((!isEffect && wasUninitialized) || !equals || !equals(value, prevValue)) {
-        el._value = value;
-        el._time = clock;
-        if (el._latestValueComputed) {
-          setSignal(el._latestValueComputed, value);
+      try {
+        if ((!isEffect && wasUninitialized) || !equals || !equals(value, prevValue)) {
+          el._value = value;
+          el._time = clock;
+          syncCompanions(el, value);
+          insertSubs(el, true);
         }
-        insertSubs(el, true);
+      } catch (e) {
+        notifyStatus(el, STATUS_ERROR, e);
       }
     } else {
-      setSignal(el, () => value);
+      try {
+        setSignal(el, () => value);
+      } catch (e) {
+        notifyStatus(el, STATUS_ERROR, e);
+      }
     }
     settlePendingSource(el);
     schedule();
     flush();
     then?.();
   };
-  if (isThenable) {
+  if (thenable) {
     let resolved = false,
+      rejected = false,
+      syncError,
       isSync = true;
     result.then(
       v => {
@@ -1311,32 +1419,39 @@ function handleAsync(el, result, setter) {
         } else asyncWrite(v);
       },
       e => {
-        if (!isSync) handleError(e);
+        if (isSync) {
+          syncError = e;
+          rejected = true;
+        } else handleError(e);
       }
     );
     isSync = false;
-    if (!resolved) {
+    if (rejected) {
+      handleError(syncError);
+      throw syncError;
+    } else if (!resolved) {
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
   if (iterator) {
     const it = result[Symbol.asyncIterator]();
-    let hadSyncValue = false;
+    let hadValue = false;
     let completed = false;
+    let initialRead = true;
     cleanup(() => {
       if (completed) return;
       completed = true;
       try {
         const returned = it.return?.();
-        if (returned && typeof returned.then === "function") {
-          returned.then(undefined, () => {});
-        }
+        if (isThenable(returned)) returned.then(undefined, () => {});
       } catch {}
     });
     const iterate = () => {
       let syncResult,
+        syncError,
         resolved = false,
+        rejected = false,
         isSync = true;
       it.next().then(
         r => {
@@ -1346,30 +1461,46 @@ function handleAsync(el, result, setter) {
             if (r.done) completed = true;
           } else if (el._inFlight !== result) {
             return;
-          } else if (!r.done) asyncWrite(r.value, iterate);
-          else {
+          } else if (!r.done) {
+            hadValue = true;
+            asyncWrite(r.value, iterate);
+          } else {
             completed = true;
-            schedule();
-            flush();
+            if (hadValue) {
+              schedule();
+              flush();
+            } else {
+              asyncWrite(undefined);
+            }
           }
         },
         e => {
-          if (!isSync && el._inFlight === result) {
+          if (isSync) {
+            syncError = e;
+            rejected = true;
+          } else if (el._inFlight === result) {
             completed = true;
             handleError(e);
           }
         }
       );
       isSync = false;
+      if (rejected) {
+        completed = true;
+        handleError(syncError);
+        if (initialRead) throw syncError;
+        return true;
+      }
       if (resolved && !syncResult.done) {
         syncValue = syncResult.value;
-        hadSyncValue = true;
+        hadValue = true;
         return iterate();
       }
       return resolved && syncResult.done;
     };
     const immediatelyDone = iterate();
-    if (!hadSyncValue && !immediatelyDone) {
+    initialRead = false;
+    if (!hadValue && !immediatelyDone) {
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
@@ -1381,7 +1512,8 @@ function clearStatus(el, clearUninitialized = false) {
   if (el._blocked) el._blocked = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
   if (el._error) setPendingError(el);
-  if (el._pendingSignal) updatePendingSignal(el);
+  if (el._pendingSignal || el._latestValueComputed) updatePendingSignal(el);
+  if (el._child) updateChildCompanions(el);
   if (el._notifyStatus) el._notifyStatus();
 }
 function notifyStatus(el, status, error, blockStatus, lane) {
@@ -1409,6 +1541,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       el._error = error;
     }
     updatePendingSignal(el);
+    if (el._child) updateChildCompanions(el);
   }
   if (lane && !blockStatus) {
     assignOrMergeLane(el, lane);
@@ -1426,7 +1559,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
     return;
   }
-  forEachDependent(el, sub => {
+  forEachDependent(el, (sub, link) => {
     sub._time = clock;
     if (
       (status === STATUS_PENDING &&
@@ -1436,6 +1569,11 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       (status !== STATUS_PENDING &&
         (sub._error !== error || sub._pendingSource || sub._pendingSources))
     ) {
+      if (link._pendingObserver && status !== STATUS_PENDING && !(error instanceof NotReadyError)) {
+        enqueueForRerun(sub);
+        schedule();
+        return;
+      }
       if (!downstreamBlockStatus && !sub._transition) queuePendingNode(sub);
       notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
@@ -1477,11 +1615,10 @@ const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE =
 let tracking = false;
 let stale = false;
 let pendingCheckActive = false;
-let foundPending = false;
 let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
-let pendingCheckSources = null;
+let pendingProbe = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1554,11 +1691,12 @@ function recompute(el, create = false) {
   }
   let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
-  const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  !!(el._statusFlags & STATUS_PENDING);
   const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
+  el._depGen++;
   el._flags = REACTIVE_RECOMPUTING_DEPS;
   el._time = clock;
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
@@ -1641,26 +1779,35 @@ function recompute(el, create = false) {
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
-    const valueChanged =
-      (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
+    let valueChanged = false;
+    try {
+      valueChanged =
+        (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
+    } catch (e) {
+      notifyStatus(el, STATUS_ERROR, e);
+    }
     if (isEffect && valueChanged) {
       el._modified = !el._error;
-      if (!create) el._queue.enqueue(isEffect, GlobalQueue._runEffect.bind(null, el));
+      if (!create)
+        el._queue.enqueue(isEffect, (el._boundRunEffect ??= GlobalQueue._runEffect.bind(null, el)));
     }
-    if (valueChanged) {
+    if (el._error);
+    else if (valueChanged) {
       const prevVisible = hasOverride ? el._overrideValue : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
         el._value = value;
         if (hasOverride && isOptimisticDirty) {
           el._overrideValue = value;
-          el._pendingValue = value;
+          el._pendingValue = NOT_PENDING;
         }
-      } else el._pendingValue = value;
-      if (hasOverride && !isOptimisticDirty && wasPending && !el._overrideSinceLane)
-        el._overrideValue = value;
+      } else {
+        el._pendingValue = value;
+        if (activeTransition || el._transition) syncCompanions(el, value);
+      }
       if (!hasOverride || isOptimisticDirty || el._overrideValue !== prevVisible)
         insertSubs(el, isOptimisticDirty || hasOverride);
     } else if (hasOverride) {
+      if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
       el._pendingValue = value;
     } else if (el._height != oldHeight) {
       for (let s = el._subs; s !== null; s = s._nextSub) {
@@ -1676,8 +1823,7 @@ function recompute(el, create = false) {
     !!(el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED));
   needsPendingCommit &&
     (!create || el._statusFlags & STATUS_PENDING) &&
-    !el._transition &&
-    !(activeTransition && hasOverride) &&
+    (!el._transition || hasOverride) &&
     queuePendingNode(el);
   el._transition &&
     isEffect &&
@@ -1716,6 +1862,7 @@ function computed(fn, options) {
       (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
       (!context || options?.lazy ? CONFIG_AUTO_DISPOSE : 0) |
       (options?.sync ? CONFIG_SYNC : 0) |
+      (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0) |
       (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: options?.equals != null ? options.equals : isEqual,
     _unobserved: options?.unobserved,
@@ -1731,6 +1878,7 @@ function computed(fn, options) {
     _prevHeap: null,
     _deps: null,
     _depsTail: null,
+    _depGen: 0,
     _subs: null,
     _subsTail: null,
     _parent: context,
@@ -1775,6 +1923,7 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _prevHeap: null,
     _deps: null,
     _depsTail: null,
+    _depGen: 0,
     _subs: null,
     _subsTail: null,
     _parent: context,
@@ -1794,7 +1943,6 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _effectFn: effectFn,
     _errorFn: errorFn,
     _cleanup: undefined,
-    _cleanupRegistered: false,
     _type: type,
     _notifyStatus: notifyStatus
   };
@@ -1842,7 +1990,7 @@ function setupComputedNode(self, options) {
   }
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
-    if (!(self._statusFlags & STATUS_PENDING)) {
+    if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT)) {
       self._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
       snapshotSources.add(self);
     }
@@ -1911,6 +2059,16 @@ function untrack(fn, strictReadLabel) {
     strictRead = prevStrictRead;
   }
 }
+function prepareComputed(comp, refresh) {
+  if (comp._flags & REACTIVE_LAZY) {
+    comp._flags &= ~REACTIVE_LAZY;
+    recompute(comp, true);
+  } else if (comp._flags & REACTIVE_DISPOSED) {
+    recompute(comp, true);
+  } else if (refresh) {
+    updateIfNecessary(comp);
+  }
+}
 function read(el) {
   if (latestReadActive) {
     const pendingComputed = getLatestValueComputed(el);
@@ -1924,7 +2082,8 @@ function read(el) {
     try {
       value = read(pendingComputed);
     } catch (e) {
-      if (!context && e instanceof NotReadyError) return visibleValue;
+      if (e instanceof NotReadyError && (!context || !(el._statusFlags & STATUS_UNINITIALIZED)))
+        return visibleValue;
       throw e;
     } finally {
       latestReadActive = prevPending;
@@ -1939,59 +2098,25 @@ function read(el) {
     }
     return value;
   }
+  let c = context;
+  if (c?._root) c = c._parentComputed;
+  const computed = el;
+  const firewall = el._firewall;
+  const owner = firewall || el;
   if (pendingCheckActive) {
-    const firewall = el._firewall;
-    const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
-    let c = context;
-    if (c?._root) c = c._parentComputed;
-    const owner = firewall || el;
-    const pendingComputed = el;
-    if (typeof pendingComputed._fn === "function") {
-      const comp = el;
-      if (comp._flags & REACTIVE_LAZY) {
-        comp._flags &= ~REACTIVE_LAZY;
-        recompute(comp, true);
-      } else if (comp._flags & REACTIVE_DISPOSED) {
-        recompute(comp, true);
-      } else {
-        updateIfNecessary(comp);
-      }
-    }
+    if (typeof computed._fn === "function") prepareComputed(el, true);
     if (c && owner._statusFlags & STATUS_PENDING && owner._statusFlags & STATUS_UNINITIALIZED) {
       if (tracking && el !== c) link(el, c);
-      pendingCheckActive = prevCheck;
+      pendingCheckActive = true;
       throw owner._error;
     }
-    if (firewall && el._overrideValue !== undefined) {
-      if (
-        el._overrideValue !== NOT_PENDING &&
-        (firewall._inFlight || !!(firewall._statusFlags & STATUS_PENDING))
-      ) {
-        foundPending = true;
-      }
-      collectPendingSources(el);
-      collectPendingSources(firewall);
-      if (c && tracking) link(el, c);
-    } else {
-      collectPendingSources(el);
-      if (firewall) collectPendingSources(firewall);
-    }
-    pendingCheckActive = prevCheck;
+    collectPendingSources(el);
+    if (firewall) collectPendingSources(firewall);
+    pendingCheckActive = true;
+  } else if (typeof computed._fn === "function") {
+    prepareComputed(el, false);
   }
-  let c = context;
-  if (c?._root) c = c._parentComputed;
-  const computed = el;
-  if (typeof computed._fn === "function") {
-    const comp = el;
-    if (comp._flags & REACTIVE_LAZY) {
-      comp._flags &= ~REACTIVE_LAZY;
-      recompute(comp, true);
-    } else if (comp._flags & REACTIVE_DISPOSED) {
-      recompute(comp, true);
-    }
-  }
-  const owner = el._firewall || el;
   if (
     !computed._fn &&
     owner === el &&
@@ -2022,7 +2147,7 @@ function read(el) {
     throw new Error(message);
   }
   if (c && tracking) {
-    link(el, c);
+    link(el, c, pendingCheckActive);
     if (owner._fn) {
       const isZombie = el._flags & REACTIVE_ZOMBIE;
       if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
@@ -2072,7 +2197,7 @@ function read(el) {
     }
   }
   if (el._fn && el._statusFlags & STATUS_ERROR) {
-    if (el._time < clock) {
+    if (tracking && !pendingCheckActive && el._time < clock) {
       recompute(el);
       return read(el);
     } else throw el._error;
@@ -2123,12 +2248,19 @@ function read(el) {
     (currentOptimisticLane !== null &&
       (el._overrideValue !== undefined ||
         el._optimisticLane ||
-        (owner === el && stale) ||
+        (owner === el && stale && c._parentSource !== el) ||
         !!(owner._statusFlags & STATUS_PENDING))) ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
       ? el._value
       : el._pendingValue;
+  if (
+    pendingCheckActive &&
+    pendingProbe !== null &&
+    el._pendingValue !== NOT_PENDING &&
+    value === el._pendingValue
+  )
+    pendingProbe.freshReads.add(el);
   if (
     !c &&
     owner === el &&
@@ -2173,26 +2305,18 @@ function setSignal(el, v) {
       : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged =
-    !el._equals || !el._equals(currentValue, v) || !!(el._statusFlags & STATUS_UNINITIALIZED);
+    !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
   if (!valueChanged) {
     if (isOptimistic && hasOverride) {
       const transition = resolveTransition(el);
       if (transition && activeTransition !== transition) globalQueue.initTransition(transition);
-      if (el._fn) {
-        insertSubs(el, true);
-        schedule();
-      }
     }
     return v;
   }
   if (isOptimistic) {
     const firstOverride = el._overrideValue === NOT_PENDING;
     if (!firstOverride) globalQueue.initTransition(resolveTransition(el));
-    if (firstOverride) {
-      el._pendingValue = el._value;
-      globalQueue._optimisticNodes.push(el);
-    }
-    el._overrideSinceLane = true;
+    if (firstOverride) globalQueue._optimisticNodes.push(el);
     const lane = getOrCreateLane(el);
     el._optimisticLane = lane;
     el._overrideValue = v;
@@ -2200,10 +2324,7 @@ function setSignal(el, v) {
     if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
     el._pendingValue = v;
   }
-  if (el._pendingSignal) updatePendingSignal(el);
-  if (el._latestValueComputed) {
-    setSignal(el._latestValueComputed, v);
-  }
+  syncCompanions(el, v);
   el._time = clock;
   insertSubs(el, isOptimistic);
   schedule();
@@ -2250,64 +2371,82 @@ function runWithOwner(owner, fn) {
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
     el._pendingSignal = optimisticSignal(false, { ownedWrite: true });
-    if (el._parentSource) {
-      el._pendingSignal._parentSource = el;
-    }
+    el._pendingSignal._parentSource = el;
     if (computePendingState(el)) setSignal(el._pendingSignal, true);
   }
   return el._pendingSignal;
 }
 function collectPendingSources(el) {
-  pendingCheckSources?.add(el);
+  if (!pendingProbe) return;
+  pendingProbe.sources.add(el);
   const owner = el._firewall || el;
-  if (owner !== el) pendingCheckSources?.add(owner);
+  if (owner !== el) pendingProbe.sources.add(owner);
 }
 function computePendingState(el) {
   const comp = el;
+  if (comp._flags & REACTIVE_DISPOSED) return false;
   const firewall = el._firewall;
+  if ((firewall || comp)._optimisticMask) return false;
   if (el._parentSource) {
-    const parent = el._parentSource;
-    if (parent._statusFlags & STATUS_PENDING && !(parent._statusFlags & STATUS_UNINITIALIZED))
-      return true;
-    return el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED);
+    const parentNode = el._parentSource;
+    if (hasActiveOverride(parentNode)) return false;
+    const parent = parentNode._firewall || parentNode;
+    if (parent._optimisticMask) return false;
+    return !!(
+      parent._statusFlags & STATUS_PENDING && !(parent._statusFlags & STATUS_UNINITIALIZED)
+    );
   }
+  if (hasActiveOverride(el)) return false;
   if (firewall && el._pendingValue !== NOT_PENDING) {
     return (
       !!(firewall._flags & REACTIVE_MANUAL_WRITE) ||
       (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING))
     );
   }
-  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
-    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
-      return true;
-    if (el._parentSource) {
-      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
-      return !!(lane && lane._pendingAsync.size > 0);
-    }
-    return true;
-  }
-  if (el._overrideValue !== undefined && el._overrideValue === NOT_PENDING && !el._parentSource) {
-    return false;
-  }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
+function syncCompanions(el, value) {
+  if (el._pendingSignal) updatePendingSignal(el);
+  if (el._latestValueComputed) setSignal(el._latestValueComputed, value);
+}
 function updatePendingSignal(el) {
   if (el._pendingSignal) {
-    const pending = computePendingState(el);
-    const sig = el._pendingSignal;
-    setSignal(sig, pending);
-    if (!pending && sig._optimisticLane) {
-      const sourceLane = resolveLane(el);
-      if (sourceLane && sourceLane._pendingAsync.size > 0) {
-        const sigLane = findLane(sig._optimisticLane);
-        if (sigLane !== sourceLane) {
-          mergeLanes(sourceLane, sigLane);
-        }
-      }
-      signalLanes.delete(sig);
-      sig._optimisticLane = undefined;
+    setSignal(el._pendingSignal, computePendingState(el));
+  }
+  if (el._latestValueComputed) updatePendingSignal(el._latestValueComputed);
+}
+function updateChildCompanions(el) {
+  for (let child = el._child; child !== null; child = child._nextChild) {
+    if (child._pendingSignal || child._latestValueComputed) updatePendingSignal(child);
+  }
+}
+function snapCompanionsToState(owner) {
+  const sig = owner._pendingSignal;
+  if (sig && (sig._overrideValue === undefined || sig._overrideValue === NOT_PENDING)) {
+    const pending = computePendingState(owner);
+    if (sig._value !== pending || sig._pendingValue !== NOT_PENDING) {
+      sig._value = pending;
+      sig._pendingValue = NOT_PENDING;
+      sig._time = clock;
+      insertSubs(sig);
+      schedule();
+    }
+  }
+  const shadow = owner._latestValueComputed;
+  if (shadow && !(shadow._flags & REACTIVE_DISPOSED)) {
+    if (
+      (shadow._overrideValue === undefined || shadow._overrideValue === NOT_PENDING) &&
+      shadow._pendingValue === NOT_PENDING &&
+      !Object.is(shadow._value, owner._value) &&
+      !(shadow._flags & (REACTIVE_DIRTY | REACTIVE_CHECK))
+    ) {
+      shadow._flags |= REACTIVE_DIRTY;
+      insertIntoHeap(shadow, shadow._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      insertSubs(shadow);
+      schedule();
     }
+    snapCompanionsToState(shadow);
   }
 }
 function getLatestValueComputed(el) {
@@ -2346,18 +2485,16 @@ function latest(fn) {
 }
 function isPending(fn) {
   const prevPendingCheck = pendingCheckActive;
-  const prevFoundPending = foundPending;
-  const prevPendingCheckSources = pendingCheckSources;
+  const prevProbe = pendingProbe;
   pendingCheckActive = true;
-  foundPending = false;
-  pendingCheckSources = new Set();
+  const probe = (pendingProbe = { found: false, sources: new Set(), freshReads: new Set() });
   const collectPending = () => {
     pendingCheckActive = false;
     const prevStrictRead = strictRead;
     strictRead = false;
     try {
-      pendingCheckSources.forEach(source => {
-        if (read(getPendingSignal(source))) foundPending = true;
+      probe.sources.forEach(source => {
+        if (read(getPendingSignal(source)) && !probe.freshReads.has(source)) probe.found = true;
       });
     } finally {
       strictRead = prevStrictRead;
@@ -2367,18 +2504,17 @@ function isPending(fn) {
   try {
     fn();
     collectPending();
-    return foundPending;
+    return probe.found;
   } catch (e) {
     collectPending();
     if (e instanceof NotReadyError) {
-      if (foundPending && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
+      if (probe.found && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
       if (context) throw e;
     }
-    return foundPending;
+    return probe.found;
   } finally {
     pendingCheckActive = prevPendingCheck;
-    foundPending = prevFoundPending;
-    pendingCheckSources = prevPendingCheckSources;
+    pendingProbe = prevProbe;
   }
 }
 function refresh(target) {
@@ -2485,50 +2621,66 @@ function notifyEffectStatus(status, error) {
   const actualStatus = status !== undefined ? status : this._statusFlags;
   const actualError = error !== undefined ? error : this._error;
   if (actualStatus & STATUS_ERROR) {
-    let err = actualError;
     this._queue.notify(this, STATUS_PENDING, 0);
     if (this._type === EFFECT_USER) {
-      try {
-        return this._errorFn
-          ? this._errorFn(err, () => {
-              this._cleanup?.();
-              this._cleanup = undefined;
-            })
-          : console.error(err);
-      } catch (e) {
-        err = e;
+      if (this._statusFlags & STATUS_ERROR) {
+        this._modified = true;
+        this._queue.enqueue(this._type, (this._boundRunEffect ??= runEffect.bind(null, this)));
       }
+      return;
+    }
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+      haltReactivity();
+      throw actualError;
     }
-    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw err;
   } else if (this._type === EFFECT_RENDER) {
     this._queue.notify(this, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
     if (_hitUnhandledAsync) {
       resetUnhandledAsync();
-      if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-        const message =
-          "[ASYNC_OUTSIDE_LOADING_BOUNDARY] An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
-        emitDiagnostic({
-          code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
-          kind: "async",
-          severity: "warn",
-          message: message,
-          ownerId: this.id,
-          ownerName: this._name
-        });
-        console.warn(message);
-      }
+      const message =
+        "[ASYNC_OUTSIDE_LOADING_BOUNDARY] An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
+      emitDiagnostic({
+        code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+        kind: "async",
+        severity: "warn",
+        message: message,
+        ownerId: this.id,
+        ownerName: this._name
+      });
+      console.warn(message);
     }
   }
 }
 function runEffect(node) {
   if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
+  if (node._statusFlags & STATUS_ERROR && node._type === EFFECT_USER) {
+    const err = unwrapStatusError(node._error);
+    node._prevValue = node._value;
+    node._modified = false;
+    try {
+      node._errorFn
+        ? node._errorFn(err, () => {
+            const prevCleanup = node._cleanup;
+            node._cleanup = undefined;
+            prevCleanup?.();
+          })
+        : console.error(err);
+    } catch (error) {
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity();
+        throw error;
+      }
+    }
+    return;
+  }
   let prevStrictRead = false;
   {
     prevStrictRead = setStrictRead("an effect callback");
   }
-  node._cleanup?.();
+  const prevCleanup = node._cleanup;
   node._cleanup = undefined;
   try {
+    prevCleanup?.();
     const nextCleanup = node._effectFn(node._value, node._prevValue);
     if (true && nextCleanup !== undefined && typeof nextCleanup !== "function") {
       throw new Error(
@@ -2536,14 +2688,13 @@ function runEffect(node) {
       );
     }
     node._cleanup = nextCleanup;
-    if (node._cleanup && !node._cleanupRegistered) {
-      node._cleanupRegistered = true;
-      runWithOwner(node._parent, () => cleanup(() => node._cleanup?.()));
-    }
   } catch (error) {
     node._error = new StatusError(node, error);
     node._statusFlags |= STATUS_ERROR;
-    if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw error;
+    if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+      haltReactivity();
+      throw error;
+    }
   } finally {
     setStrictRead(prevStrictRead);
     node._prevValue = node._value;
@@ -2564,8 +2715,9 @@ function trackedEffect(fn, options) {
   };
   const node = computed(
     () => {
-      node._cleanup?.();
+      const prevCleanup = node._cleanup;
       node._cleanup = undefined;
+      prevCleanup?.();
       const cleanup = staleValues(fn);
       if (cleanup !== undefined && typeof cleanup !== "function") {
         throw new Error(
@@ -2585,12 +2737,14 @@ function trackedEffect(fn, options) {
     if (actualStatus & STATUS_ERROR) {
       node._queue.notify(node, STATUS_PENDING, 0);
       const err = error !== undefined ? error : node._error;
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity();
+        throw err;
+      }
     }
   };
   node._run = run;
   node._queue.enqueue(EFFECT_USER, run);
-  cleanup(() => node._cleanup?.());
   if (!node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
@@ -2606,6 +2760,9 @@ function trackedEffect(fn, options) {
     console.warn(message);
   }
 }
+const ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE =
+  "[ACTION_CALLED_IN_OWNED_SCOPE] Calling an action inside an owned scope (component, computation) is not allowed. " +
+  "Call it from an event handler or another imperative scope.";
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
   const result = fn();
@@ -2613,34 +2770,47 @@ function restoreTransition(transition, fn) {
   return result;
 }
 function action(genFn) {
-  return (...args) =>
-    new Promise((resolve, reject) => {
+  return (...args) => {
+    {
+      const owner = getOwner();
+      if (owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)) {
+        emitDiagnostic({
+          code: "ACTION_CALLED_IN_OWNED_SCOPE",
+          kind: "write",
+          severity: "error",
+          message: ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE,
+          ownerId: owner.id,
+          ownerName: owner._name
+        });
+        throw new Error(ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE);
+      }
+    }
+    return new Promise((resolve, reject) => {
       const it = genFn(...args);
       globalQueue.initTransition();
       let ctx = activeTransition;
       ctx._actions.push(it);
-      const done = (v, e) => {
+      const done = (v, e, failed = false) => {
         ctx = currentTransition(ctx);
         const i = ctx._actions.indexOf(it);
         if (i >= 0) ctx._actions.splice(i, 1);
         setActiveTransition(ctx);
         schedule();
-        e ? reject(e) : resolve(v);
+        failed ? reject(e) : resolve(v);
       };
       const step = (v, err) => {
         let r;
         try {
           r = err ? it.throw(v) : it.next(v);
         } catch (e) {
-          return done(undefined, e);
+          return done(undefined, e, true);
         }
-        if (r instanceof Promise)
-          return void r.then(run, e => restoreTransition(ctx, () => step(e, true)));
+        if (isThenable(r)) return void r.then(run, e => done(undefined, e, true));
         run(r);
       };
       const run = r => {
         if (r.done) return done(r.value);
-        if (r.value instanceof Promise)
+        if (isThenable(r.value))
           return void r.value.then(
             v => restoreTransition(ctx, () => step(v)),
             e => restoreTransition(ctx, () => step(e, true))
@@ -2649,6 +2819,7 @@ function action(genFn) {
       };
       step();
     });
+  };
 }
 function onCleanup(fn) {
   {
@@ -2727,11 +2898,17 @@ function createReaction(effectFn, options) {
   let cl = undefined;
   cleanup(() => cl?.());
   const owner = getOwner();
+  let arm;
   return tracking => {
+    if (arm) {
+      dispose(arm);
+      arm = undefined;
+    }
     runWithOwner(owner, () => {
       effect(
-        () => (tracking(), getOwner()),
+        () => (tracking(), (arm = getOwner())),
         node => {
+          arm = undefined;
           cl?.();
           const cleanup = (effectFn.effect || effectFn)?.();
           if (true && cleanup !== undefined && typeof cleanup !== "function") {
@@ -2760,15 +2937,18 @@ function resolve(fn) {
   }
   return new Promise((res, rej) => {
     createRoot(dispose => {
-      computed(() => {
-        try {
-          res(fn());
-        } catch (err) {
-          if (err instanceof NotReadyError) throw err;
+      effect(
+        fn,
+        value => {
+          res(value);
+          dispose();
+        },
+        err => {
           rej(err);
-        }
-        dispose();
-      });
+          dispose();
+        },
+        { user: true }
+      );
     });
   });
 }
@@ -2788,27 +2968,110 @@ function onSettled(callback) {
     ? createTrackedEffect(() => untrack(callback), { name: "onSettled" })
     : globalQueue.enqueue(EFFECT_USER, () => {
         const cleanup = callback();
-        if (cleanup !== undefined && typeof cleanup !== "function") {
-          throw new Error(
-            "onSettled callback returned an invalid cleanup value. Return a cleanup function or undefined."
-          );
+        if (cleanup !== undefined) {
+          const message =
+            "[SETTLED_CLEANUP_UNOWNED] onSettled returned a cleanup in an unowned scope; a cleanup can only be honored under an owner. Call your setup helper from an owned scope (e.g. the component body) instead of from inside an event handler, tracked effect, or another onSettled.";
+          emitDiagnostic({
+            code: "SETTLED_CLEANUP_UNOWNED",
+            kind: "lifecycle",
+            severity: "error",
+            message: message
+          });
+          throw new Error(message);
         }
-        cleanup?.();
       });
 }
+function nodeKeys(nodes) {
+  const keys = Object.keys(nodes);
+  if (symbolKeyedRecords.has(nodes)) {
+    const syms = Object.getOwnPropertySymbols(nodes);
+    for (let i = 0, len = syms.length; i < len; i++) {
+      if (syms[i] !== $TRACK) keys.push(syms[i]);
+    }
+  }
+  return keys;
+}
 function unwrap(value) {
-  return value?.[$TARGET]?.[STORE_NODE] ?? value;
+  if (value === null || typeof value !== "object") return value;
+  return value[$TARGET]?.[STORE_VALUE] ?? value;
 }
 function getOverrideValue(value, override, key, optOverride) {
   if (optOverride && key in optOverride) return optOverride[key];
   return override && key in override ? override[key] : value[key];
 }
+function addEnumSymbols(o, syms, keys) {
+  for (let i = 0, len = syms.length; i < len; i++) {
+    if (Object.prototype.propertyIsEnumerable.call(o, syms[i])) keys.add(syms[i]);
+  }
+}
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
   const nextKeys = Object.keys(next);
-  return Array.from(new Set([...keys, ...nextKeys]));
+  const valueSyms = value[$TARGET]
+    ? untrack(() => Object.getOwnPropertySymbols(value))
+    : Object.getOwnPropertySymbols(value);
+  const nextSyms = Object.getOwnPropertySymbols(next);
+  if (valueSyms.length === 0 && nextSyms.length === 0) {
+    if (keys.length === nextKeys.length) {
+      let same = true;
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i] !== nextKeys[i]) {
+          same = false;
+          break;
+        }
+      }
+      if (same) return keys;
+    }
+    const set = new Set(keys);
+    for (let i = 0; i < nextKeys.length; i++) set.add(nextKeys[i]);
+    return Array.from(set);
+  }
+  const set = new Set(keys);
+  addEnumSymbols(value, valueSyms, set);
+  if (override) {
+    for (const key of Reflect.ownKeys(override)) {
+      override[key] === $DELETED ? set.delete(key) : set.add(key);
+    }
+  }
+  for (let i = 0; i < nextKeys.length; i++) set.add(nextKeys[i]);
+  addEnumSymbols(next, nextSyms, set);
+  return Array.from(set);
+}
+function wrapValue(value, target) {
+  return isWrappable(value) ? wrap(value, target) : value;
+}
+function itemKey(item, keyFn) {
+  return isWrappable(item) ? keyFn(item) : item;
+}
+function keyedMatch(a, b, keyFn) {
+  return a === b || (isWrappable(a) && isWrappable(b) && keyFn(a) === keyFn(b));
+}
+function syncArrayNodeMembership(target, next) {
+  let nodes = target[STORE_NODE];
+  if (nodes) {
+    const keys = nodeKeys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      key in next || setSignal(nodes[key], undefined);
+    }
+  }
+  if ((nodes = target[STORE_HAS])) {
+    const keys = nodeKeys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      setSignal(nodes[key], key in next);
+    }
+  }
+}
+function applyArrayItem(next, previous, target, node, keyFn) {
+  if (isWrappable(next) && isWrappable(previous)) {
+    const wrapped = wrap(previous, target);
+    node && setSignal(node, wrapped);
+    applyState(next, wrapped, keyFn);
+  } else node && setSignal(node, wrapValue(next, target));
 }
 function applyState(next, state, keyFn) {
+  next = unwrap(next);
   const target = state?.[$TARGET];
   if (!target) return;
   if (target[STORE_OVERRIDE] || target[STORE_OPTIMISTIC_OVERRIDE]) {
@@ -2826,25 +3089,22 @@ function applyStateFast(next, target, keyFn) {
   if (Array.isArray(previous)) {
     let changed = false;
     const prevLength = previous.length;
-    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
+    if (next.length && prevLength && isWrappable(next[0]) && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
       for (
         start = 0, end = Math.min(prevLength, next.length);
-        start < end &&
-        ((item = previous[start]) === next[start] ||
-          (item && next[start] && keyFn(item) === keyFn(next[start])));
+        start < end && keyedMatch((item = previous[start]), next[start], keyFn);
         start++
       ) {
-        applyState(next[start], wrap(item, target), keyFn);
+        isWrappable(item) &&
+          isWrappable(next[start]) &&
+          applyState(next[start], wrap(item, target), keyFn);
       }
       const temp = new Array(next.length),
         newIndices = new Map();
       for (
         end = prevLength - 1, newEnd = next.length - 1;
-        end >= start &&
-        newEnd >= start &&
-        ((item = previous[end]) === next[newEnd] ||
-          (item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])));
+        end >= start && newEnd >= start && keyedMatch((item = previous[end]), next[newEnd], keyFn);
         end--, newEnd--
       ) {
         temp[newEnd] = item;
@@ -2852,15 +3112,14 @@ function applyStateFast(next, target, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          arrayNodes?.[j] && setSignal(arrayNodes[j], wrap(next[j], target));
+          arrayNodes?.[j] && setSignal(arrayNodes[j], wrapValue(next[j], target));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap(temp[j], target);
-          arrayNodes?.[j] && setSignal(arrayNodes[j], wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyArrayItem(next[j], temp[j], target, arrayNodes?.[j], keyFn);
         }
-        changed && notifySelf(target);
+        syncArrayNodeMembership(target, next);
+        (changed || prevLength !== next.length) && notifySelf(target);
         prevLength !== next.length &&
           arrayNodes?.length &&
           setSignal(arrayNodes.length, next.length);
@@ -2869,14 +3128,14 @@ function applyStateFast(next, target, keyFn) {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = next[j];
-        keyVal = item ? keyFn(item) : item;
+        keyVal = itemKey(item, keyFn);
         i = newIndices.get(keyVal);
         newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
         item = previous[i];
-        keyVal = item ? keyFn(item) : item;
+        keyVal = itemKey(item, keyFn);
         j = newIndices.get(keyVal);
         if (j !== undefined && j !== -1) {
           temp[j] = item;
@@ -2886,22 +3145,22 @@ function applyStateFast(next, target, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap(temp[j], target);
-          arrayNodes?.[j] && setSignal(arrayNodes[j], wrapped);
-          applyState(next[j], wrapped, keyFn);
-        } else arrayNodes?.[j] && setSignal(arrayNodes[j], wrap(next[j], target));
+          applyArrayItem(next[j], temp[j], target, arrayNodes?.[j], keyFn);
+        } else arrayNodes?.[j] && setSignal(arrayNodes[j], wrapValue(next[j], target));
       }
       if (start < next.length) changed = true;
     } else if (next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
         const item = previous[i];
-        if (isWrappable(item)) applyState(next[i], wrap(item, target), keyFn);
+        if (isWrappable(item) && isWrappable(next[i]))
+          applyState(next[i], wrap(item, target), keyFn);
         else {
           if (item !== next[i]) changed = true;
-          arrayNodes?.[i] && setSignal(arrayNodes[i], next[i]);
+          arrayNodes?.[i] && setSignal(arrayNodes[i], wrapValue(next[i], target));
         }
       }
     }
+    syncArrayNodeMembership(target, next);
     if (prevLength !== next.length) {
       changed = true;
       arrayNodes?.length && setSignal(arrayNodes.length, next.length);
@@ -2912,7 +3171,7 @@ function applyStateFast(next, target, keyFn) {
   let nodes = target[STORE_NODE];
   if (nodes) {
     const tracked = nodes[$TRACK];
-    const keys = tracked ? getAllKeys(previous, undefined, next) : Object.keys(nodes);
+    const keys = tracked ? getAllKeys(previous, undefined, next) : nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const node = nodes[key];
@@ -2923,6 +3182,7 @@ function applyStateFast(next, target, keyFn) {
         !previousValue ||
         !isWrappable(previousValue) ||
         !isWrappable(nextValue) ||
+        Array.isArray(previousValue) !== Array.isArray(nextValue) ||
         (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
       ) {
         tracked && setSignal(tracked, void 0);
@@ -2931,7 +3191,7 @@ function applyStateFast(next, target, keyFn) {
     }
   }
   if ((nodes = target[STORE_HAS])) {
-    const keys = Object.keys(nodes);
+    const keys = nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       setSignal(nodes[key], key in next);
@@ -2949,16 +3209,21 @@ function applyStateSlow(next, target, keyFn) {
   if (Array.isArray(previous)) {
     let changed = false;
     const prevLength = getOverrideValue(previous, override, "length", optOverride);
-    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
+    if (next.length && prevLength && isWrappable(next[0]) && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
       for (
         start = 0, end = Math.min(prevLength, next.length);
         start < end &&
-        ((item = getOverrideValue(previous, override, start, optOverride)) === next[start] ||
-          (item && next[start] && keyFn(item) === keyFn(next[start])));
+        keyedMatch(
+          (item = getOverrideValue(previous, override, start, optOverride)),
+          next[start],
+          keyFn
+        );
         start++
       ) {
-        applyState(next[start], wrap(item, target), keyFn);
+        isWrappable(item) &&
+          isWrappable(next[start]) &&
+          applyState(next[start], wrap(item, target), keyFn);
       }
       const temp = new Array(next.length),
         newIndices = new Map();
@@ -2966,8 +3231,11 @@ function applyStateSlow(next, target, keyFn) {
         end = prevLength - 1, newEnd = next.length - 1;
         end >= start &&
         newEnd >= start &&
-        ((item = getOverrideValue(previous, override, end, optOverride)) === next[newEnd] ||
-          (item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])));
+        keyedMatch(
+          (item = getOverrideValue(previous, override, end, optOverride)),
+          next[newEnd],
+          keyFn
+        );
         end--, newEnd--
       ) {
         temp[newEnd] = item;
@@ -2975,30 +3243,29 @@ function applyStateSlow(next, target, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          nodes?.[j] && setSignal(nodes[j], wrap(next[j], target));
+          nodes?.[j] && setSignal(nodes[j], wrapValue(next[j], target));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap(temp[j], target);
-          nodes?.[j] && setSignal(nodes[j], wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyArrayItem(next[j], temp[j], target, nodes?.[j], keyFn);
         }
         const nextLength = next.length;
-        changed && notifySelf(target);
+        syncArrayNodeMembership(target, next);
+        (changed || prevLength !== nextLength) && notifySelf(target);
         prevLength !== nextLength && nodes?.length && setSignal(nodes.length, nextLength);
         return;
       }
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = next[j];
-        keyVal = item ? keyFn(item) : item;
+        keyVal = itemKey(item, keyFn);
         i = newIndices.get(keyVal);
         newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
         item = getOverrideValue(previous, override, i, optOverride);
-        keyVal = item ? keyFn(item) : item;
+        keyVal = itemKey(item, keyFn);
         j = newIndices.get(keyVal);
         if (j !== undefined && j !== -1) {
           temp[j] = item;
@@ -3008,23 +3275,23 @@ function applyStateSlow(next, target, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap(temp[j], target);
-          nodes?.[j] && setSignal(nodes[j], wrapped);
-          applyState(next[j], wrapped, keyFn);
-        } else nodes?.[j] && setSignal(nodes[j], wrap(next[j], target));
+          applyArrayItem(next[j], temp[j], target, nodes?.[j], keyFn);
+        } else nodes?.[j] && setSignal(nodes[j], wrapValue(next[j], target));
       }
       if (start < next.length) changed = true;
     } else if (next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
         const item = getOverrideValue(previous, override, i, optOverride);
-        if (isWrappable(item)) applyState(next[i], wrap(item, target), keyFn);
+        if (isWrappable(item) && isWrappable(next[i]))
+          applyState(next[i], wrap(item, target), keyFn);
         else {
           if (item !== next[i]) changed = true;
-          nodes?.[i] && setSignal(nodes[i], next[i]);
+          nodes?.[i] && setSignal(nodes[i], wrapValue(next[i], target));
         }
       }
     }
     const nextLength = next.length;
+    syncArrayNodeMembership(target, next);
     if (prevLength !== nextLength) {
       changed = true;
       nodes?.length && setSignal(nodes.length, nextLength);
@@ -3034,7 +3301,7 @@ function applyStateSlow(next, target, keyFn) {
   }
   if (nodes) {
     const tracked = nodes[$TRACK];
-    const keys = tracked ? getAllKeys(previous, override, next) : Object.keys(nodes);
+    const keys = tracked ? getAllKeys(previous, override, next) : nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const node = nodes[key];
@@ -3045,6 +3312,7 @@ function applyStateSlow(next, target, keyFn) {
         !previousValue ||
         !isWrappable(previousValue) ||
         !isWrappable(nextValue) ||
+        Array.isArray(previousValue) !== Array.isArray(nextValue) ||
         (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
       ) {
         tracked && setSignal(tracked, void 0);
@@ -3053,7 +3321,7 @@ function applyStateSlow(next, target, keyFn) {
     }
   }
   if ((nodes = target[STORE_HAS])) {
-    const keys = Object.keys(nodes);
+    const keys = nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       setSignal(nodes[key], key in next);
@@ -3193,7 +3461,8 @@ const STORE_VALUE = "v",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
-  STORE_OPTIMISTIC = "p";
+  STORE_OPTIMISTIC = "p",
+  STORE_MASKED = "m";
 const STORE_SELF_PENDING = Symbol("STORE_SELF_PENDING");
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
@@ -3212,6 +3481,7 @@ function createStoreProxy(value, traps = storeTraps, extend) {
   return (newTarget[$PROXY] = new Proxy(newTarget, traps));
 }
 const storeLookup = new WeakMap();
+const symbolKeyedRecords = new WeakSet();
 function wrap(value, target) {
   if (target?.[STORE_WRAP]) return target[STORE_WRAP](value, target);
   let p = value[$PROXY] || storeLookup.get(value);
@@ -3252,21 +3522,26 @@ function unwrapStoreValue(value, map, lookup) {
 function isPrototypePollutionKey$1(property) {
   return property === "__proto__" || property === "constructor" || property === "prototype";
 }
-function hasOwnStoreProperty(target, property) {
-  const optimisticOverride = target[STORE_OPTIMISTIC_OVERRIDE];
-  if (
-    optimisticOverride &&
-    Object.prototype.hasOwnProperty.call(optimisticOverride, property) &&
-    optimisticOverride[property] !== $DELETED
-  )
-    return true;
+function ownEnumerableKeys(o) {
+  return Reflect.ownKeys(o).filter(k => Object.prototype.propertyIsEnumerable.call(o, k));
+}
+function getOverlayLayer(target, property) {
+  const opt = target[STORE_OPTIMISTIC_OVERRIDE];
+  if (opt && property in opt) return opt;
   const override = target[STORE_OVERRIDE];
-  if (
-    override &&
-    Object.prototype.hasOwnProperty.call(override, property) &&
-    override[property] !== $DELETED
-  )
-    return true;
+  if (override && property in override) return override;
+  return undefined;
+}
+function visibleNodeValue(node) {
+  return node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING
+    ? node._overrideValue
+    : node._pendingValue !== NOT_PENDING
+      ? node._pendingValue
+      : node._value;
+}
+function hasOwnStoreProperty(target, property) {
+  const layer = getOverlayLayer(target, property);
+  if (layer) return layer[property] !== $DELETED;
   return Object.prototype.hasOwnProperty.call(unwrapStoreValue(target[STORE_VALUE]), property);
 }
 function hasInheritedAccessor(source, property) {
@@ -3290,7 +3565,24 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     {
       equals: equals,
       unobserved() {
-        if (nodes[property] === s) delete nodes[property];
+        if (nodes[property] === s) {
+          delete nodes[property];
+          if (
+            typeof property === "symbol" &&
+            property !== $TRACK &&
+            symbolKeyedRecords.has(nodes)
+          ) {
+            const syms = Object.getOwnPropertySymbols(nodes);
+            let hasUserSymbol = false;
+            for (let i = 0, len = syms.length; i < len; i++) {
+              if (syms[i] !== $TRACK) {
+                hasUserSymbol = true;
+                break;
+              }
+            }
+            if (!hasUserSymbol) symbolKeyedRecords.delete(nodes);
+          }
+        }
       }
     },
     firewall
@@ -3303,20 +3595,28 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     s._snapshotValue = sv === undefined ? NO_SNAPSHOT : sv;
     snapshotSources?.add(s);
   }
+  if (typeof property === "symbol" && property !== $TRACK) symbolKeyedRecords.add(nodes);
   return (nodes[property] = s);
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() &&
-    read(
-      getNode(
-        getNodes(target, STORE_NODE),
-        symbol,
-        undefined,
-        target[STORE_FIREWALL],
-        false,
-        target[STORE_OPTIMISTIC]
-      )
-    );
+  if (!getObserver()) return;
+  read(
+    getNode(
+      getNodes(target, STORE_NODE),
+      symbol,
+      undefined,
+      target[STORE_FIREWALL],
+      false,
+      target[STORE_OPTIMISTIC]
+    )
+  );
+  if (
+    symbol === $TRACK &&
+    !target[STORE_OVERRIDE] &&
+    !target[STORE_OPTIMISTIC_OVERRIDE] &&
+    target[STORE_VALUE][$TARGET]
+  )
+    target[STORE_VALUE][$TRACK];
 }
 function notifySelf(target) {
   const node = target[STORE_NODE]?.[$TRACK];
@@ -3327,7 +3627,11 @@ function notifySelf(target) {
     );
 }
 function getKeys(source, override, enumerable = true) {
-  const baseKeys = untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)));
+  const baseKeys = source[$TARGET]
+    ? untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)))
+    : enumerable
+      ? Object.keys(source)
+      : Reflect.ownKeys(source);
   if (!override) return baseKeys;
   const keys = new Set(baseKeys);
   const overrides = Reflect.ownKeys(override);
@@ -3341,10 +3645,26 @@ function getPropertyDescriptor(source, override, property) {
   if (override && property in override) {
     if (override[property] === $DELETED) return void 0;
     const overrideDesc = Reflect.getOwnPropertyDescriptor(override, property);
-    if (overrideDesc?.get || overrideDesc?.set || !(property in source)) return overrideDesc;
+    if (overrideDesc?.get || overrideDesc?.set) return overrideDesc;
+    const baseDesc = Reflect.getOwnPropertyDescriptor(source, property);
+    if (!baseDesc) return overrideDesc;
+    if (baseDesc.get || baseDesc.set) return baseDesc;
+    baseDesc.value = override[property];
+    return baseDesc;
   }
   return Reflect.getOwnPropertyDescriptor(source, property);
 }
+function maskStoreTarget(target, on) {
+  const firewall = target[STORE_FIREWALL];
+  if (!firewall) return;
+  if (!!target[STORE_MASKED] === on) return;
+  target[STORE_MASKED] = on;
+  const count = (firewall._optimisticMask = (firewall._optimisticMask || 0) + (on ? 1 : -1));
+  if ((on && count === 1) || (!on && count === 0)) {
+    updatePendingSignal(firewall);
+    updateChildCompanions(firewall);
+  }
+}
 function prepareStoreWrite(target, store, property) {
   if (target[STORE_OPTIMISTIC]) {
     const firewall = target[STORE_FIREWALL];
@@ -3369,9 +3689,14 @@ function prepareStoreWrite(target, store, property) {
   }
   const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
   const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-  if (useOptimistic) trackOptimisticStore(store);
   return { base: base, overrideKey: overrideKey, state: state };
 }
+function armOptimisticStoreWrite(target, store) {
+  if (target[STORE_OPTIMISTIC] && !projectionWriteActive) {
+    trackOptimisticStore(store);
+    maskStoreTarget(target, true);
+  }
+}
 function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
   if (nodes[property]) return nodes[property];
   const initial = isWrappable(prev) ? wrap(prev, target) : prev;
@@ -3449,16 +3774,10 @@ const storeTraps = {
     ) {
       return read(getNode(nodes, property, undefined, target[STORE_FIREWALL]));
     }
-    const optOverridden =
-      target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE];
-    const overridden =
-      optOverridden || (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]);
+    const overlay = getOverlayLayer(target, property);
+    const overridden = !!overlay;
     const proxySource = !!target[STORE_VALUE][$TARGET];
-    const storeValue = optOverridden
-      ? target[STORE_OPTIMISTIC_OVERRIDE]
-      : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-        ? target[STORE_OVERRIDE]
-        : target[STORE_VALUE];
+    const storeValue = overlay ?? target[STORE_VALUE];
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
       if (desc && desc.get) return desc.get.call(receiver);
@@ -3473,13 +3792,7 @@ const storeTraps = {
       if (isPrototypePollutionKey$1(property) && !hasOwnStoreProperty(target, property))
         return undefined;
       let value =
-        tracked && (overridden || !proxySource)
-          ? tracked._overrideValue !== undefined && tracked._overrideValue !== NOT_PENDING
-            ? tracked._overrideValue
-            : tracked._pendingValue !== NOT_PENDING
-              ? tracked._pendingValue
-              : tracked._value
-          : storeValue[property];
+        tracked && (overridden || !proxySource) ? visibleNodeValue(tracked) : storeValue[property];
       value === $DELETED && (value = undefined);
       if (!isWrappable(value)) return value;
       const wrapped = wrap(value, target);
@@ -3493,7 +3806,11 @@ const storeTraps = {
       : storeValue[property];
     value === $DELETED && (value = undefined);
     if (!tracked) {
-      if (!overridden && typeof value === "function" && !storeValue.hasOwnProperty(property)) {
+      if (
+        !overridden &&
+        typeof value === "function" &&
+        !Object.prototype.hasOwnProperty.call(storeValue, property)
+      ) {
         let proto;
         return !Array.isArray(target[STORE_VALUE]) &&
           (proto = Object.getPrototypeOf(target[STORE_VALUE])) &&
@@ -3532,12 +3849,8 @@ const storeTraps = {
   },
   has(target, property) {
     if (property === $PROXY || property === $TRACK || property === "__proto__") return true;
-    const has =
-      target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
-        ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
-        : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-          ? target[STORE_OVERRIDE][property] !== $DELETED
-          : property in target[STORE_VALUE];
+    const hasLayer = getOverlayLayer(target, property);
+    const has = hasLayer ? hasLayer[property] !== $DELETED : property in target[STORE_VALUE];
     if (writeOnly(target[$PROXY]) || getObserver() === target[STORE_FIREWALL]) return has;
     const nodes = getNodes(target, STORE_HAS);
     if (nodes[property]) return read(nodes[property]);
@@ -3558,30 +3871,24 @@ const storeTraps = {
           overrideKey: overrideKey,
           state: state
         } = prepareStoreWrite(target, store, property);
-        const prev =
-          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
-            ? target[STORE_OPTIMISTIC_OVERRIDE][property]
-            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE][property]
-              : base;
-        const prevHas =
-          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
-            ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
-            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE][property] !== $DELETED
-              : property in target[STORE_VALUE];
+        const prevLayer = getOverlayLayer(target, property);
+        const prev = prevLayer ? prevLayer[property] : base;
+        const prevHas = prevLayer
+          ? prevLayer[property] !== $DELETED
+          : property in target[STORE_VALUE];
         const value = unwrapStoreValue(rawValue);
-        const isArrayIndexWrite = Array.isArray(state) && property !== "length";
-        const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
-        const len =
-          isArrayIndexWrite &&
-          (target[STORE_OPTIMISTIC_OVERRIDE] && "length" in target[STORE_OPTIMISTIC_OVERRIDE]
-            ? target[STORE_OPTIMISTIC_OVERRIDE].length
-            : target[STORE_OVERRIDE] && "length" in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE].length
-              : state.length);
+        const index = typeof property === "string" ? Number(property) : -1;
+        const isArrayIndexWrite =
+          Array.isArray(state) &&
+          Number.isInteger(index) &&
+          index >= 0 &&
+          index < 4294967295 &&
+          String(index) === property;
+        const nextIndex = isArrayIndexWrite ? index + 1 : 0;
+        const len = isArrayIndexWrite && (getOverlayLayer(target, "length") ?? state).length;
         const nextLength = isArrayIndexWrite && nextIndex > len ? nextIndex : undefined;
         if (prev === value && nextLength === undefined) return true;
+        armOptimisticStoreWrite(target, store);
         if (value !== undefined && value === base && nextLength === undefined)
           delete target[overrideKey]?.[property];
         else {
@@ -3590,6 +3897,22 @@ const storeTraps = {
           if (nextLength !== undefined) override.length = nextLength;
         }
         notifyStoreProperty(target, property, "set", value, prev, prevHas);
+        if (
+          Array.isArray(state) &&
+          property === "length" &&
+          typeof value === "number" &&
+          typeof prev === "number" &&
+          value < prev
+        ) {
+          const override = target[overrideKey] || (target[overrideKey] = Object.create(null));
+          for (let i = value; i < prev; i++) {
+            if (override[i] === $DELETED) continue;
+            const prevIndex = i in override ? override[i] : state[i];
+            if (!(i in override) && !(i in state)) continue;
+            override[i] = $DELETED;
+            notifyStoreProperty(target, i, "delete", undefined, prevIndex, true);
+          }
+        }
         if (Array.isArray(state) && property !== "length" && nextLength !== undefined) {
           const nodes = getNodes(target, STORE_NODE);
           if (nodes.length) {
@@ -3616,6 +3939,7 @@ const storeTraps = {
     if (writeOnly(store)) {
       untrack(() => {
         const { base: base, overrideKey: overrideKey } = prepareStoreWrite(target, store, property);
+        armOptimisticStoreWrite(target, store);
         const normalizedDescriptor =
           "value" in descriptor
             ? { ...descriptor, value: unwrapStoreValue(descriptor.value) }
@@ -3645,19 +3969,16 @@ const storeTraps = {
       untrack(() => {
         const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
         const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-        if (useOptimistic) trackOptimisticStore(target[$PROXY]);
-        const prev =
-          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
-            ? target[STORE_OPTIMISTIC_OVERRIDE][property]
-            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE][property]
-              : target[STORE_VALUE][property];
+        const prevLayer = getOverlayLayer(target, property);
+        const prev = prevLayer ? prevLayer[property] : target[STORE_VALUE][property];
         if (
           property in target[STORE_VALUE] ||
           (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE])
         ) {
+          armOptimisticStoreWrite(target, target[$PROXY]);
           (target[overrideKey] || (target[overrideKey] = Object.create(null)))[property] = $DELETED;
         } else if (target[overrideKey] && property in target[overrideKey]) {
+          armOptimisticStoreWrite(target, target[$PROXY]);
           delete target[overrideKey][property];
         } else return true;
         notifyStoreProperty(target, property, "delete", undefined, prev, true);
@@ -3686,7 +4007,13 @@ const storeTraps = {
       if (optDesc?.get || optDesc?.set || !(property in target[STORE_VALUE])) return optDesc;
       const baseDesc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
       if (baseDesc) {
-        return { ...baseDesc, value: target[STORE_OPTIMISTIC_OVERRIDE][property] };
+        const targetDesc = Reflect.getOwnPropertyDescriptor(target, property);
+        const configurable = !targetDesc || targetDesc.configurable ? true : baseDesc.configurable;
+        return {
+          ...baseDesc,
+          configurable: configurable,
+          value: target[STORE_OPTIMISTIC_OVERRIDE][property]
+        };
       }
       return {
         value: target[STORE_OPTIMISTIC_OVERRIDE][property],
@@ -3695,7 +4022,12 @@ const storeTraps = {
         configurable: true
       };
     }
-    return getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
+    const desc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
+    if (desc && !desc.configurable) {
+      const targetDesc = Reflect.getOwnPropertyDescriptor(target, property);
+      if (!targetDesc || targetDesc.configurable) return { ...desc, configurable: true };
+    }
+    return desc;
   },
   getPrototypeOf(target) {
     return Object.getPrototypeOf(target[STORE_VALUE]);
@@ -3712,7 +4044,7 @@ function storeSetter(store, fn) {
         for (let i = 0, len = value.length; i < len; i++) store[i] = value[i];
         store.length = value.length;
       } else {
-        const keys = new Set([...Object.keys(store), ...Object.keys(value)]);
+        const keys = new Set([...ownEnumerableKeys(store), ...ownEnumerableKeys(value)]);
         keys.forEach(key => {
           if (key in value) store[key] = value[key];
           else delete store[key];
@@ -3748,12 +4080,15 @@ function createOptimisticStore(first, second, options) {
 }
 function clearOptimisticStore(store) {
   const target = store[$TARGET];
-  if (!target || !target[STORE_OPTIMISTIC_OVERRIDE]) return;
+  if (!target) return;
+  maskStoreTarget(target, false);
+  if (!target[STORE_OPTIMISTIC_OVERRIDE]) return;
   clearOptimisticOverride(target);
 }
 function clearOptimisticOverride(target) {
   const override = target[STORE_OPTIMISTIC_OVERRIDE];
   if (!override) return;
+  maskStoreTarget(target, false);
   const nodes = target[STORE_NODE];
   delete target[STORE_OPTIMISTIC_OVERRIDE];
   const wasProjectionWriteActive = projectionWriteActive;
@@ -3764,18 +4099,11 @@ function clearOptimisticOverride(target) {
         if (nodes[key]) {
           const node = nodes[key];
           node._optimisticLane = undefined;
-          const baseValue =
-            target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE][key]
-              : target[STORE_VALUE][key];
+          const layer = getOverlayLayer(target, key);
+          const baseValue = layer ? layer[key] : target[STORE_VALUE][key];
           const value = baseValue === $DELETED ? undefined : baseValue;
           const next = isWrappable(value) ? wrap(value, target) : value;
-          const prev =
-            node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING
-              ? node._overrideValue
-              : node._pendingValue !== NOT_PENDING
-                ? node._pendingValue
-                : node._value;
+          const prev = visibleNodeValue(node);
           node._overrideValue = NOT_PENDING;
           node._pendingValue = NOT_PENDING;
           node._value = next;
@@ -3907,10 +4235,10 @@ function updatePath(current, args, i = 0) {
     (isWrappable(prev) && isWrappable(value) && !Array.isArray(value))
   ) {
     const target = part !== undefined ? current[part] : current;
-    const keys = Object.keys(value);
+    const keys = ownEnumerableKeys(value);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
-      if (isPrototypePollutionKey(key)) continue;
+      if (typeof key === "string" && isPrototypePollutionKey(key)) continue;
       const desc = Object.getOwnPropertyDescriptor(value, key);
       if (desc.get || desc.set) Object.defineProperty(target, key, desc);
       else target[key] = desc.value;
@@ -3927,6 +4255,11 @@ const storePath = Object.assign(
   },
   { DELETE: DELETE }
 );
+function mergedOverlay(target) {
+  const override = target[STORE_OVERRIDE];
+  const opt = target[STORE_OPTIMISTIC_OVERRIDE];
+  return override && opt ? { ...override, ...opt } : (opt ?? override);
+}
 function snapshotImpl(item, track, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
   if (!isWrappable(item)) return item;
@@ -3934,7 +4267,7 @@ function snapshotImpl(item, track, map, lookup) {
   if (!map) map = new Map();
   if ((target = item[$TARGET] || lookup?.get(item)?.[$TARGET])) {
     if (track) trackSelf(target, $TRACK);
-    override = target[STORE_OVERRIDE];
+    override = mergedOverlay(target);
     isArray = Array.isArray(target[STORE_VALUE]);
     map.set(
       item,
@@ -3959,13 +4292,30 @@ function snapshotImpl(item, track, map, lookup) {
         result[i] = unwrapped;
       }
     }
+    if (result) result.length = len;
+  } else if (!override) {
+    const keys = getKeys(item, undefined);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const prop = keys[i];
+      const desc = Object.getOwnPropertyDescriptor(item, prop);
+      if (desc.get) continue;
+      v = desc.value;
+      if (track && isWrappable(v)) wrap(v, target);
+      if ((unwrapped = snapshotImpl(v, track, map, lookup)) !== v || result) {
+        if (!result) {
+          result = Object.create(Object.getPrototypeOf(item));
+          Object.assign(result, item);
+        }
+        result[prop] = unwrapped;
+      }
+    }
   } else {
     const keys = getKeys(item, override);
     for (let i = 0, l = keys.length; i < l; i++) {
       let prop = keys[i];
       const desc = getPropertyDescriptor(item, override, prop);
       if (desc.get) continue;
-      v = override && prop in override ? override[prop] : item[prop];
+      v = prop in override ? override[prop] : item[prop];
       if (track && isWrappable(v)) wrap(v, target);
       if ((unwrapped = snapshotImpl(v, track, map, lookup)) !== item[prop] || result) {
         if (!result) {
@@ -4048,7 +4398,7 @@ function merge(...sources) {
         keys() {
           const keys = new Set();
           for (let i = 0; i < flattened.length; i++) {
-            const sourceKeys = Object.keys(resolveSource(flattened[i]));
+            const sourceKeys = ownEnumerableKeys(resolveSource(flattened[i]));
             for (let j = 0; j < sourceKeys.length; j++) keys.add(sourceKeys[j]);
           }
           return [...keys];
@@ -4102,7 +4452,7 @@ function omit(props, ...keys) {
           return !keys.includes(property) && property in props;
         },
         keys() {
-          return Object.keys(props).filter(k => !keys.includes(k));
+          return ownEnumerableKeys(props).filter(k => !keys.includes(k));
         }
       },
       propTraps
@@ -4331,6 +4681,18 @@ function updateRepeat() {
     const to = from + newLen;
     const prevTo = this._offset + this._len;
     if (this._len === 0 && this._nodes[0]) this._nodes[0].dispose();
+    if (from >= prevTo || to <= this._offset) {
+      for (let i = 0; i < this._len; i++) this._nodes[i].dispose();
+      this._nodes = new Array(newLen);
+      this._mappings = new Array(newLen);
+      for (let i = 0; i < newLen; i++)
+        this._mappings[i] = runWithOwner((this._nodes[i] = createOwner()), () =>
+          this._map(from + i)
+        );
+      this._offset = from;
+      this._len = newLen;
+      return;
+    }
     for (let i = to; i < prevTo; i++) this._nodes[i - this._offset].dispose();
     if (this._offset < from) {
       const removed = from - this._offset;
@@ -4372,7 +4734,13 @@ function boundaryComputed(fn, propagationMask) {
     const flags = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
     node._statusFlags &= ~node._propagationMask;
-    node._queue.notify(node, node._propagationMask, flags, actualError);
+    node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, flags, actualError);
+    const foreign = flags & ~node._propagationMask & (STATUS_PENDING | STATUS_ERROR);
+    if (foreign) {
+      node._statusFlags &= ~foreign;
+      if (node._error === actualError && !(node._statusFlags & (STATUS_PENDING | STATUS_ERROR)))
+        node._error = undefined;
+    }
   };
   node._propagationMask = propagationMask;
   node._config &= ~CONFIG_AUTO_DISPOSE;
@@ -4566,9 +4934,6 @@ class CollectionQueue extends Queue {
     }
     if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
-    if (this._collectionType & STATUS_PENDING && flags & STATUS_ERROR) {
-      return super.notify(node, STATUS_ERROR, flags, error);
-    }
     if (flags & this._collectionType) {
       this._pending = true;
       const source = error?.source || node._error?.source;
@@ -4577,7 +4942,7 @@ class CollectionQueue extends Queue {
         this._sources.add(source);
         if (wasEmpty) setSignal(this._disabled, true);
         if (this._collectionType & STATUS_ERROR) {
-          setSignal(this._error, source._error?.cause ?? source._error);
+          setSignal(this._error, unwrapStatusError(source._error));
         }
       }
     }
@@ -4655,14 +5020,17 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
     cleanup(() => controller.unregister(queue));
   }
   return accessor(
-    computed(() => {
-      if (!read(queue._disabled)) {
-        const resolved = read(tree);
-        if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
-      }
-      if (_revealUsed && read(queue._collapsed)) return undefined;
-      return fallback(queue);
-    })
+    computed(
+      () => {
+        if (!read(queue._disabled)) {
+          const resolved = read(tree);
+          if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
+        }
+        if (_revealUsed && read(queue._collapsed)) return undefined;
+        return fallback(queue);
+      },
+      { _noSnapshot: true }
+    )
   );
 }
 function createLoadingBoundary(fn, fallback, options) {
@@ -4809,6 +5177,7 @@ export {
   refresh,
   releaseSnapshotScope,
   repeat,
+  resetErrorHalt,
   resolve,
   runWithOwner,
   setContext,