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

package/dist/dev.js

@@ -140,107 +140,6 @@ 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 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, heap);
-    }
-  }
-}
 const signalLanes = new WeakMap();
 const activeLanes = new Set();
 function getOrCreateLane(signal) {
@@ -796,8 +695,11 @@ function flush(fn) {
     try {
       return fn();
     } finally {
-      flush();
-      syncDepth--;
+      try {
+        flush();
+      } finally {
+        syncDepth--;
+      }
     }
   }
   if (globalQueue._running) {
@@ -886,24 +788,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);
@@ -1264,8 +1269,10 @@ 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 (setter) {
+      setter(value);
+      if (wasUninitialized) clearStatus(el, true);
+    } else if (el._overrideValue !== undefined) {
       if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
         el._pendingValue = value;
       else {
@@ -1461,15 +1468,20 @@ 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 pendingCheckLoadingPath = false;
+let pendingCheckSources = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1931,15 +1943,23 @@ function read(el) {
     const firewall = el._firewall;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
+    let c = context;
+    if (c?._root) c = c._parentComputed;
     const owner = firewall || el;
-    if (
-      pendingCheckLoadingPath &&
-      owner._statusFlags & STATUS_PENDING &&
-      owner._statusFlags & STATUS_UNINITIALIZED
-    ) {
-      let c = context;
-      if (c?._root) c = c._parentComputed;
-      if (c && tracking) link(el, c);
+    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 (c && owner._statusFlags & STATUS_PENDING && owner._statusFlags & STATUS_UNINITIALIZED) {
+      if (tracking && el !== c) link(el, c);
       pendingCheckActive = prevCheck;
       throw owner._error;
     }
@@ -1950,17 +1970,14 @@ function read(el) {
       ) {
         foundPending = true;
       }
-      let c = context;
-      if (c?._root) c = c._parentComputed;
+      collectPendingSources(el);
+      collectPendingSources(firewall);
       if (c && tracking) link(el, c);
-      read(getPendingSignal(el));
-      read(getPendingSignal(firewall));
     } else {
-      if (read(getPendingSignal(el))) foundPending = true;
-      if (firewall && read(getPendingSignal(firewall))) foundPending = true;
+      collectPendingSources(el);
+      if (firewall) collectPendingSources(firewall);
     }
     pendingCheckActive = prevCheck;
-    return el._value;
   }
   let c = context;
   if (c?._root) c = c._parentComputed;
@@ -2094,7 +2111,7 @@ function read(el) {
     currentOptimisticLane !== null &&
     !latestReadActive &&
     el._pendingValue !== NOT_PENDING &&
-    owner === el &&
+    (owner === el || !!(owner._flags & REACTIVE_MANUAL_WRITE)) &&
     !el._fn &&
     c
   ) {
@@ -2131,19 +2148,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);
@@ -2160,9 +2175,13 @@ function setSignal(el, v) {
   const valueChanged =
     !el._equals || !el._equals(currentValue, v) || !!(el._statusFlags & STATUS_UNINITIALIZED);
   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);
+      if (el._fn) {
+        insertSubs(el, true);
+        schedule();
+      }
     }
     return v;
   }
@@ -2192,8 +2211,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) {
@@ -2236,11 +2257,25 @@ function getPendingSignal(el) {
   }
   return el._pendingSignal;
 }
+function collectPendingSources(el) {
+  pendingCheckSources?.add(el);
+  const owner = el._firewall || el;
+  if (owner !== el) pendingCheckSources?.add(owner);
+}
 function computePendingState(el) {
   const comp = el;
   const firewall = el._firewall;
+  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);
+  }
   if (firewall && el._pendingValue !== NOT_PENDING) {
-    return !firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING);
+    return (
+      !!(firewall._flags & REACTIVE_MANUAL_WRITE) ||
+      (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING))
+    );
   }
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
@@ -2309,32 +2344,47 @@ function latest(fn) {
     latestReadActive = prevLatest;
   }
 }
-function isPending(fn, loading) {
+function isPending(fn) {
   const prevPendingCheck = pendingCheckActive;
-  const prevPendingCheckLoadingPath = pendingCheckLoadingPath;
   const prevFoundPending = foundPending;
-  const checkLoading = loading === true;
+  const prevPendingCheckSources = pendingCheckSources;
   pendingCheckActive = true;
-  pendingCheckLoadingPath = checkLoading;
   foundPending = false;
+  pendingCheckSources = new Set();
+  const collectPending = () => {
+    pendingCheckActive = false;
+    const prevStrictRead = strictRead;
+    strictRead = false;
+    try {
+      pendingCheckSources.forEach(source => {
+        if (read(getPendingSignal(source))) foundPending = true;
+      });
+    } finally {
+      strictRead = prevStrictRead;
+      pendingCheckActive = true;
+    }
+  };
   try {
     fn();
+    collectPending();
     return foundPending;
   } catch (e) {
-    if (checkLoading && e instanceof NotReadyError) throw e;
+    collectPending();
+    if (e instanceof NotReadyError) {
+      if (foundPending && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
+      if (context) throw e;
+    }
     return foundPending;
   } finally {
     pendingCheckActive = prevPendingCheck;
-    pendingCheckLoadingPath = prevPendingCheckLoadingPath;
     foundPending = prevFoundPending;
+    pendingCheckSources = prevPendingCheckSources;
   }
 }
 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.";
@@ -2346,18 +2396,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 };
@@ -2756,6 +2820,7 @@ 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)) {
@@ -2787,18 +2852,18 @@ 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], wrap(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);
+          arrayNodes?.[j] && setSignal(arrayNodes[j], wrapped);
           applyState(next[j], wrapped, keyFn);
         }
-        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+        changed && 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);
@@ -2822,24 +2887,26 @@ 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);
+          arrayNodes?.[j] && setSignal(arrayNodes[j], wrapped);
           applyState(next[j], wrapped, keyFn);
-        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+        } else arrayNodes?.[j] && setSignal(arrayNodes[j], wrap(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)) applyState(next[i], wrap(item, target), keyFn);
+        else {
+          if (item !== next[i]) changed = true;
+          arrayNodes?.[i] && setSignal(arrayNodes[i], next[i]);
+        }
       }
     }
     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];
@@ -2908,18 +2975,17 @@ 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], wrap(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);
+          nodes?.[j] && setSignal(nodes[j], wrapped);
           applyState(next[j], wrapped, 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;
+        changed && notifySelf(target);
+        prevLength !== nextLength && nodes?.length && setSignal(nodes.length, nextLength);
         return;
       }
       newIndicesNext = new Array(newEnd + 1);
@@ -2943,24 +3009,27 @@ 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);
+          nodes?.[j] && setSignal(nodes[j], wrapped);
           applyState(next[j], wrapped, keyFn);
-        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+        } else nodes?.[j] && setSignal(nodes[j], wrap(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)) applyState(next[i], wrap(item, target), keyFn);
+        else {
+          if (item !== next[i]) changed = true;
+          nodes?.[i] && setSignal(nodes[i], next[i]);
+        }
       }
     }
-    if (prevLength !== next.length) {
+    const nextLength = next.length;
+    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) {
@@ -2996,7 +3065,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);
   };
@@ -3035,13 +3104,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);
@@ -3055,7 +3124,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
   });
   return owner;
 }
-function createWriteTraps(isActive) {
+function createWriteTraps(isActive, onDraftWrite) {
   const traps = {
     get(_, prop) {
       let value;
@@ -3067,6 +3136,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) {
@@ -3087,6 +3157,7 @@ function createWriteTraps(isActive) {
       setProjectionWriteActive(true);
       try {
         _[prop] = value;
+        onDraftWrite?.();
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(false);
@@ -3099,6 +3170,7 @@ function createWriteTraps(isActive) {
       setProjectionWriteActive(true);
       try {
         delete _[prop];
+        onDraftWrite?.();
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(false);
@@ -3122,6 +3194,7 @@ const STORE_VALUE = "v",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
   STORE_OPTIMISTIC = "p";
+const STORE_SELF_PENDING = Symbol("STORE_SELF_PENDING");
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
@@ -3156,8 +3229,45 @@ 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;
+  const override = target[STORE_OVERRIDE];
+  if (
+    override &&
+    Object.prototype.hasOwnProperty.call(override, property) &&
+    override[property] !== $DELETED
+  )
+    return true;
+  return Object.prototype.hasOwnProperty.call(unwrapStoreValue(target[STORE_VALUE]), property);
 }
 function hasInheritedAccessor(source, property) {
   let current = Object.getPrototypeOf(source);
@@ -3208,6 +3318,14 @@ 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)));
   if (!override) return baseKeys;
@@ -3300,7 +3418,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 = {
@@ -3312,8 +3430,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 &&
@@ -3325,6 +3444,7 @@ const storeTraps = {
       !source[$TARGET] &&
       !(property in source) &&
       getObserver() &&
+      !selfRead &&
       !writeOnly(receiver)
     ) {
       return read(getNode(nodes, property, undefined, target[STORE_FIREWALL]));
@@ -3350,6 +3470,8 @@ const storeTraps = {
       }
     }
     if (writeOnly(receiver)) {
+      if (isPrototypePollutionKey$1(property) && !hasOwnStoreProperty(target, property))
+        return undefined;
       let value =
         tracked && (overridden || !proxySource)
           ? tracked._overrideValue !== undefined && tracked._overrideValue !== NOT_PENDING
@@ -3378,7 +3500,7 @@ const storeTraps = {
           proto !== Object.prototype
           ? value.bind(storeValue)
           : value;
-      } else if (getObserver()) {
+      } else if (getObserver() && !selfRead) {
         return read(
           getNode(
             nodes,
@@ -3416,7 +3538,7 @@ const storeTraps = {
         : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
           ? target[STORE_OVERRIDE][property] !== $DELETED
           : property in target[STORE_VALUE];
-    if (writeOnly(target[$PROXY])) return has;
+    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()) {
@@ -3427,6 +3549,7 @@ const storeTraps = {
     return has;
   },
   set(target, property, rawValue) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3488,6 +3611,7 @@ const storeTraps = {
     return true;
   },
   defineProperty(target, property, descriptor) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3514,6 +3638,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(target, property) {
+    if (property === "__proto__") return true;
     const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
     const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
     if (writeOnly(target[$PROXY]) && !optDeleted && !regDeleted) {
@@ -3541,7 +3666,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);
@@ -3606,7 +3731,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)
   ];
 }
@@ -3621,31 +3749,50 @@ function createOptimisticStore(first, second, options) {
 function clearOptimisticStore(store) {
   const target = store[$TARGET];
   if (!target || !target[STORE_OPTIMISTIC_OVERRIDE]) return;
+  clearOptimisticOverride(target);
+}
+function clearOptimisticOverride(target) {
   const override = target[STORE_OPTIMISTIC_OVERRIDE];
+  if (!override) return;
   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 node = nodes[key];
+          node._optimisticLane = undefined;
           const baseValue =
             target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
               ? target[STORE_OVERRIDE][key]
               : target[STORE_VALUE][key];
           const value = baseValue === $DELETED ? undefined : baseValue;
-          setSignal(nodes[key], isWrappable(value) ? wrap(value, target) : value);
+          const next = isWrappable(value) ? wrap(value, target) : value;
+          const prev =
+            node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING
+              ? node._overrideValue
+              : node._pendingValue !== NOT_PENDING
+                ? node._pendingValue
+                : node._value;
+          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;
@@ -3670,19 +3817,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);
         }
@@ -3784,13 +3943,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;
@@ -4162,6 +4321,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);
@@ -4173,10 +4333,10 @@ function updateRepeat() {
     if (this._len === 0 && this._nodes[0]) this._nodes[0].dispose();
     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;
@@ -4225,7 +4385,7 @@ function createBoundChildren(owner, fn, queue, mask) {
   cleanup(() => parentQueue.removeChild(owner._queue));
   return runWithOwner(owner, () => {
     const c = computed(fn);
-    return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
+    return boundaryComputed(() => flatten(read(c)), mask);
   });
 }
 const ON_INIT = Symbol();
@@ -4636,7 +4796,6 @@ export {
   isDisposed,
   isEqual,
   isPending,
-  isRefreshing,
   isWrappable,
   latest,
   mapArray,