@solidjs/signals 2.0.0-beta.14 → 2.0.0-beta.16

package/dist/dev.js

@@ -140,106 +140,21 @@ function getObservers(node) {
   }
   return observers;
 }
-function actualInsertIntoHeap(n, heap) {
-  const parentHeight =
-    (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
-  if (parentHeight >= n._height) n._height = parentHeight + 1;
-  const height = n._height;
-  const heapAtHeight = heap._heap[height];
-  if (heapAtHeight === undefined) heap._heap[height] = n;
-  else {
-    const tail = heapAtHeight._prevHeap;
-    tail._nextHeap = n;
-    n._prevHeap = tail;
-    heapAtHeight._prevHeap = n;
-  }
-  if (height > heap._max) heap._max = height;
-}
-function insertIntoHeap(n, heap) {
-  let flags = n._flags;
-  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
-  if (flags & REACTIVE_CHECK) {
-    n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else n._flags = flags | REACTIVE_IN_HEAP;
-  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
+function createAsyncReporters() {
+  return new Map();
 }
-function insertIntoHeapHeight(n, heap) {
-  let flags = n._flags;
-  if (
-    flags &
-    (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)
-  )
-    return;
-  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
-  actualInsertIntoHeap(n, heap);
+function devCheckActiveOverrides(isRegisteredForRevert) {
+  return;
 }
-function deleteFromHeap(n, heap) {
-  const flags = n._flags;
-  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  n._flags = flags & -25;
-  const height = n._height;
-  if (n._prevHeap === n) heap._heap[height] = undefined;
-  else {
-    const next = n._nextHeap;
-    const dhh = heap._heap[height];
-    const end = next ?? dhh;
-    if (n === dhh) heap._heap[height] = next;
-    else n._prevHeap._nextHeap = next;
-    end._prevHeap = n._prevHeap;
-  }
-  n._prevHeap = n;
-  n._nextHeap = undefined;
-}
-function markHeap(heap) {
-  if (heap._marked) return;
-  heap._marked = true;
-  for (let i = 0; i <= heap._max; i++) {
-    for (let el = heap._heap[i]; el !== undefined; el = el._nextHeap) {
-      if (el._flags & REACTIVE_IN_HEAP) markNode(el);
-    }
-  }
-}
-function markNode(el, newState = REACTIVE_DIRTY) {
-  const flags = el._flags;
-  if ((flags & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= newState) return;
-  el._flags = (flags & -4) | newState;
-  for (let link = el._subs; link !== null; link = link._nextSub) {
-    markNode(link._sub, REACTIVE_CHECK);
-  }
-  if (el._child !== null) {
-    for (let child = el._child; child !== null; child = child._nextChild) {
-      for (let link = child._subs; link !== null; link = link._nextSub) {
-        markNode(link._sub, REACTIVE_CHECK);
-      }
-    }
-  }
+function devCheckFlushStart() {
+  return;
 }
-function runHeap(heap, recompute) {
-  heap._marked = false;
-  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
-    let el = heap._heap[heap._min];
-    while (el !== undefined) {
-      if (el._flags & REACTIVE_IN_HEAP) recompute(el);
-      else adjustHeight(el, heap);
-      el = heap._heap[heap._min];
-    }
-  }
-  heap._max = 0;
+typeof globalThis !== "undefined" && !!globalThis.process?.env?.COMPANION_CENSUS;
+function devCensusCompanions(isQueuedForCommit) {
+  return;
 }
-function adjustHeight(el, heap) {
-  deleteFromHeap(el, heap);
-  let newHeight = el._height;
-  for (let d = el._deps; d; d = d._nextDep) {
-    const dep1 = d._dep;
-    const dep = dep1._firewall || dep1;
-    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
-  }
-  if (el._height !== newHeight) {
-    el._height = newHeight;
-    for (let s = el._subs; s !== null; s = s._nextSub) {
-      insertIntoHeapHeight(s._sub, heap);
-    }
-  }
+function devCheckQuiescent(isQueuedForCommit) {
+  return;
 }
 const signalLanes = new WeakMap();
 const activeLanes = new Set();
@@ -260,7 +175,6 @@ function getOrCreateLane(signal) {
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
-  signal._overrideSinceLane = false;
   return lane;
 }
 function findLane(lane) {
@@ -273,8 +187,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) {
@@ -318,6 +235,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;
@@ -406,19 +325,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) {
@@ -439,10 +363,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 = [[], []];
@@ -520,6 +475,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);
@@ -583,6 +539,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;
@@ -614,7 +588,7 @@ class GlobalQueue extends Queue {
       activeTransition = transition ?? {
         _time: clock,
         _pendingNodes: [],
-        _asyncReporters: new Map(),
+        _asyncReporters: createAsyncReporters(),
         _optimisticNodes: [],
         _optimisticStores: new Set(),
         _actions: [],
@@ -710,6 +684,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) {
@@ -721,6 +696,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) {
@@ -796,8 +772,11 @@ function flush(fn) {
     try {
       return fn();
     } finally {
-      flush();
-      syncDepth--;
+      try {
+        flush();
+      } finally {
+        syncDepth--;
+      }
     }
   }
   if (globalQueue._running) {
@@ -808,6 +787,7 @@ function flush(fn) {
     }
     return;
   }
+  if (halted) return;
   let count = 0;
   while (scheduled || activeTransition) {
     if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
@@ -859,8 +839,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;
@@ -886,24 +865,127 @@ function runInTransition(transition, fn) {
     activeTransition = prevTransition;
   }
 }
+function actualInsertIntoHeap(n, heap) {
+  const parentHeight =
+    (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
+  if (parentHeight >= n._height) n._height = parentHeight + 1;
+  const height = n._height;
+  const heapAtHeight = heap._heap[height];
+  if (heapAtHeight === undefined) heap._heap[height] = n;
+  else {
+    const tail = heapAtHeight._prevHeap;
+    tail._nextHeap = n;
+    n._prevHeap = tail;
+    heapAtHeight._prevHeap = n;
+  }
+  if (height > heap._max) heap._max = height;
+}
+function insertIntoHeap(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
+  if (flags & REACTIVE_CHECK) {
+    n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else n._flags = flags | REACTIVE_IN_HEAP;
+  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
+}
+function insertIntoHeapHeight(n, heap) {
+  let flags = n._flags;
+  if (
+    flags &
+    (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)
+  )
+    return;
+  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(n, heap);
+}
+function deleteFromHeap(n, heap) {
+  const flags = n._flags;
+  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  n._flags = flags & -25;
+  const height = n._height;
+  if (n._prevHeap === n) heap._heap[height] = undefined;
+  else {
+    const next = n._nextHeap;
+    const dhh = heap._heap[height];
+    const end = next ?? dhh;
+    if (n === dhh) heap._heap[height] = next;
+    else n._prevHeap._nextHeap = next;
+    end._prevHeap = n._prevHeap;
+  }
+  n._prevHeap = n;
+  n._nextHeap = undefined;
+}
+function markHeap(heap) {
+  if (heap._marked) return;
+  heap._marked = true;
+  for (let i = 0; i <= heap._max; i++) {
+    for (let el = heap._heap[i]; el !== undefined; el = el._nextHeap) {
+      if (el._flags & REACTIVE_IN_HEAP) markNode(el);
+    }
+  }
+}
+function markNode(el, newState = REACTIVE_DIRTY) {
+  const flags = el._flags;
+  if ((flags & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= newState) return;
+  el._flags = (flags & -4) | newState;
+  for (let link = el._subs; link !== null; link = link._nextSub) {
+    markNode(link._sub, REACTIVE_CHECK);
+  }
+  if (el._child !== null) {
+    for (let child = el._child; child !== null; child = child._nextChild) {
+      for (let link = child._subs; link !== null; link = link._nextSub) {
+        markNode(link._sub, REACTIVE_CHECK);
+      }
+    }
+  }
+}
+function runHeap(heap, recompute) {
+  heap._marked = false;
+  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
+    let el = heap._heap[heap._min];
+    while (el !== undefined) {
+      if (el._flags & REACTIVE_IN_HEAP) recompute(el);
+      else adjustHeight(el, heap);
+      el = heap._heap[heap._min];
+    }
+  }
+  heap._max = 0;
+}
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el._height;
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep1 = d._dep;
+    const dep = dep1._firewall || dep1;
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
+  }
+  if (el._height !== newHeight) {
+    el._height = newHeight;
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    }
+  }
+}
 const PENDING_OWNER = {};
 function markDisposal(el) {
   let child = el._firstChild;
   while (child) {
-    child._flags |= REACTIVE_ZOMBIE;
-    if (child._flags & REACTIVE_IN_HEAP) {
-      deleteFromHeap(child, dirtyQueue);
-      insertIntoHeap(child, zombieQueue);
+    const flags = child._flags;
+    child._flags = flags | REACTIVE_ZOMBIE;
+    if (flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) {
+      deleteFromHeap(child, flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      if (flags & REACTIVE_IN_HEAP) insertIntoHeap(child, zombieQueue);
+      else insertIntoHeapHeight(child, zombieQueue);
     }
     markDisposal(child);
     child = child._nextSibling;
   }
 }
 function dispose(node) {
-  let toRemove = node._deps || null;
-  do {
+  let toRemove = node._deps;
+  while (toRemove !== null) {
     toRemove = unlinkSubs(toRemove);
-  } while (toRemove !== null);
+  }
   node._deps = null;
   node._depsTail = null;
   disposeChildren(node, true);
@@ -911,7 +993,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;
@@ -951,6 +1037,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;
@@ -1092,42 +1183,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) {
@@ -1177,9 +1275,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) {
@@ -1198,17 +1309,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;
@@ -1218,23 +1319,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({
@@ -1264,37 +1368,45 @@ function handleAsync(el, result, setter) {
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
-    if (setter) setter(value);
-    else if (el._overrideValue !== undefined) {
-      if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
-        el._pendingValue = value;
-      else {
-        el._value = value;
-        insertSubs(el);
-      }
+    if (setter) {
+      setter(value);
+      if (wasUninitialized) clearStatus(el, true);
+    } else if (el._overrideValue !== undefined) {
+      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 => {
@@ -1304,11 +1416,17 @@ 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);
     }
@@ -1322,9 +1440,7 @@ function handleAsync(el, result, setter) {
       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 = () => {
@@ -1374,7 +1490,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) {
@@ -1402,6 +1519,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       el._error = error;
     }
     updatePendingSignal(el);
+    if (el._child) updateChildCompanions(el);
   }
   if (lane && !blockStatus) {
     assignOrMergeLane(el, lane);
@@ -1419,7 +1537,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
     return;
   }
-  forEachDependent(el, sub => {
+  forEachDependent(el, (sub, link) => {
     sub._time = clock;
     if (
       (status === STATUS_PENDING &&
@@ -1429,6 +1547,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);
     }
@@ -1461,15 +1584,19 @@ GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
 const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE =
   "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
+const REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE =
+  "[REACTIVE_WRITE_IN_OWNED_SCOPE] Writing to reactive state inside an owned scope (component, computation) is not allowed. " +
+  "Move the write outside or set the `ownedWrite` option if this is intentional.";
+const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE =
+  "[REACTIVE_WRITE_IN_OWNED_SCOPE] Calling refresh() inside an owned scope (component, computation) is not allowed. " +
+  "Move the invalidation outside pure computation.";
 let tracking = false;
 let stale = false;
-let refreshing = 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) {
@@ -1542,11 +1669,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;
@@ -1629,26 +1757,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) {
@@ -1664,8 +1801,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 &&
@@ -1704,6 +1840,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,
@@ -1719,6 +1856,7 @@ function computed(fn, options) {
     _prevHeap: null,
     _deps: null,
     _depsTail: null,
+    _depGen: 0,
     _subs: null,
     _subsTail: null,
     _parent: context,
@@ -1763,6 +1901,7 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _prevHeap: null,
     _deps: null,
     _depsTail: null,
+    _depGen: 0,
     _subs: null,
     _subsTail: null,
     _parent: context,
@@ -1782,7 +1921,6 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _effectFn: effectFn,
     _errorFn: errorFn,
     _cleanup: undefined,
-    _cleanupRegistered: false,
     _type: type,
     _notifyStatus: notifyStatus
   };
@@ -1830,7 +1968,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);
     }
@@ -1899,6 +2037,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);
@@ -1912,7 +2060,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;
@@ -1927,59 +2076,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 &&
@@ -2010,7 +2125,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)) {
@@ -2060,7 +2175,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;
@@ -2099,7 +2214,7 @@ function read(el) {
     currentOptimisticLane !== null &&
     !latestReadActive &&
     el._pendingValue !== NOT_PENDING &&
-    owner === el &&
+    (owner === el || !!(owner._flags & REACTIVE_MANUAL_WRITE)) &&
     !el._fn &&
     c
   ) {
@@ -2111,12 +2226,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 &&
@@ -2136,19 +2258,17 @@ function setSignal(el, v) {
     context &&
     el._firewall !== context
   ) {
-    const message =
-      "[SIGNAL_WRITE_IN_OWNED_SCOPE] Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
-      "Move the write outside or set the `ownedWrite` option if this is intentional.";
     emitDiagnostic({
-      code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
+      code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
       kind: "write",
       severity: "error",
-      message: message,
+      message: REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
       ownerId: context.id,
       ownerName: context._name,
-      nodeName: el._name
+      nodeName: el._name,
+      data: { operation: "setSignal" }
     });
-    throw new Error(message);
+    throw new Error(REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE);
   }
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
@@ -2163,22 +2283,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 && el._fn) {
-      insertSubs(el, true);
-      schedule();
+    if (isOptimistic && hasOverride) {
+      const transition = resolveTransition(el);
+      if (transition && activeTransition !== transition) globalQueue.initTransition(transition);
     }
     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;
@@ -2186,10 +2302,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();
@@ -2197,8 +2310,10 @@ function setSignal(el, v) {
 }
 function suppressComputedRecompute(el) {
   deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  if (!(el._flags & REACTIVE_MANUAL_WRITE) && el._pendingValue === NOT_PENDING)
+  if (!(el._flags & REACTIVE_MANUAL_WRITE) && el._pendingValue === NOT_PENDING) {
     queuePendingNode(el);
+    schedule();
+  }
   el._flags = (el._flags & -4) | REACTIVE_MANUAL_WRITE;
 }
 function setMemo(el, v) {
@@ -2234,61 +2349,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._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;
+    return (
+      !!(firewall._flags & REACTIVE_MANUAL_WRITE) ||
+      (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING))
+    );
   }
   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) {
@@ -2327,18 +2463,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;
@@ -2348,26 +2482,23 @@ 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) {
-  let prevRefreshing = refreshing;
-  refreshing = true;
-  try {
-    const node = target?.[$REFRESH];
-    if (true && !node) {
+  const node = target?.[$REFRESH];
+  if (!node) {
+    {
       const message =
         "[INVALID_REFRESH_TARGET] refresh() expects a Solid source accessor or refreshable store. " +
         "Pass the original source target, not a wrapper function or derived property read.";
@@ -2379,18 +2510,32 @@ function refresh(target) {
       });
       throw new Error(message);
     }
-    if (node && typeof node._fn === "function" && !(node._flags & REACTIVE_DISPOSED)) {
-      recompute(node);
-    }
-  } finally {
-    refreshing = prevRefreshing;
-    if (!prevRefreshing) {
-      schedule();
-    }
   }
-}
-function isRefreshing() {
-  return refreshing;
+  if (
+    context &&
+    !((node._config ?? 0) & CONFIG_OWNED_WRITE) &&
+    !(context._config & CONFIG_CHILDREN_FORBIDDEN)
+  ) {
+    emitDiagnostic({
+      code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
+      kind: "write",
+      severity: "error",
+      message: REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE,
+      ownerId: context.id,
+      ownerName: context._name,
+      nodeName: node._name,
+      data: { operation: "refresh" }
+    });
+    throw new Error(REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE);
+  }
+  if (
+    typeof node._fn === "function" &&
+    !(node._flags & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))
+  ) {
+    node._flags = (node._flags & ~REACTIVE_CHECK) | REACTIVE_DIRTY;
+    insertIntoHeap(node, node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    schedule();
+  }
 }
 function createContext(defaultValue, description) {
   return { id: Symbol(description), defaultValue: defaultValue };
@@ -2454,50 +2599,67 @@ 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 =
+      node._error instanceof StatusError ? (node._error.cause ?? node._error) : 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(
@@ -2505,14 +2667,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;
@@ -2533,8 +2694,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(
@@ -2554,12 +2716,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";
@@ -2603,13 +2767,12 @@ function action(genFn) {
         } catch (e) {
           return done(undefined, e);
         }
-        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));
         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))
@@ -2729,15 +2892,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 }
+      );
     });
   });
 }
@@ -2757,27 +2923,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]) {
@@ -2789,30 +3038,28 @@ function applyState(next, state, keyFn) {
 function applyStateFast(next, target, keyFn) {
   const previous = target[STORE_VALUE];
   if (next === previous) return;
+  const arrayNodes = target[STORE_NODE];
   (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
   target[STORE_VALUE] = next;
   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;
@@ -2820,31 +3067,30 @@ function applyStateFast(next, target, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][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);
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyArrayItem(next[j], temp[j], target, arrayNodes?.[j], keyFn);
         }
-        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+        syncArrayNodeMembership(target, next);
+        (changed || prevLength !== next.length) && notifySelf(target);
         prevLength !== next.length &&
-          target[STORE_NODE].length &&
-          setSignal(target[STORE_NODE].length, next.length);
+          arrayNodes?.length &&
+          setSignal(arrayNodes.length, next.length);
         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 = previous[i];
-        keyVal = item ? keyFn(item) : item;
+        keyVal = itemKey(item, keyFn);
         j = newIndices.get(keyVal);
         if (j !== undefined && j !== -1) {
           temp[j] = item;
@@ -2854,31 +3100,33 @@ function applyStateFast(next, target, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         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);
-        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][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];
-        isWrappable(item)
-          ? applyState(next[i], wrap(item, target), keyFn)
-          : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
+        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], wrapValue(next[i], target));
+        }
       }
     }
+    syncArrayNodeMembership(target, next);
     if (prevLength !== next.length) {
       changed = true;
-      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+      arrayNodes?.length && setSignal(arrayNodes.length, next.length);
     }
-    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+    changed && notifySelf(target);
     return;
   }
   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];
@@ -2889,6 +3137,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);
@@ -2897,7 +3146,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);
@@ -2915,16 +3164,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();
@@ -2932,8 +3186,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;
@@ -2941,31 +3198,29 @@ function applyStateSlow(next, target, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][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);
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyArrayItem(next[j], temp[j], target, nodes?.[j], keyFn);
         }
-        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
-        prevLength !== next.length &&
-          target[STORE_NODE].length &&
-          setSignal(target[STORE_NODE].length, next.length);
+        const nextLength = next.length;
+        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;
@@ -2975,30 +3230,33 @@ function applyStateSlow(next, target, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         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);
-        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][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);
-        isWrappable(item)
-          ? applyState(next[i], wrap(item, target), keyFn)
-          : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
+        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], wrapValue(next[i], target));
+        }
       }
     }
-    if (prevLength !== next.length) {
+    const nextLength = next.length;
+    syncArrayNodeMembership(target, next);
+    if (prevLength !== nextLength) {
       changed = true;
-      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+      nodes?.length && setSignal(nodes.length, nextLength);
     }
-    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+    changed && notifySelf(target);
     return;
   }
   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];
@@ -3009,6 +3267,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);
@@ -3017,7 +3276,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);
@@ -3029,7 +3288,7 @@ function reconcile(value, key) {
     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))
+    if (eq !== undefined && keyFn(value) !== eq)
       throw new Error("Cannot reconcile states with different identity");
     applyState(value, state, keyFn);
   };
@@ -3068,13 +3327,13 @@ function createProjectionInternal(fn, seed, options) {
 function createProjection(fn, seed, options) {
   return createProjectionInternal(fn, seed, options).store;
 }
-function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
+function runProjectionComputed(wrappedStore, fn, key, wrapCommit, onDraftWrite) {
   const owner = getOwner();
   let settled = false;
   let result;
   const draft = new Proxy(
     wrappedStore,
-    createWriteTraps(() => !settled || owner._inFlight === result)
+    createWriteTraps(() => !settled || owner._inFlight === result, onDraftWrite)
   );
   storeSetter(draft, s => {
     result = fn(s);
@@ -3088,7 +3347,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
   });
   return owner;
 }
-function createWriteTraps(isActive) {
+function createWriteTraps(isActive, onDraftWrite) {
   const traps = {
     get(_, prop) {
       let value;
@@ -3100,6 +3359,7 @@ function createWriteTraps(isActive) {
         setWriteOverride(false);
         setProjectionWriteActive(false);
       }
+      if (prop === $TARGET) return value;
       return typeof value === "object" && value !== null ? new Proxy(value, traps) : value;
     },
     has(_, prop) {
@@ -3120,6 +3380,7 @@ function createWriteTraps(isActive) {
       setProjectionWriteActive(true);
       try {
         _[prop] = value;
+        onDraftWrite?.();
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(false);
@@ -3132,6 +3393,7 @@ function createWriteTraps(isActive) {
       setProjectionWriteActive(true);
       try {
         delete _[prop];
+        onDraftWrite?.();
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(false);
@@ -3154,7 +3416,9 @@ 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;
   if (Array.isArray(value)) {
@@ -3172,6 +3436,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);
@@ -3189,27 +3454,49 @@ function setWriteOverride(value) {
 function writeOnly(proxy) {
   return writeOverride || !!Writing?.has(proxy);
 }
-function unwrapStoreValue(value) {
-  return value?.[$TARGET]?.[STORE_VALUE] ?? value;
+function unwrapStoreValue(value, map, lookup) {
+  const target = value?.[$TARGET] || lookup?.get(value)?.[$TARGET];
+  if (!target) return value;
+  const override = target[STORE_OVERRIDE];
+  if (!override) return target[STORE_VALUE];
+  if (!map) map = new Map();
+  if (map.has(value)) return map.get(value);
+  const source = target[STORE_VALUE];
+  const isArray = Array.isArray(source);
+  const result = isArray ? [] : Object.create(Object.getPrototypeOf(source));
+  map.set(value, result);
+  lookup = target[STORE_LOOKUP] ?? storeLookup;
+  for (const key of getKeys(source, override)) {
+    if (isArray && key === "length") continue;
+    const next = key in override ? override[key] : source[key];
+    if (next !== $DELETED) result[key] = unwrapStoreValue(next, map, lookup);
+  }
+  if (isArray) result.length = override.length ?? source.length;
+  return result;
 }
 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) {
@@ -3233,7 +3520,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
@@ -3246,6 +3550,7 @@ 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) {
@@ -3261,8 +3566,20 @@ function trackSelf(target, symbol = $TRACK) {
       )
     );
 }
+function notifySelf(target) {
+  const node = target[STORE_NODE]?.[$TRACK];
+  node &&
+    setSignal(
+      node,
+      target[STORE_OPTIMISTIC] && !projectionWriteActive ? STORE_SELF_PENDING : undefined
+    );
+}
 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);
@@ -3276,10 +3593,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];
@@ -3304,9 +3637,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;
@@ -3353,7 +3691,7 @@ function notifyStoreProperty(target, property, mode, value, prev, prevHas) {
       setSignal(node, undefined);
     }
   }
-  nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+  notifySelf(target);
 }
 let Writing = null;
 const storeTraps = {
@@ -3365,8 +3703,9 @@ const storeTraps = {
       trackSelf(target);
       return receiver;
     }
+    const selfRead = getObserver() === target[STORE_FIREWALL];
     const nodes = getNodes(target, STORE_NODE);
-    const tracked = nodes[property];
+    const tracked = selfRead ? undefined : nodes[property];
     const source = target[STORE_VALUE];
     if (
       !tracked &&
@@ -3378,20 +3717,15 @@ const storeTraps = {
       !source[$TARGET] &&
       !(property in source) &&
       getObserver() &&
+      !selfRead &&
       !writeOnly(receiver)
     ) {
       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);
@@ -3406,13 +3740,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);
@@ -3426,14 +3754,18 @@ 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])) &&
           proto !== Object.prototype
           ? value.bind(storeValue)
           : value;
-      } else if (getObserver()) {
+      } else if (getObserver() && !selfRead) {
         return read(
           getNode(
             nodes,
@@ -3465,13 +3797,9 @@ 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];
-    if (writeOnly(target[$PROXY])) return has;
+    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]);
     if (getObserver()) {
@@ -3491,30 +3819,19 @@ 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 isArrayIndexWrite =
+          Array.isArray(state) && property !== "length" && typeof property !== "symbol";
         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 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 {
@@ -3523,6 +3840,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) {
@@ -3549,6 +3882,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) }
@@ -3578,19 +3912,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);
@@ -3599,7 +3930,7 @@ const storeTraps = {
     return true;
   },
   ownKeys(target) {
-    trackSelf(target);
+    if (getObserver() !== target[STORE_FIREWALL]) trackSelf(target);
     let keys = getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
     if (target[STORE_OPTIMISTIC_OVERRIDE]) {
       const keySet = new Set(keys);
@@ -3619,7 +3950,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],
@@ -3628,7 +3965,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]);
@@ -3645,7 +3987,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];
@@ -3664,7 +4006,10 @@ function createStore(first, second, options) {
   return [
     wrappedStore,
     derived
-      ? fn => (storeSetter(wrappedStore, fn), suppressComputedRecompute(wrappedStore[$REFRESH]))
+      ? fn => {
+          suppressComputedRecompute(wrappedStore[$REFRESH]);
+          storeSetter(wrappedStore, fn);
+        }
       : fn => storeSetter(wrappedStore, fn)
   ];
 }
@@ -3678,32 +4023,47 @@ 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;
   setProjectionWriteActive(true);
   try {
     if (nodes) {
       for (const key of Reflect.ownKeys(override)) {
         if (nodes[key]) {
-          nodes[key]._optimisticLane = undefined;
-          const baseValue =
-            target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
-              ? target[STORE_OVERRIDE][key]
-              : target[STORE_VALUE][key];
+          const node = nodes[key];
+          node._optimisticLane = undefined;
+          const layer = getOverlayLayer(target, key);
+          const baseValue = layer ? layer[key] : target[STORE_VALUE][key];
           const value = baseValue === $DELETED ? undefined : baseValue;
-          setSignal(nodes[key], isWrappable(value) ? wrap(value, target) : value);
+          const next = isWrappable(value) ? wrap(value, target) : value;
+          const prev = visibleNodeValue(node);
+          node._overrideValue = NOT_PENDING;
+          node._pendingValue = NOT_PENDING;
+          node._value = next;
+          if (!node._equals || !node._equals(prev, next)) {
+            insertSubs(node, true);
+            schedule();
+          }
         }
       }
       if (nodes[$TRACK]) {
         nodes[$TRACK]._optimisticLane = undefined;
-        setSignal(nodes[$TRACK], undefined);
+        notifySelf(target);
       }
     }
   } finally {
-    setProjectionWriteActive(false);
+    setProjectionWriteActive(wasProjectionWriteActive);
   }
-  delete target[STORE_OPTIMISTIC_OVERRIDE];
 }
 function createOptimisticProjectionInternal(fn, initialValue, options) {
   let node;
@@ -3728,19 +4088,31 @@ function createOptimisticProjectionInternal(fn, initialValue, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   if (fn) {
+    const clearProjectionOverride = () => {
+      const target = wrappedStore[$TARGET];
+      if (target?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(target);
+    };
     const wrapCommit = write => {
+      const wasProjectionWriteActive = projectionWriteActive;
       setProjectionWriteActive(true);
       try {
         write();
+        clearProjectionOverride();
       } finally {
-        setProjectionWriteActive(false);
+        setProjectionWriteActive(wasProjectionWriteActive);
       }
     };
     node = computed(
       () => {
         setProjectionWriteActive(true);
         try {
-          runProjectionComputed(wrappedStore, fn, options?.key || "id", wrapCommit);
+          runProjectionComputed(
+            wrappedStore,
+            fn,
+            options?.key || "id",
+            wrapCommit,
+            clearProjectionOverride
+          );
         } finally {
           setProjectionWriteActive(false);
         }
@@ -3806,10 +4178,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;
@@ -3826,6 +4198,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;
@@ -3833,7 +4210,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,
@@ -3842,13 +4219,13 @@ function snapshotImpl(item, track, map, lookup) {
         : target[STORE_VALUE]
     );
     item = target[STORE_VALUE];
-    lookup = storeLookup;
+    lookup = target[STORE_LOOKUP] ?? storeLookup;
   } else {
     isArray = Array.isArray(item);
     map.set(item, item);
   }
   if (isArray) {
-    const len = override?.length || item.length;
+    const len = override?.length ?? item.length;
     for (let i = 0; i < len; i++) {
       v = override && i in override ? override[i] : item[i];
       if (v === $DELETED) continue;
@@ -3858,13 +4235,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) {
@@ -3947,7 +4341,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];
@@ -4001,7 +4395,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
@@ -4220,6 +4614,7 @@ function updateRepeat() {
         this._nodes = [];
         this._mappings = [];
         this._len = 0;
+        this._offset = 0;
       }
       if (this._fallback && !this._mappings[0]) {
         this._mappings[0] = runWithOwner((this._nodes[0] = createOwner()), this._fallback);
@@ -4229,12 +4624,24 @@ 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) {
-      let i = this._offset;
-      while (i < from && i < this._len) this._nodes[i++].dispose();
-      this._nodes.splice(0, from - this._offset);
-      this._mappings.splice(0, from - this._offset);
+      const removed = from - this._offset;
+      for (let i = 0; i < removed && i < this._len; i++) this._nodes[i].dispose();
+      this._nodes.splice(0, removed);
+      this._mappings.splice(0, removed);
     } else if (this._offset > from) {
       let i = prevTo - this._offset - 1;
       let difference = this._offset - from;
@@ -4270,7 +4677,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;
@@ -4462,11 +4875,11 @@ class CollectionQueue extends Queue {
         this._sources.clear();
       }
     }
-    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 (this._collectionType & STATUS_PENDING && this._initialized)
+      return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
       this._pending = true;
       const source = error?.source || node._error?.source;
@@ -4553,14 +4966,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) {
@@ -4694,7 +5110,6 @@ export {
   isDisposed,
   isEqual,
   isPending,
-  isRefreshing,
   isWrappable,
   latest,
   mapArray,
@@ -4708,6 +5123,7 @@ export {
   refresh,
   releaseSnapshotScope,
   repeat,
+  resetErrorHalt,
   resolve,
   runWithOwner,
   setContext,