@solidjs/signals 0.8.2 → 0.8.4

package/dist/dev.js

@@ -1,124 +1,116 @@
-// src/core/error.ts
-var NotReadyError = class extends Error {
+class NotReadyError extends Error {
+  cause;
   constructor(cause) {
     super();
     this.cause = cause;
   }
-};
-var NoOwnerError = class extends Error {
+}
+class NoOwnerError extends Error {
   constructor() {
-    super("Context can only be accessed under a reactive root." );
+    super("Context can only be accessed under a reactive root.");
   }
-};
-var ContextNotFoundError = class extends Error {
+}
+class ContextNotFoundError extends Error {
   constructor() {
     super(
-      "Context must either be created with a default value or a value must be provided before accessing it." 
+      "Context must either be created with a default value or a value must be provided before accessing it."
     );
   }
-};
-
-// src/core/constants.ts
-var NOT_PENDING = {};
-var SUPPORTS_PROXY = typeof Proxy === "function";
-
-// src/core/heap.ts
+}
+const REACTIVE_NONE = 0;
+const REACTIVE_CHECK = 1 << 0;
+const REACTIVE_DIRTY = 1 << 1;
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+const REACTIVE_IN_HEAP = 1 << 3;
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+const REACTIVE_ZOMBIE = 1 << 5;
+const REACTIVE_DISPOSED = 1 << 6;
+const STATUS_NONE = 0;
+const STATUS_PENDING = 1 << 0;
+const STATUS_ERROR = 1 << 1;
+const STATUS_UNINITIALIZED = 1 << 2;
+const EFFECT_RENDER = 1;
+const EFFECT_USER = 2;
+const NOT_PENDING = {};
+const SUPPORTS_PROXY = typeof Proxy === "function";
+const defaultContext = {};
 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 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 === void 0) {
-    heap._heap[height] = n;
-  } else {
+  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;
-  }
+  if (height > heap._max) heap._max = height;
 }
 function insertIntoHeap(n, heap) {
   let flags = n._flags;
-  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */))
-    return;
-  if (flags & 1 /* Check */) {
-    n._flags = flags & ~(1 /* Check */ | 2 /* Dirty */) | 2 /* Dirty */ | 8 /* InHeap */;
-  } else
-    n._flags = flags | 8 /* InHeap */;
-  if (!(flags & 16 /* InHeapHeight */)) {
-    actualInsertIntoHeap(n, heap);
-  }
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) 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 & (8 /* InHeap */ | 4 /* RecomputingDeps */ | 16 /* InHeapHeight */))
-    return;
-  n._flags = flags | 16 /* InHeapHeight */;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(n, heap);
 }
 function deleteFromHeap(n, heap) {
   const flags = n._flags;
-  if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
-    return;
-  n._flags = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
+  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] = void 0;
-  } else {
+  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;
-    }
+    if (n === dhh) heap._heap[height] = next;
+    else n._prevHeap._nextHeap = next;
     end._prevHeap = n._prevHeap;
   }
   n._prevHeap = n;
-  n._nextHeap = void 0;
+  n._nextHeap = undefined;
 }
 function markHeap(heap) {
-  if (heap._marked)
-    return;
+  if (heap._marked) return;
   heap._marked = true;
   for (let i = 0; i <= heap._max; i++) {
-    for (let el = heap._heap[i]; el !== void 0; el = el._nextHeap) {
-      if (el._flags & 8 /* InHeap */)
-        markNode(el);
+    for (let el = heap._heap[i]; el !== undefined; el = el._nextHeap) {
+      if (el._flags & REACTIVE_IN_HEAP) markNode(el);
     }
   }
 }
-function markNode(el, newState = 2 /* Dirty */) {
+function markNode(el, newState = REACTIVE_DIRTY) {
   const flags = el._flags;
-  if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
-    return;
-  el._flags = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
-  for (let link2 = el._subs; link2 !== null; link2 = link2._nextSub) {
-    markNode(link2._sub, 1 /* Check */);
+  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 link2 = child._subs; link2 !== null; link2 = link2._nextSub) {
-        markNode(link2._sub, 1 /* Check */);
+      for (let link = child._subs; link !== null; link = link._nextSub) {
+        markNode(link._sub, REACTIVE_CHECK);
       }
     }
   }
 }
-function runHeap(heap, recompute2) {
+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 !== void 0) {
-      if (el._flags & 8 /* InHeap */)
-        recompute2(el);
-      else {
-        adjustHeight(el, heap);
-      }
+    while (el !== undefined) {
+      if (el._flags & REACTIVE_IN_HEAP) recompute(el);
+      else adjustHeight(el, heap);
       el = heap._heap[heap._min];
     }
   }
@@ -129,12 +121,8 @@ function adjustHeight(el, heap) {
   let newHeight = el._height;
   for (let d = el._deps; d; d = d._nextDep) {
     const dep1 = d._dep;
-    const dep = "_owner" in dep1 ? dep1._owner : dep1;
-    if ("_fn" in dep) {
-      if (dep._height >= newHeight) {
-        newHeight = dep._height + 1;
-      }
-    }
+    const dep = dep1._firewall || dep1;
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
   }
   if (el._height !== newHeight) {
     el._height = newHeight;
@@ -143,33 +131,18 @@ function adjustHeight(el, heap) {
     }
   }
 }
-
-// src/core/scheduler.ts
-var clock = 0;
-var activeTransition = null;
-var unobserved = [];
-var transitions = /* @__PURE__ */ new Set();
-var scheduled = false;
+const transitions = new Set();
+const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
+const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
+let clock = 0;
+let activeTransition = null;
+let scheduled = false;
 function schedule() {
-  if (scheduled)
-    return;
+  if (scheduled) return;
   scheduled = true;
-  if (!globalQueue._running)
-    queueMicrotask(flush);
-}
-var dirtyQueue = {
-  _heap: new Array(2e3).fill(void 0),
-  _marked: false,
-  _min: 0,
-  _max: 0
-};
-var zombieQueue = {
-  _heap: new Array(2e3).fill(void 0),
-  _marked: false,
-  _min: 0,
-  _max: 0
-};
-var Queue = class {
+  if (!globalQueue._running) queueMicrotask(flush);
+}
+class Queue {
   _parent = null;
   _queues = [[], []];
   _children = [];
@@ -186,8 +159,7 @@ var Queue = class {
     }
   }
   notify(node, mask, flags) {
-    if (this._parent)
-      return this._parent.notify(node, mask, flags);
+    if (this._parent) return this._parent.notify(node, mask, flags);
     return false;
   }
   run(type) {
@@ -201,8 +173,7 @@ var Queue = class {
     }
   }
   enqueue(type, fn) {
-    if (type)
-      this._queues[type - 1].push(fn);
+    if (type) this._queues[type - 1].push(fn);
     schedule();
   }
   stashQueues(stub) {
@@ -225,63 +196,58 @@ var Queue = class {
     for (let i = 0; i < stub._children.length; i++) {
       const childStub = stub._children[i];
       let child = this._children[i];
-      if (child)
-        child.restoreQueues(childStub);
+      if (child) child.restoreQueues(childStub);
     }
   }
-};
-var GlobalQueue = class _GlobalQueue extends Queue {
+}
+class GlobalQueue extends Queue {
   _running = false;
   _pendingNodes = [];
   static _update;
   static _dispose;
   flush() {
-    if (this._running)
-      return;
+    if (this._running) return;
     this._running = true;
     try {
-      runHeap(dirtyQueue, _GlobalQueue._update);
+      runHeap(dirtyQueue, GlobalQueue._update);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, _GlobalQueue._update);
-          globalQueue._pendingNodes = [];
-          globalQueue.stashQueues(activeTransition.queueStash);
+          runHeap(zombieQueue, GlobalQueue._update);
+          this._pendingNodes = [];
+          this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
           runPending(activeTransition.pendingNodes, true);
           activeTransition = null;
           return;
         }
-        globalQueue._pendingNodes.push(...activeTransition.pendingNodes);
-        globalQueue.restoreQueues(activeTransition.queueStash);
+        this._pendingNodes.push(...activeTransition.pendingNodes);
+        this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        if (runPending(globalQueue._pendingNodes, false))
-          runHeap(dirtyQueue, _GlobalQueue._update);
-      } else if (transitions.size)
-        runHeap(zombieQueue, _GlobalQueue._update);
-      for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
-        const n = globalQueue._pendingNodes[i];
+        if (runPending(this._pendingNodes, false)) runHeap(dirtyQueue, GlobalQueue._update);
+      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
+      for (let i = 0; i < this._pendingNodes.length; i++) {
+        const n = this._pendingNodes[i];
         if (n._pendingValue !== NOT_PENDING) {
           n._value = n._pendingValue;
           n._pendingValue = NOT_PENDING;
+          if (n._type) n._modified = true;
         }
-        if (n._fn)
-          _GlobalQueue._dispose(n, false, true);
+        if (n._fn) GlobalQueue._dispose(n, false, true);
       }
-      globalQueue._pendingNodes.length = 0;
+      this._pendingNodes.length = 0;
       clock++;
       scheduled = false;
-      this.run(1 /* Render */);
-      this.run(2 /* User */);
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
     } finally {
       this._running = false;
-      unobserved.length && notifyUnobserved();
     }
   }
   notify(node, mask, flags) {
-    if (mask & 1 /* Pending */) {
-      if (flags & 1 /* Pending */) {
+    if (mask & STATUS_PENDING) {
+      if (flags & STATUS_PENDING) {
         if (activeTransition && !activeTransition.asyncNodes.includes(node._error.cause))
           activeTransition.asyncNodes.push(node._error.cause);
       }
@@ -290,8 +256,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
     return false;
   }
   initTransition(node) {
-    if (activeTransition && activeTransition.time === clock)
-      return;
+    if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
       activeTransition = node._transition ?? {
         time: clock,
@@ -302,14 +267,14 @@ var GlobalQueue = class _GlobalQueue extends Queue {
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
-    for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
-      const n = globalQueue._pendingNodes[i];
+    for (let i = 0; i < this._pendingNodes.length; i++) {
+      const n = this._pendingNodes[i];
       n._transition = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
-    globalQueue._pendingNodes = activeTransition.pendingNodes;
+    this._pendingNodes = activeTransition.pendingNodes;
   }
-};
+}
 function runPending(pendingNodes, value) {
   let needsReset = false;
   const p = pendingNodes.slice();
@@ -320,60 +285,57 @@ function runPending(pendingNodes, value) {
       n._pendingCheck._set(value);
       needsReset = true;
     }
+    if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING) {
+      n._pendingSignal._set(n._pendingSignal._pendingValue);
+      n._pendingSignal._pendingValue = NOT_PENDING;
+      needsReset = true;
+    }
   }
   return needsReset;
 }
-var globalQueue = new GlobalQueue();
+const globalQueue = new GlobalQueue();
 function flush() {
   let count = 0;
   while (scheduled) {
-    if (++count === 1e5)
-      throw new Error("Potential Infinite Loop Detected.");
+    if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
     globalQueue.flush();
   }
 }
 function runQueue(queue, type) {
-  for (let i = 0; i < queue.length; i++)
-    queue[i](type);
+  for (let i = 0; i < queue.length; i++) queue[i](type);
 }
 function transitionComplete(transition) {
   let done = true;
   for (let i = 0; i < transition.asyncNodes.length; i++) {
-    if (transition.asyncNodes[i]._statusFlags & 1 /* Pending */) {
+    if (transition.asyncNodes[i]._statusFlags & STATUS_PENDING) {
       done = false;
       break;
     }
   }
   return done;
 }
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source._subs)
-      unobserved[i]._unobserved?.();
-  }
-  unobserved = [];
+function runInTransition(el, recompute) {
+  const prevTransition = activeTransition;
+  activeTransition = el._transition;
+  recompute(el);
+  activeTransition = prevTransition;
 }
-
-// src/core/core.ts
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
-var tracking = false;
-var stale = false;
-var pendingValueCheck = false;
-var pendingCheck = null;
-var context = null;
-var defaultContext = {};
+let tracking = false;
+let stale = false;
+let pendingValueCheck = false;
+let pendingCheck = null;
+let context = null;
 function notifySubs(node) {
   for (let s = node._subs; s !== null; s = s._nextSub) {
-    const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-    if (queue._min > s._sub._height)
-      queue._min = s._sub._height;
+    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height) queue._min = s._sub._height;
     insertIntoHeap(s._sub, queue);
   }
 }
 function recompute(el, create = false) {
-  deleteFromHeap(el, el._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
   if (el._pendingValue !== NOT_PENDING || el._pendingFirstChild || el._pendingDisposal)
     disposeChildren(el);
   else {
@@ -387,29 +349,27 @@ function recompute(el, create = false) {
   const oldcontext = context;
   context = el;
   el._depsTail = null;
-  el._flags = 4 /* RecomputingDeps */;
+  el._flags = REACTIVE_RECOMPUTING_DEPS;
   el._time = clock;
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
   let prevStatusFlags = el._statusFlags;
   let prevError = el._error;
   let prevTracking = tracking;
-  clearStatusFlags(el);
+  setStatusFlags(el, STATUS_NONE | (prevStatusFlags & STATUS_UNINITIALIZED));
   tracking = true;
   try {
     value = el._fn(value);
+    el._statusFlags &= ~STATUS_UNINITIALIZED;
   } catch (e) {
     if (e instanceof NotReadyError) {
-      if (e.cause !== el)
-        link(e.cause, el);
-      setStatusFlags(el, prevStatusFlags & ~2 /* Error */ | 1 /* Pending */, e);
-    } else {
-      setError(el, e);
-    }
+      if (e.cause !== el) link(e.cause, el);
+      setStatusFlags(el, (prevStatusFlags & ~STATUS_ERROR) | STATUS_PENDING, e);
+    } else setStatusFlags(el, STATUS_ERROR, e);
   } finally {
     tracking = prevTracking;
   }
-  el._flags = 0 /* None */;
+  el._flags = REACTIVE_NONE;
   context = oldcontext;
   const depsTail = el._depsTail;
   let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
@@ -417,81 +377,89 @@ function recompute(el, create = false) {
     do {
       toRemove = unlinkSubs(toRemove);
     } while (toRemove !== null);
-    if (depsTail !== null) {
-      depsTail._nextDep = null;
-    } else {
-      el._deps = null;
-    }
-  }
-  const valueChanged = !el._equals || !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, value);
+    if (depsTail !== null) depsTail._nextDep = null;
+    else el._deps = null;
+  }
+  const valueChanged =
+    !el._equals ||
+    !el._equals(
+      el._pendingValue === NOT_PENDING || el._optimistic ? el._value : el._pendingValue,
+      value
+    );
   const statusFlagsChanged = el._statusFlags !== prevStatusFlags || el._error !== prevError;
   el._notifyQueue?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
-      if (create || el._optimistic || el._type)
+      if (create || el._optimistic || (el._type && el._transition != activeTransition))
         el._value = value;
       else {
-        if (el._pendingValue === NOT_PENDING)
-          globalQueue._pendingNodes.push(el);
+        if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
         el._pendingValue = value;
       }
-      if (el._pendingSignal)
-        el._pendingSignal._set(value);
+      if (el._pendingSignal) el._pendingSignal._set(value);
     }
     for (let s = el._subs; s !== null; s = s._nextSub) {
-      const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s._sub._height < el._height && queue._min > s._sub._height)
-        queue._min = s._sub._height;
+      const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+      if (s._sub._height < el._height && queue._min > s._sub._height) queue._min = s._sub._height;
       insertIntoHeap(s._sub, queue);
     }
   } else if (el._height != oldHeight) {
     for (let s = el._subs; s !== null; s = s._nextSub) {
-      insertIntoHeapHeight(s._sub, s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+      insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
+  if (el._type && el._transition && activeTransition !== el._transition)
+    runInTransition(el, recompute);
 }
 function updateIfNecessary(el) {
-  if (el._flags & 1 /* Check */) {
+  if (el._flags & REACTIVE_CHECK) {
     for (let d = el._deps; d; d = d._nextDep) {
       const dep1 = d._dep;
-      const dep = "_owner" in dep1 ? dep1._owner : dep1;
-      if ("_fn" in dep) {
+      const dep = dep1._firewall || dep1;
+      if (dep._fn) {
         updateIfNecessary(dep);
       }
-      if (el._flags & 2 /* Dirty */) {
+      if (el._flags & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (el._flags & 2 /* Dirty */) {
+  if (el._flags & REACTIVE_DIRTY) {
     recompute(el);
   }
-  el._flags = 0 /* None */;
+  el._flags = REACTIVE_NONE;
 }
-function unlinkSubs(link2) {
-  const dep = link2._dep;
-  const nextDep = link2._nextDep;
-  const nextSub = link2._nextSub;
-  const prevSub = link2._prevSub;
-  if (nextSub !== null) {
-    nextSub._prevSub = prevSub;
-  } else {
-    dep._subsTail = prevSub;
-  }
-  if (prevSub !== null) {
-    prevSub._nextSub = nextSub;
-  } else {
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
     dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && unobserved(dep);
+    }
   }
   return nextDep;
 }
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  runDisposal(el);
+}
 function link(dep, sub) {
   const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) {
-    return;
-  }
+  if (prevDep !== null && prevDep._dep === dep) return;
   let nextDep = null;
-  const isRecomputing = sub._flags & 4 /* RecomputingDeps */;
+  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
   if (isRecomputing) {
     nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
     if (nextDep !== null && nextDep._dep === dep) {
@@ -500,59 +468,38 @@ function link(dep, sub) {
     }
   }
   const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
+  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
     return;
-  }
-  const newLink = sub._depsTail = dep._subsTail = {
-    _dep: dep,
-    _sub: sub,
-    _nextDep: nextDep,
-    _prevSub: prevSub,
-    _nextSub: null
-  };
-  if (prevDep !== null) {
-    prevDep._nextDep = newLink;
-  } else {
-    sub._deps = newLink;
-  }
-  if (prevSub !== null) {
-    prevSub._nextSub = newLink;
-  } else {
-    dep._subs = newLink;
-  }
+  const newLink =
+    (sub._depsTail =
+    dep._subsTail =
+      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
+  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 link2 = sub._deps;
+    let link = sub._deps;
     do {
-      if (link2 === checkLink) {
-        return true;
-      }
-      if (link2 === depsTail) {
-        break;
-      }
-      link2 = link2._nextDep;
-    } while (link2 !== null);
+      if (link === checkLink) return true;
+      if (link === depsTail) break;
+      link = link._nextDep;
+    } while (link !== null);
   }
   return false;
 }
-function setStatusFlags(signal2, flags, error = null) {
-  signal2._statusFlags = flags;
-  signal2._error = error;
-}
-function setError(signal2, error) {
-  setStatusFlags(signal2, 2 /* Error */, error);
-}
-function clearStatusFlags(signal2) {
-  setStatusFlags(signal2, 0 /* None */);
+function setStatusFlags(signal, flags, error = null) {
+  signal._statusFlags = flags;
+  signal._error = error;
 }
 function markDisposal(el) {
   let child = el._firstChild;
   while (child) {
-    child._flags |= 32 /* Zombie */;
-    const inHeap = child._flags & 8 /* InHeap */;
-    if (inHeap) {
+    child._flags |= REACTIVE_ZOMBIE;
+    if (child._flags & REACTIVE_IN_HEAP) {
       deleteFromHeap(child, dirtyQueue);
       insertIntoHeap(child, zombieQueue);
     }
@@ -560,17 +507,24 @@ function markDisposal(el) {
     child = child._nextSibling;
   }
 }
+function dispose(node) {
+  let toRemove = node._deps || null;
+  do {
+    toRemove = unlinkSubs(toRemove);
+  } while (toRemove !== null);
+  node._deps = null;
+  node._depsTail = null;
+  disposeChildren(node, true);
+}
 function disposeChildren(node, self = false, zombie) {
-  if (node._flags & 64 /* Disposed */)
-    return;
-  if (self)
-    node._flags = 64 /* Disposed */;
+  if (node._flags & REACTIVE_DISPOSED) return;
+  if (self) node._flags = REACTIVE_DISPOSED;
   let child = zombie ? node._pendingFirstChild : node._firstChild;
   while (child) {
     const nextChild = child._nextSibling;
     if (child._deps) {
       const n = child;
-      deleteFromHeap(n, n._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+      deleteFromHeap(n, n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       let toRemove = n._deps;
       do {
         toRemove = unlinkSubs(toRemove);
@@ -591,8 +545,7 @@ function disposeChildren(node, self = false, zombie) {
 }
 function runDisposal(node, zombie) {
   let disposal = zombie ? node._pendingDisposal : node._disposal;
-  if (!disposal)
-    return;
+  if (!disposal) return;
   if (Array.isArray(disposal)) {
     for (let i = 0; i < disposal.length; i++) {
       const callable = disposal[i];
@@ -601,61 +554,52 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? node._pendingDisposal = null : node._disposal = null;
-}
-function withOptions(obj, options) {
-  obj._name = options?.name ?? (obj._fn ? "computed" : "signal");
-  obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj._equals = options?.equals != null ? options.equals : isEqual;
-  obj._pureWrite = !!options?.pureWrite;
-  obj._unobserved = options?.unobserved;
-  if (options?._internal)
-    Object.assign(obj, options._internal);
-  return obj;
+  zombie ? (node._pendingDisposal = null) : (node._disposal = null);
 }
 function getNextChildId(owner) {
-  if (owner.id != null)
-    return formatId(owner.id, owner._childCount++);
+  if (owner.id != null) return formatId(owner.id, owner._childCount++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(prefix, id) {
-  const num = id.toString(36), len = num.length - 1;
+  const num = id.toString(36),
+    len = num.length - 1;
   return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
 function computed(fn, initialValue, options) {
-  const self = withOptions(
-    {
-      _disposal: null,
-      _queue: globalQueue,
-      _context: defaultContext,
-      _childCount: 0,
-      _fn: fn,
-      _value: initialValue,
-      _height: 0,
-      _child: null,
-      _nextHeap: void 0,
-      _prevHeap: null,
-      _deps: null,
-      _depsTail: null,
-      _subs: null,
-      _subsTail: null,
-      _parent: context,
-      _nextSibling: null,
-      _firstChild: null,
-      _flags: 0 /* None */,
-      _statusFlags: 4 /* Uninitialized */,
-      _time: clock,
-      _pendingValue: NOT_PENDING,
-      _pendingDisposal: null,
-      _pendingFirstChild: null
-    },
-    options
-  );
+  const self = {
+    id: options?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
+    _equals: options?.equals != null ? options.equals : isEqual,
+    _pureWrite: !!options?.pureWrite,
+    _unobserved: options?.unobserved,
+    _disposal: null,
+    _queue: context?._queue ?? globalQueue,
+    _context: context?._context ?? defaultContext,
+    _childCount: 0,
+    _fn: fn,
+    _value: initialValue,
+    _height: 0,
+    _child: null,
+    _nextHeap: undefined,
+    _prevHeap: null,
+    _deps: null,
+    _depsTail: null,
+    _subs: null,
+    _subsTail: null,
+    _parent: context,
+    _nextSibling: null,
+    _firstChild: null,
+    _flags: REACTIVE_NONE,
+    _statusFlags: STATUS_UNINITIALIZED,
+    _time: clock,
+    _pendingValue: NOT_PENDING,
+    _pendingDisposal: null,
+    _pendingFirstChild: null
+  };
+  if (options?._internal) Object.assign(self, options._internal);
+  self._name = options?.name ?? "computed";
   self._prevHeap = self;
   const parent = context?._root ? context._parentComputed : context;
   if (context) {
-    context._queue && (self._queue = context._queue);
-    context._context && (self._context = context._context);
     const lastChild = context._firstChild;
     if (lastChild === null) {
       context._firstChild = self;
@@ -664,15 +608,14 @@ function computed(fn, initialValue, options) {
       context._firstChild = self;
     }
   }
-  if (parent)
-    self._height = parent._height + 1;
+  if (parent) self._height = parent._height + 1;
   recompute(self, true);
   return self;
 }
 function asyncComputed(asyncFn, initialValue, options) {
-  let lastResult = void 0;
+  let lastResult = undefined;
   let refreshing = false;
-  const fn = (prev) => {
+  const fn = prev => {
     const result = asyncFn(prev, refreshing);
     refreshing = false;
     lastResult = result;
@@ -682,37 +625,35 @@ function asyncComputed(asyncFn, initialValue, options) {
       return result;
     }
     if (isPromise) {
-      result.then((v) => {
-        if (lastResult !== result)
-          return;
-        globalQueue.initTransition(self);
-        setSignal(self, () => v);
-        flush();
-      }).catch((e) => {
-        if (lastResult !== result)
-          return;
-        globalQueue.initTransition(self);
-        setError(self, e);
-        self._time = clock;
-        notifySubs(self);
-        schedule();
-        flush();
-      });
+      result
+        .then(v => {
+          if (lastResult !== result) return;
+          globalQueue.initTransition(self);
+          setSignal(self, () => v);
+          flush();
+        })
+        .catch(e => {
+          if (lastResult !== result) return;
+          globalQueue.initTransition(self);
+          setStatusFlags(self, STATUS_ERROR, e);
+          self._time = clock;
+          notifySubs(self);
+          schedule();
+          flush();
+        });
     } else {
       (async () => {
         try {
           for await (let value of result) {
-            if (lastResult !== result)
-              return;
+            if (lastResult !== result) return;
             globalQueue.initTransition(self);
             setSignal(self, () => value);
             flush();
           }
         } catch (error) {
-          if (lastResult !== result)
-            return;
+          if (lastResult !== result) return;
           globalQueue.initTransition(self);
-          setError(self, error);
+          setStatusFlags(self, STATUS_ERROR, error);
           self._time = clock;
           notifySubs(self);
           schedule();
@@ -727,45 +668,35 @@ function asyncComputed(asyncFn, initialValue, options) {
   self._refresh = () => {
     refreshing = true;
     recompute(self);
+    schedule();
     flush();
   };
   return self;
 }
 function signal(v, options, firewall = null) {
-  if (firewall !== null) {
-    return firewall._child = withOptions(
-      {
-        _value: v,
-        _subs: null,
-        _subsTail: null,
-        _owner: firewall,
-        _nextChild: firewall._child,
-        _statusFlags: 0 /* None */,
-        _time: clock,
-        _pendingValue: NOT_PENDING
-      },
-      options
-    );
-  } else {
-    return withOptions(
-      {
-        _value: v,
-        _subs: null,
-        _subsTail: null,
-        _statusFlags: 0 /* None */,
-        _time: clock,
-        _pendingValue: NOT_PENDING
-      },
-      options
-    );
-  }
+  const s = {
+    id: options?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
+    _equals: options?.equals != null ? options.equals : isEqual,
+    _pureWrite: !!options?.pureWrite,
+    _unobserved: options?.unobserved,
+    _value: v,
+    _subs: null,
+    _subsTail: null,
+    _statusFlags: STATUS_NONE,
+    _time: clock,
+    _firewall: firewall,
+    _nextChild: firewall?._child || null,
+    _pendingValue: NOT_PENDING
+  };
+  s._name = options?.name ?? "signal";
+  firewall && (firewall._child = s);
+  return s;
 }
 function isEqual(a, b) {
   return a === b;
 }
 function untrack(fn) {
-  if (!tracking)
-    return fn();
+  if (!tracking) return fn();
   tracking = false;
   try {
     return fn();
@@ -775,13 +706,12 @@ function untrack(fn) {
 }
 function read(el) {
   let c = context;
-  if (c?._root)
-    c = c._parentComputed;
-  if (c && tracking) {
+  if (c?._root) c = c._parentComputed;
+  if (c && tracking && !pendingCheck && !pendingValueCheck) {
     link(el, c);
-    const owner = "_owner" in el ? el._owner : el;
-    if ("_fn" in owner) {
-      const isZombie = el._flags & 32 /* Zombie */;
+    const owner = el._firewall || el;
+    if (owner._fn) {
+      const isZombie = el._flags & REACTIVE_ZOMBIE;
       if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
@@ -794,25 +724,21 @@ function read(el) {
     }
   }
   if (pendingCheck) {
-    const pendingResult = (el._statusFlags & 1 /* Pending */) !== 0 || !!el._transition || false;
     if (!el._pendingCheck) {
-      el._pendingCheck = signal(pendingResult);
+      el._pendingCheck = signal(false);
       el._pendingCheck._optimistic = true;
-      el._pendingCheck._set = (v) => setSignal(el._pendingCheck, v);
+      el._pendingCheck._set = v => setSignal(el._pendingCheck, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
-    read(el._pendingCheck);
+    prev._value = read(el._pendingCheck) || prev._value;
     pendingCheck = prev;
-    prev._value = pendingResult || prev._value;
   }
   if (pendingValueCheck) {
     if (!el._pendingSignal) {
-      el._pendingSignal = signal(
-        el._pendingValue === NOT_PENDING ? el._value : el._pendingValue
-      );
+      el._pendingSignal = signal(el._value);
       el._pendingSignal._optimistic = true;
-      el._pendingSignal._set = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el._pendingSignal, v)));
+      el._pendingSignal._set = v => setSignal(el._pendingSignal, v);
     }
     pendingValueCheck = false;
     try {
@@ -821,18 +747,13 @@ function read(el) {
       pendingValueCheck = true;
     }
   }
-  if (el._statusFlags & 1 /* Pending */) {
-    if (c && !stale || el._statusFlags & 4 /* Uninitialized */)
-      throw el._error;
+  if (el._statusFlags & STATUS_PENDING) {
+    if ((c && !stale) || el._statusFlags & STATUS_UNINITIALIZED) throw el._error;
     else if (c && stale && !pendingCheck) {
-      setStatusFlags(
-        c,
-        c._statusFlags | 1,
-        el._error
-      );
+      setStatusFlags(c, c._statusFlags | 1, el._error);
     }
   }
-  if (el._statusFlags & 2 /* Error */) {
+  if (el._statusFlags & STATUS_ERROR) {
     if (el._time < clock) {
       recompute(el, true);
       return read(el);
@@ -840,31 +761,35 @@ function read(el) {
       throw el._error;
     }
   }
-  return !c || el._pendingValue === NOT_PENDING || stale && !pendingCheck && el._transition && activeTransition !== el._transition ? el._value : el._pendingValue;
+  return !c ||
+    el._optimistic ||
+    el._pendingValue === NOT_PENDING ||
+    (stale && !pendingCheck && el._transition && activeTransition !== el._transition)
+    ? el._value
+    : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && context && !context.firewall)
+  if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (typeof v === "function") {
-    v = v(
-      el._pendingValue === NOT_PENDING ? el._value : el._pendingValue
-    );
+    v = v(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue);
   }
-  const valueChanged = !el._equals || !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, v);
-  if (!valueChanged && !el._statusFlags)
-    return v;
+  const valueChanged =
+    !el._equals ||
+    !el._equals(
+      el._pendingValue === NOT_PENDING || el._optimistic ? el._value : el._pendingValue,
+      v
+    );
+  if (!valueChanged && !el._statusFlags) return v;
   if (valueChanged) {
-    if (el._optimistic)
-      el._value = v;
+    if (el._optimistic) el._value = v;
     else {
-      if (el._pendingValue === NOT_PENDING)
-        globalQueue._pendingNodes.push(el);
+      if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
       el._pendingValue = v;
     }
-    if (el._pendingSignal)
-      el._pendingSignal._set(v);
+    if (el._pendingSignal) el._pendingSignal._pendingValue = v;
   }
-  clearStatusFlags(el);
+  setStatusFlags(el, STATUS_NONE);
   el._time = clock;
   notifySubs(el);
   schedule();
@@ -877,8 +802,7 @@ function getOwner() {
   return context;
 }
 function onCleanup(fn) {
-  if (!context)
-    return fn;
+  if (!context) return fn;
   const node = context;
   if (!node._disposal) {
     node._disposal = fn;
@@ -897,7 +821,7 @@ function createOwner(options) {
     _firstChild: null,
     _nextSibling: null,
     _disposal: null,
-    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
+    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : undefined),
     _queue: parent?._queue ?? globalQueue,
     _context: parent?._context || defaultContext,
     _childCount: 0,
@@ -957,134 +881,117 @@ function isPending(fn, loadingValue) {
     staleValues(fn);
     return pendingCheck._value;
   } catch (err) {
-    if (!(err instanceof NotReadyError))
-      return false;
-    if (loadingValue !== void 0)
-      return loadingValue;
+    if (!(err instanceof NotReadyError)) return false;
+    if (loadingValue !== undefined) return loadingValue;
     throw err;
   } finally {
     pendingCheck = current;
   }
 }
-
-// src/core/context.ts
 function createContext(defaultValue, description) {
-  return { id: Symbol(description), defaultValue };
+  return { id: Symbol(description), defaultValue: defaultValue };
 }
-function getContext(context2, owner = getOwner()) {
+function getContext(context, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context2, owner) ? owner._context[context2.id] : context2.defaultValue;
+  const value = hasContext(context, owner) ? owner._context[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
   return value;
 }
-function setContext(context2, value, owner = getOwner()) {
+function setContext(context, value, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
   owner._context = {
     ...owner._context,
-    [context2.id]: isUndefined(value) ? context2.defaultValue : value
+    [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
-function hasContext(context2, owner) {
-  return !isUndefined(owner?._context[context2.id]);
+function hasContext(context, owner) {
+  return !isUndefined(owner?._context[context.id]);
 }
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-
-// src/core/effect.ts
-function effect(compute, effect2, error, initialValue, options) {
+function effect(compute, effect, error, initialValue, options) {
   let initialized = false;
   const node = computed(compute, initialValue, {
     ...options,
     _internal: {
       _modified: true,
       _prevValue: initialValue,
-      _effectFn: effect2,
+      _effectFn: effect,
       _errorFn: error,
-      _cleanup: void 0,
-      _queue: getOwner()?._queue ?? globalQueue,
-      _type: options?.render ? 1 /* Render */ : 2 /* User */,
+      _cleanup: undefined,
+      _type: options?.render ? EFFECT_RENDER : EFFECT_USER,
       _notifyQueue(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
-          const errorChanged = this._statusFlags && this._statusFlags === prevStatusFlags && statusFlagsChanged;
-          this._modified = !(this._statusFlags & 2 /* Error */) && !(this._statusFlags & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this._modified)
-            this._queue.enqueue(this._type, runEffect.bind(this));
+          const errorChanged =
+            this._statusFlags && this._statusFlags === prevStatusFlags && statusFlagsChanged;
+          this._modified =
+            !(this._statusFlags & STATUS_ERROR) &&
+            !(this._statusFlags & STATUS_PENDING & ~prevStatusFlags) &&
+            !errorChanged;
+          if (this._modified) this._queue.enqueue(this._type, runEffect.bind(this));
         }
-        if (this._statusFlags & 2 /* Error */) {
-          let error2 = this._error;
-          this._queue.notify(this, 1 /* Pending */, 0);
-          if (this._type === 2 /* User */) {
+        if (this._statusFlags & STATUS_ERROR) {
+          let error = this._error;
+          this._queue.notify(this, STATUS_PENDING, 0);
+          if (this._type === EFFECT_USER) {
             try {
-              return this._errorFn ? this._errorFn(error2, () => {
-                this._cleanup?.();
-                this._cleanup = void 0;
-              }) : console.error(error2);
+              return this._errorFn
+                ? this._errorFn(error, () => {
+                    this._cleanup?.();
+                    this._cleanup = undefined;
+                  })
+                : console.error(error);
             } catch (e) {
-              error2 = e;
+              error = e;
             }
           }
-          if (!this._queue.notify(this, 2 /* Error */, 2 /* Error */))
-            throw error2;
-        } else if (this._type === 1 /* Render */) {
-          this._queue.notify(
-            this,
-            1 /* Pending */ | 2 /* Error */,
-            this._statusFlags
-          );
+          if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
+        } else if (this._type === EFFECT_RENDER) {
+          this._queue.notify(this, STATUS_PENDING | STATUS_ERROR, this._statusFlags);
         }
       }
     }
   });
   initialized = true;
-  if (node._type === 1 /* Render */)
-    node._fn = (p) => staleValues(() => compute(p));
-  !options?.defer && !(node._statusFlags & (2 /* Error */ | 1 /* Pending */)) && (node._type === 2 /* User */ ? node._queue.enqueue(node._type, runEffect.bind(node)) : runEffect.call(node));
+  if (node._type === EFFECT_RENDER) node._fn = p => staleValues(() => compute(p));
+  !options?.defer &&
+    !(node._statusFlags & (STATUS_ERROR | STATUS_PENDING)) &&
+    (node._type === EFFECT_USER
+      ? node._queue.enqueue(node._type, runEffect.bind(node))
+      : runEffect.call(node));
   onCleanup(() => node._cleanup?.());
   if (!node._parent)
     console.warn("Effects created outside a reactive context will never be disposed");
 }
 function runEffect() {
-  if (!this._modified || this._flags & 64 /* Disposed */)
-    return;
+  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
   this._cleanup?.();
-  this._cleanup = void 0;
+  this._cleanup = undefined;
   try {
     this._cleanup = this._effectFn(this._value, this._prevValue);
   } catch (error) {
-    if (!this._queue.notify(this, 2 /* Error */, 2 /* Error */))
-      throw error;
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
   } finally {
     this._prevValue = this._value;
     this._modified = false;
   }
 }
-
-// src/signals.ts
 function createSignal(first, second, third) {
   if (typeof first === "function") {
-    const node2 = computed(first, second, third);
-    return [
-      read.bind(null, node2),
-      setSignal.bind(null, node2)
-    ];
+    const node = computed(first, second, third);
+    return [read.bind(null, node), setSignal.bind(null, node)];
   }
   const o = getOwner();
   const needsId = o?.id != null;
-  const node = signal(
-    first,
-    needsId ? { id: getNextChildId(o), ...second } : second
-  );
-  return [
-    read.bind(null, node),
-    setSignal.bind(null, node)
-  ];
+  const node = signal(first, needsId ? { id: getNextChildId(o), ...second } : second);
+  return [read.bind(null, node), setSignal.bind(null, node)];
 }
 function createMemo(compute, value, options) {
   let node = computed(compute, value, options);
@@ -1097,33 +1004,46 @@ function createAsync(compute, value, options) {
   return ret;
 }
 function createEffect(compute, effectFn, value, options) {
-  void effect(
-    compute,
-    effectFn.effect || effectFn,
-    effectFn.error,
-    value,
-    { ...options, name: options?.name ?? "effect" } 
-  );
+  void effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
+    ...options,
+    name: options?.name ?? "effect"
+  });
 }
 function createRenderEffect(compute, effectFn, value, options) {
-  void effect(compute, effectFn, void 0, value, {
+  void effect(compute, effectFn, undefined, value, {
     render: true,
-    ...{ ...options, name: options?.name ?? "effect" } 
+    ...{ ...options, name: options?.name ?? "effect" }
   });
 }
-function createTrackedEffect(compute, options) {
-}
-function createReaction(effect2, options) {
+function createTrackedEffect(compute, options) {}
+function createReaction(effectFn, options) {
+  let cleanup = undefined;
+  onCleanup(() => cleanup?.());
+  const owner = getOwner();
+  return tracking => {
+    runWithOwner(owner, () => {
+      effect(
+        () => (tracking(), getOwner()),
+        node => {
+          cleanup?.();
+          cleanup = (effectFn.effect || effectFn)?.();
+          dispose(node);
+        },
+        effectFn.error,
+        undefined,
+        { defer: true, ...(true ? { ...options, name: options?.name ?? "effect" } : options) }
+      );
+    });
+  };
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
-    createRoot((dispose) => {
+    createRoot(dispose => {
       computed(() => {
         try {
           res(fn());
         } catch (err) {
-          if (err instanceof NotReadyError)
-            throw err;
+          if (err instanceof NotReadyError) throw err;
           rej(err);
         }
         dispose();
@@ -1135,42 +1055,63 @@ function createOptimistic(first, second, third) {
   return {};
 }
 function onSettled(callback) {
+  let cleanup;
+  const o = getOwner();
+  if (o) onCleanup(() => cleanup?.());
+  globalQueue.enqueue(EFFECT_USER, () => {
+    cleanup = callback();
+    !o && cleanup?.();
+  });
 }
-
-// src/store/reconcile.ts
 function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
 }
 function getOverrideValue(value, override, nodes, key) {
-  return nodes && key in nodes ? read(nodes[key]) : override && key in override ? override[key] : value[key];
+  return nodes && key in nodes
+    ? read(nodes[key])
+    : override && key in override
+      ? override[key]
+      : value[key];
 }
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
   const nextKeys = Object.keys(next);
-  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
+  return Array.from(new Set([...keys, ...nextKeys]));
 }
 function applyState(next, state, keyFn, all) {
   const target = state?.[$TARGET];
-  if (!target)
-    return;
+  if (!target) return;
   const previous = target[STORE_VALUE];
   const override = target[STORE_OVERRIDE];
   let nodes = target[STORE_NODE];
-  if (next === previous && !override)
-    return;
+  if (next === previous && !override) return;
   (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
   target[STORE_VALUE] = next;
-  target[STORE_OVERRIDE] = void 0;
+  target[STORE_OVERRIDE] = undefined;
   if (Array.isArray(previous)) {
     let changed = false;
     const prevLength = getOverrideValue(previous, override, nodes, "length");
     if (next.length && prevLength && 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, nodes, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
+      for (
+        start = 0, end = Math.min(prevLength, next.length);
+        start < end &&
+        ((item = getOverrideValue(previous, override, nodes, start)) === next[start] ||
+          (item && next[start] && keyFn(item) === keyFn(next[start])));
+        start++
+      ) {
         applyState(next[start], wrap(item, target), keyFn, all);
       }
-      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
-      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, nodes, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
+      const temp = new Array(next.length),
+        newIndices = new Map();
+      for (
+        end = prevLength - 1, newEnd = next.length - 1;
+        end >= start &&
+        newEnd >= start &&
+        ((item = getOverrideValue(previous, override, nodes, end)) === next[newEnd] ||
+          (item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])));
+        end--, newEnd--
+      ) {
         temp[newEnd] = item;
       }
       if (start > newEnd || start > end) {
@@ -1185,7 +1126,9 @@ function applyState(next, state, keyFn, all) {
           applyState(next[j], wrapped, keyFn, all);
         }
         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);
+        prevLength !== next.length &&
+          target[STORE_NODE].length &&
+          setSignal(target[STORE_NODE].length, next.length);
         return;
       }
       newIndicesNext = new Array(newEnd + 1);
@@ -1193,14 +1136,14 @@ function applyState(next, state, keyFn, all) {
         item = next[j];
         keyVal = item ? keyFn(item) : item;
         i = newIndices.get(keyVal);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
         item = getOverrideValue(previous, override, nodes, i);
         keyVal = item ? keyFn(item) : item;
         j = newIndices.get(keyVal);
-        if (j !== void 0 && j !== -1) {
+        if (j !== undefined && j !== -1) {
           temp[j] = item;
           j = newIndicesNext[j];
           newIndices.set(keyVal, j);
@@ -1211,11 +1154,9 @@ function applyState(next, state, keyFn, all) {
           const wrapped = wrap(temp[j], target);
           target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
           applyState(next[j], wrapped, keyFn, all);
-        } else
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
       }
-      if (start < next.length)
-        changed = true;
+      if (start < next.length) changed = true;
     } else if (prevLength && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
         const item = getOverrideValue(previous, override, nodes, i);
@@ -1237,16 +1178,18 @@ function applyState(next, state, keyFn, all) {
       const node = nodes[key];
       const previousValue = unwrap(getOverrideValue(previous, override, nodes, key));
       let nextValue = unwrap(next[key]);
-      if (previousValue === nextValue)
-        continue;
-      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
+      if (previousValue === nextValue) continue;
+      if (
+        !previousValue ||
+        !isWrappable(previousValue) ||
+        (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
+      ) {
         tracked && setSignal(tracked, void 0);
         node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else
-        applyState(nextValue, wrap(previousValue, target), keyFn, all);
+      } else applyState(nextValue, wrap(previousValue, target), keyFn, all);
     }
   }
-  if (nodes = target[STORE_HAS]) {
+  if ((nodes = target[STORE_HAS])) {
     const keys = Object.keys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
@@ -1255,87 +1198,72 @@ function applyState(next, state, keyFn, all) {
   }
 }
 function reconcile(value, key, all = false) {
-  return (state) => {
-    if (state == null)
-      throw new Error("Cannot reconcile null or undefined state");
-    const keyFn = typeof key === "string" ? (item) => item[key] : key;
+  return state => {
+    if (state == null) throw new Error("Cannot reconcile null or undefined state");
+    const keyFn = typeof key === "string" ? item => item[key] : key;
     const eq = keyFn(state);
-    if (eq !== void 0 && keyFn(value) !== keyFn(state))
+    if (eq !== undefined && keyFn(value) !== keyFn(state))
       throw new Error("Cannot reconcile states with different identity");
     applyState(value, state, keyFn, all);
   };
 }
-
-// src/store/projection.ts
 function createProjectionInternal(fn, initialValue = {}, options) {
   let node;
-  const wrappedMap = /* @__PURE__ */ new WeakMap();
-  const traps = {
-    ...storeTraps,
-    get(target, property, receiver) {
-      const o = getOwner();
-      const n = node;
-      (!o || o !== n) && n && read(n);
-      return storeTraps.get(target, property, receiver);
-    }
-  };
-  const wrapProjection = (source) => {
-    if (wrappedMap.has(source))
-      return wrappedMap.get(source);
-    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
-      return source;
-    const wrapped = createStoreProxy(source, traps, {
+  const wrappedMap = new WeakMap();
+  const wrapProjection = source => {
+    if (wrappedMap.has(source)) return wrappedMap.get(source);
+    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection) return source;
+    const wrapped = createStoreProxy(source, storeTraps, {
       [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+      [STORE_LOOKUP]: wrappedMap,
+      [STORE_FIREWALL]() {
+        return node;
+      }
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
-    storeSetter(wrappedStore, (s) => {
+    storeSetter(wrappedStore, s => {
       const value = fn(s);
-      if (value !== s && value !== void 0) {
+      if (value !== s && value !== undefined) {
         reconcile(value, options?.key || "id", options?.all)(s);
       }
     });
   });
-  return { store: wrappedStore, node };
+  return { store: wrappedStore, node: node };
 }
 function createProjection(fn, initialValue = {}, options) {
   return createProjectionInternal(fn, initialValue, options).store;
 }
-
-// src/store/store.ts
-var $TRACK = Symbol("STORE_TRACK" );
-var $DEEP = Symbol("STORE_DEEP" );
-var $TARGET = Symbol("STORE_TARGET" );
-var $PROXY = Symbol("STORE_PROXY" );
-var $DELETED = Symbol("STORE_DELETED" );
-var PARENTS = /* @__PURE__ */ new WeakMap();
-var STORE_VALUE = "v";
-var STORE_OVERRIDE = "o";
-var STORE_NODE = "n";
-var STORE_HAS = "h";
-var STORE_WRAP = "w";
-var STORE_LOOKUP = "l";
+const $TRACK = Symbol("STORE_TRACK"),
+  $DEEP = Symbol("STORE_DEEP"),
+  $TARGET = Symbol("STORE_TARGET"),
+  $PROXY = Symbol("STORE_PROXY"),
+  $DELETED = Symbol("STORE_DELETED");
+const PARENTS = new WeakMap();
+const STORE_VALUE = "v",
+  STORE_OVERRIDE = "o",
+  STORE_NODE = "n",
+  STORE_HAS = "h",
+  STORE_WRAP = "w",
+  STORE_LOOKUP = "l",
+  STORE_FIREWALL = "f";
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
     newTarget = [];
     newTarget.v = value;
-  } else
-    newTarget = { v: value };
+  } else newTarget = { v: value };
   extend && Object.assign(newTarget, extend);
-  return newTarget[$PROXY] = new Proxy(newTarget, traps);
+  return (newTarget[$PROXY] = new Proxy(newTarget, traps));
 }
-var storeLookup = /* @__PURE__ */ new WeakMap();
+const storeLookup = new WeakMap();
 function wrap(value, target) {
-  if (target?.[STORE_WRAP])
-    return target[STORE_WRAP](value, target);
+  if (target?.[STORE_WRAP]) return target[STORE_WRAP](value, target);
   let p = value[$PROXY] || storeLookup.get(value);
-  if (!p)
-    storeLookup.set(value, p = createStoreProxy(value));
+  if (!p) storeLookup.set(value, (p = createStoreProxy(value)));
   return p;
 }
 function isWrappable(obj) {
@@ -1343,54 +1271,52 @@ function isWrappable(obj) {
 }
 function getNodes(target, type) {
   let nodes = target[type];
-  if (!nodes)
-    target[type] = nodes = /* @__PURE__ */ Object.create(null);
+  if (!nodes) target[type] = nodes = Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, equals = isEqual) {
-  if (nodes[property])
-    return nodes[property];
-  return nodes[property] = signal(value, {
-    equals,
-    unobserved() {
-      delete nodes[property];
-    }
-  });
+function getNode(nodes, property, value, firewall, equals = isEqual) {
+  if (nodes[property]) return nodes[property];
+  return (nodes[property] = signal(
+    value,
+    {
+      equals: equals,
+      unobserved() {
+        delete nodes[property];
+      }
+    },
+    firewall
+  ));
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
+  getObserver() &&
+    read(
+      getNode(getNodes(target, STORE_NODE), symbol, undefined, target[STORE_FIREWALL]?.(), false)
+    );
 }
 function getKeys(source, override, enumerable = true) {
-  const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
-  if (!override)
-    return baseKeys;
+  const baseKeys = untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)));
+  if (!override) return baseKeys;
   const keys = new Set(baseKeys);
   const overrides = Reflect.ownKeys(override);
   for (const key of overrides) {
-    if (override[key] !== $DELETED)
-      keys.add(key);
-    else
-      keys.delete(key);
+    if (override[key] !== $DELETED) keys.add(key);
+    else keys.delete(key);
   }
   return Array.from(keys);
 }
 function getPropertyDescriptor(source, override, property) {
   let value = source;
   if (override && property in override) {
-    if (value[property] === $DELETED)
-      return void 0;
-    if (!(property in value))
-      value = override;
+    if (value[property] === $DELETED) return void 0;
+    if (!(property in value)) value = override;
   }
   return Reflect.getOwnPropertyDescriptor(value, property);
 }
-var Writing = null;
-var storeTraps = {
+let Writing = null;
+const storeTraps = {
   get(target, property, receiver) {
-    if (property === $TARGET)
-      return target;
-    if (property === $PROXY)
-      return receiver;
+    if (property === $TARGET) return target;
+    if (property === $PROXY) return receiver;
     if (property === $TRACK || property === $DEEP) {
       trackSelf(target, property);
       return receiver;
@@ -1402,35 +1328,56 @@ var storeTraps = {
     const storeValue = overridden ? target[STORE_OVERRIDE] : target[STORE_VALUE];
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
-      if (desc && desc.get)
-        return desc.get.call(receiver);
+      if (desc && desc.get) return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked._pendingValue !== NOT_PENDING ? tracked._pendingValue : tracked._value : storeValue[property];
-      value2 === $DELETED && (value2 = void 0);
-      if (!isWrappable(value2))
-        return value2;
-      const wrapped = wrap(value2, target);
+      let value =
+        tracked && (overridden || !proxySource)
+          ? tracked._pendingValue !== NOT_PENDING
+            ? tracked._pendingValue
+            : tracked._value
+          : storeValue[property];
+      value === $DELETED && (value = undefined);
+      if (!isWrappable(value)) return value;
+      const wrapped = wrap(value, target);
       Writing.add(wrapped);
       return wrapped;
     }
-    let value = tracked ? overridden || !proxySource ? read(nodes[property]) : (read(nodes[property]), storeValue[property]) : storeValue[property];
-    value === $DELETED && (value = void 0);
+    let value = tracked
+      ? overridden || !proxySource
+        ? read(nodes[property])
+        : (read(nodes[property]), storeValue[property])
+      : storeValue[property];
+    value === $DELETED && (value = undefined);
     if (!tracked) {
       if (!overridden && typeof value === "function" && !storeValue.hasOwnProperty(property)) {
         let proto;
-        return !Array.isArray(target[STORE_VALUE]) && (proto = Object.getPrototypeOf(target[STORE_VALUE])) && proto !== Object.prototype ? value.bind(storeValue) : value;
+        return !Array.isArray(target[STORE_VALUE]) &&
+          (proto = Object.getPrototypeOf(target[STORE_VALUE])) &&
+          proto !== Object.prototype
+          ? value.bind(storeValue)
+          : value;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(
+          getNode(
+            nodes,
+            property,
+            isWrappable(value) ? wrap(value, target) : value,
+            target[STORE_FIREWALL]?.()
+          )
+        );
       }
     }
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
-    if (property === $PROXY || property === $TRACK || property === "__proto__")
-      return true;
-    const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
+    if (property === $PROXY || property === $TRACK || property === "__proto__") return true;
+    const has =
+      target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+        ? target[STORE_OVERRIDE][property] !== $DELETED
+        : property in target[STORE_VALUE];
+    getObserver() &&
+      read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]?.()));
     return has;
   },
   set(target, property, rawValue) {
@@ -1439,31 +1386,32 @@ var storeTraps = {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
-        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : base;
+        const prev =
+          target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+            ? target[STORE_OVERRIDE][property]
+            : base;
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
-        if (prev === value)
-          return true;
+        if (prev === value) return true;
         const len = target[STORE_OVERRIDE]?.length || state.length;
-        if (value !== void 0 && value === base)
-          delete target[STORE_OVERRIDE][property];
+        if (value !== undefined && value === base) delete target[STORE_OVERRIDE][property];
         else
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = value;
+          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = Object.create(null)))[property] =
+            value;
         const wrappable = isWrappable(value);
         if (isWrappable(prev)) {
           const parents = PARENTS.get(prev);
           parents && (parents instanceof Set ? parents.delete(store) : PARENTS.delete(prev));
         }
-        if (recursivelyNotify(store, storeLookup) && wrappable)
-          recursivelyAddParent(value, store);
+        if (recursivelyNotify(store, storeLookup) && wrappable) recursivelyAddParent(value, store);
         target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
         const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], () => wrappable ? wrap(value, target) : value);
+        nodes[property] &&
+          setSignal(nodes[property], () => (wrappable ? wrap(value, target) : value));
         if (Array.isArray(state)) {
           const index = parseInt(property) + 1;
-          if (index > len)
-            nodes.length && setSignal(nodes.length, index);
+          if (index > len) nodes.length && setSignal(nodes.length, index);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
+        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
       });
     }
     return true;
@@ -1471,22 +1419,24 @@ var storeTraps = {
   deleteProperty(target, property) {
     if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
       untrack(() => {
-        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : target[STORE_VALUE][property];
+        const prev =
+          target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+            ? target[STORE_OVERRIDE][property]
+            : target[STORE_VALUE][property];
         if (property in target[STORE_VALUE]) {
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = $DELETED;
+          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = Object.create(null)))[property] =
+            $DELETED;
         } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
           delete target[STORE_OVERRIDE][property];
-        } else
-          return true;
+        } else return true;
         if (isWrappable(prev)) {
           const parents = PARENTS.get(prev);
           parents && (parents instanceof Set ? parents.delete(target) : PARENTS.delete(prev));
         }
-        if (target[STORE_HAS]?.[property])
-          setSignal(target[STORE_HAS][property], false);
+        if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], false);
         const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], void 0);
-        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
+        nodes[property] && setSignal(nodes[property], undefined);
+        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
       });
     }
     return true;
@@ -1496,8 +1446,7 @@ var storeTraps = {
     return getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
   },
   getOwnPropertyDescriptor(target, property) {
-    if (property === $PROXY)
-      return { value: target[$PROXY], writable: true, configurable: true };
+    if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
     return getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
   },
   getPrototypeOf(target) {
@@ -1506,22 +1455,19 @@ var storeTraps = {
 };
 function storeSetter(store, fn) {
   const prevWriting = Writing;
-  Writing = /* @__PURE__ */ new Set();
+  Writing = new Set();
   Writing.add(store);
   try {
     const value = fn(store);
-    if (value !== store && value !== void 0) {
+    if (value !== store && value !== undefined) {
       if (Array.isArray(value)) {
-        for (let i = 0, len = value.length; i < len; i++)
-          store[i] = value[i];
+        for (let i = 0, len = value.length; i < len; i++) store[i] = value[i];
         store.length = value.length;
       } else {
-        const keys = /* @__PURE__ */ new Set([...Object.keys(store), ...Object.keys(value)]);
-        keys.forEach((key) => {
-          if (key in value)
-            store[key] = value[key];
-          else
-            delete store[key];
+        const keys = new Set([...Object.keys(store), ...Object.keys(value)]);
+        keys.forEach(key => {
+          if (key in value) store[key] = value[key];
+          else delete store[key];
         });
       }
     }
@@ -1531,28 +1477,26 @@ function storeSetter(store, fn) {
   }
 }
 function createStore(first, second, options) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
-  return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
+  const derived = typeof first === "function",
+    wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
+  return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
 }
 function recursivelyNotify(state, lookup) {
   let target = state[$TARGET] || lookup?.get(state)?.[$TARGET];
   let notified = false;
   if (target) {
-    const deep2 = getNodes(target, STORE_NODE)[$DEEP];
-    if (deep2) {
-      setSignal(deep2, void 0);
+    const deep = getNodes(target, STORE_NODE)[$DEEP];
+    if (deep) {
+      setSignal(deep, undefined);
       notified = true;
     }
     lookup = target[STORE_LOOKUP] || lookup;
   }
   const parents = PARENTS.get(target?.[STORE_VALUE] || state);
-  if (!parents)
-    return notified;
+  if (!parents) return notified;
   if (parents instanceof Set) {
-    for (let parent of parents)
-      notified = recursivelyNotify(parent, lookup) || notified;
-  } else
-    notified = recursivelyNotify(parents, lookup) || notified;
+    for (let parent of parents) notified = recursivelyNotify(parent, lookup) || notified;
+  } else notified = recursivelyNotify(parents, lookup) || notified;
   return notified;
 }
 function recursivelyAddParent(state, parent) {
@@ -1564,16 +1508,12 @@ function recursivelyAddParent(state, parent) {
   }
   if (parent) {
     let parents = PARENTS.get(state);
-    if (!parents)
-      PARENTS.set(state, parent);
+    if (!parents) PARENTS.set(state, parent);
     else if (parents !== parent) {
-      if (!(parents instanceof Set))
-        PARENTS.set(state, parents = /* @__PURE__ */ new Set([parents]));
-      else if (parents.has(parent))
-        return;
+      if (!(parents instanceof Set)) PARENTS.set(state, (parents = new Set([parents])));
+      else if (parents.has(parent)) return;
       parents.add(parent);
-    } else
-      return;
+    } else return;
   }
   if (Array.isArray(state)) {
     const len = override?.length || state.length;
@@ -1594,27 +1534,22 @@ function deep(store) {
   recursivelyAddParent(store);
   return store[$DEEP];
 }
-
-// src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
   return [];
 }
-
-// src/store/utils.ts
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
-  if (!isWrappable(item))
-    return item;
-  if (map && map.has(item))
-    return map.get(item);
-  if (!map)
-    map = /* @__PURE__ */ new Map();
-  if (target = item[$TARGET] || lookup?.get(item)?.[$TARGET]) {
+  if (!isWrappable(item)) return item;
+  if (map && map.has(item)) return map.get(item);
+  if (!map) map = new Map();
+  if ((target = item[$TARGET] || lookup?.get(item)?.[$TARGET])) {
     override = target[STORE_OVERRIDE];
     isArray = Array.isArray(target[STORE_VALUE]);
     map.set(
       item,
-      override ? result = isArray ? [] : Object.create(Object.getPrototypeOf(target[STORE_VALUE])) : target[STORE_VALUE]
+      override
+        ? (result = isArray ? [] : Object.create(Object.getPrototypeOf(target[STORE_VALUE])))
+        : target[STORE_VALUE]
     );
     item = target[STORE_VALUE];
     lookup = storeLookup;
@@ -1626,11 +1561,9 @@ function snapshot(item, map, lookup) {
     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;
+      if (v === $DELETED) continue;
       if ((unwrapped = snapshot(v, map, lookup)) !== v || result) {
-        if (!result)
-          map.set(item, result = [...item]);
+        if (!result) map.set(item, (result = [...item]));
         result[i] = unwrapped;
       }
     }
@@ -1639,8 +1572,7 @@ function snapshot(item, map, lookup) {
     for (let i = 0, l = keys.length; i < l; i++) {
       let prop = keys[i];
       const desc = getPropertyDescriptor(item, override, prop);
-      if (desc.get)
-        continue;
+      if (desc.get) continue;
       v = override && prop in override ? override[prop] : item[prop];
       if ((unwrapped = snapshot(v, map, lookup)) !== item[prop] || result) {
         if (!result) {
@@ -1656,15 +1588,13 @@ function snapshot(item, map, lookup) {
 function trueFn() {
   return true;
 }
-var propTraps = {
+const propTraps = {
   get(_, property, receiver) {
-    if (property === $PROXY)
-      return receiver;
+    if (property === $PROXY) return receiver;
     return _.get(property);
   },
   has(_, property) {
-    if (property === $PROXY)
-      return true;
+    if (property === $PROXY) return true;
     return _.has(property);
   },
   set: trueFn,
@@ -1687,39 +1617,31 @@ var propTraps = {
 function resolveSource(s) {
   return !(s = typeof s === "function" ? s() : s) ? {} : s;
 }
-var $SOURCES = Symbol("MERGE_SOURCE" );
+const $SOURCES = Symbol("MERGE_SOURCE");
 function merge(...sources) {
-  if (sources.length === 1 && typeof sources[0] !== "function")
-    return sources[0];
+  if (sources.length === 1 && typeof sources[0] !== "function") return sources[0];
   let proxy = false;
   const flattened = [];
   for (let i = 0; i < sources.length; i++) {
     const s = sources[i];
-    proxy = proxy || !!s && $PROXY in s;
+    proxy = proxy || (!!s && $PROXY in s);
     const childSources = !!s && s[$SOURCES];
-    if (childSources)
-      flattened.push(...childSources);
-    else
-      flattened.push(
-        typeof s === "function" ? (proxy = true, createMemo(s)) : s
-      );
+    if (childSources) flattened.push(...childSources);
+    else flattened.push(typeof s === "function" ? ((proxy = true), createMemo(s)) : s);
   }
   if (SUPPORTS_PROXY && proxy) {
     return new Proxy(
       {
         get(property) {
-          if (property === $SOURCES)
-            return flattened;
+          if (property === $SOURCES) return flattened;
           for (let i = flattened.length - 1; i >= 0; i--) {
             const s = resolveSource(flattened[i]);
-            if (property in s)
-              return s[property];
+            if (property in s) return s[property];
           }
         },
         has(property) {
           for (let i = flattened.length - 1; i >= 0; i--) {
-            if (property in resolveSource(flattened[i]))
-              return true;
+            if (property in resolveSource(flattened[i])) return true;
           }
           return false;
         },
@@ -1733,7 +1655,7 @@ function merge(...sources) {
       propTraps
     );
   }
-  const defined = /* @__PURE__ */ Object.create(null);
+  const defined = Object.create(null);
   let nonTargetKey = false;
   let lastIndex = flattened.length - 1;
   for (let i = lastIndex; i >= 0; i--) {
@@ -1745,29 +1667,24 @@ function merge(...sources) {
     const sourceKeys = Object.getOwnPropertyNames(source);
     for (let j = sourceKeys.length - 1; j >= 0; j--) {
       const key = sourceKeys[j];
-      if (key === "__proto__" || key === "constructor")
-        continue;
+      if (key === "__proto__" || key === "constructor") continue;
       if (!defined[key]) {
         nonTargetKey = nonTargetKey || i !== lastIndex;
         const desc = Object.getOwnPropertyDescriptor(source, key);
-        defined[key] = desc.get ? {
-          enumerable: true,
-          configurable: true,
-          get: desc.get.bind(source)
-        } : desc;
+        defined[key] = desc.get
+          ? { enumerable: true, configurable: true, get: desc.get.bind(source) }
+          : desc;
       }
     }
   }
-  if (!nonTargetKey)
-    return flattened[lastIndex];
+  if (!nonTargetKey) return flattened[lastIndex];
   const target = {};
   const definedKeys = Object.keys(defined);
   for (let i = definedKeys.length - 1; i >= 0; i--) {
-    const key = definedKeys[i], desc = defined[key];
-    if (desc.get)
-      Object.defineProperty(target, key, desc);
-    else
-      target[key] = desc.value;
+    const key = definedKeys[i],
+      desc = defined[key];
+    if (desc.get) Object.defineProperty(target, key, desc);
+    else target[key] = desc.value;
   }
   target[$SOURCES] = flattened;
   return target;
@@ -1778,13 +1695,13 @@ function omit(props, ...keys) {
     return new Proxy(
       {
         get(property) {
-          return blocked.has(property) ? void 0 : props[property];
+          return blocked.has(property) ? undefined : props[property];
         },
         has(property) {
           return !blocked.has(property) && property in props;
         },
         keys() {
-          return Object.keys(props).filter((k) => !blocked.has(k));
+          return Object.keys(props).filter(k => !blocked.has(k));
         }
       },
       propTraps
@@ -1794,15 +1711,15 @@ function omit(props, ...keys) {
   for (const propName of Object.getOwnPropertyNames(props)) {
     if (!blocked.has(propName)) {
       const desc = Object.getOwnPropertyDescriptor(props, propName);
-      !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable ? result[propName] = desc.value : Object.defineProperty(result, propName, desc);
+      !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable
+        ? (result[propName] = desc.value)
+        : Object.defineProperty(result, propName, desc);
     }
   }
   return result;
 }
-
-// src/map.ts
 function mapArray(list, map, options) {
-  const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
+  const keyFn = typeof options?.keyed === "function" ? options.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
       _owner: createOwner(),
@@ -1813,35 +1730,39 @@ function mapArray(list, map, options) {
       _mappings: [],
       _nodes: [],
       _key: keyFn,
-      _rows: keyFn || options?.keyed === false ? [] : void 0,
-      _indexes: map.length > 1 ? [] : void 0,
+      _rows: keyFn || options?.keyed === false ? [] : undefined,
+      _indexes: map.length > 1 ? [] : undefined,
       _fallback: options?.fallback
     })
   );
 }
-var pureOptions = { pureWrite: true };
+const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this._list() || [], newLen = newItems.length;
+  const newItems = this._list() || [],
+    newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this._owner, () => {
-    let i, j, mapper = this._rows ? () => {
-      this._rows[j] = signal(newItems[j], pureOptions);
-      this._indexes && (this._indexes[j] = signal(j, pureOptions));
-      return this._map(
-        read.bind(null, this._rows[j]),
-        this._indexes ? read.bind(null, this._indexes[j]) : void 0
-      );
-    } : this._indexes ? () => {
-      const item = newItems[j];
-      this._indexes[j] = signal(j, pureOptions);
-      return this._map(
-        () => item,
-        read.bind(null, this._indexes[j])
-      );
-    } : () => {
-      const item = newItems[j];
-      return this._map(() => item);
-    };
+    let i,
+      j,
+      mapper = this._rows
+        ? () => {
+            this._rows[j] = signal(newItems[j], pureOptions);
+            this._indexes && (this._indexes[j] = signal(j, pureOptions));
+            return this._map(
+              read.bind(null, this._rows[j]),
+              this._indexes ? read.bind(null, this._indexes[j]) : undefined
+            );
+          }
+        : this._indexes
+          ? () => {
+              const item = newItems[j];
+              this._indexes[j] = signal(j, pureOptions);
+              return this._map(() => item, read.bind(null, this._indexes[j]));
+            }
+          : () => {
+              const item = newItems[j];
+              return this._map(() => item);
+            };
     if (newLen === 0) {
       if (this._len !== 0) {
         this._owner.dispose(false);
@@ -1853,54 +1774,71 @@ function updateKeyedMap() {
         this._indexes && (this._indexes = []);
       }
       if (this._fallback && !this._mappings[0]) {
-        this._mappings[0] = runWithOwner(
-          this._nodes[0] = createOwner(),
-          this._fallback
-        );
+        this._mappings[0] = runWithOwner((this._nodes[0] = createOwner()), this._fallback);
       }
     } else if (this._len === 0) {
-      if (this._nodes[0])
-        this._nodes[0].dispose();
+      if (this._nodes[0]) this._nodes[0].dispose();
       this._mappings = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this._items[j] = newItems[j];
-        this._mappings[j] = runWithOwner(this._nodes[j] = createOwner(), mapper);
+        this._mappings[j] = runWithOwner((this._nodes[j] = createOwner()), mapper);
       }
       this._len = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this._rows ? new Array(newLen) : void 0, tempIndexes = this._indexes ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this._len, newLen); start < end && (this._items[start] === newItems[start] || this._rows && compare(this._key, this._items[start], newItems[start])); start++) {
-        if (this._rows)
-          setSignal(this._rows[start], newItems[start]);
+      let start,
+        end,
+        newEnd,
+        item,
+        key,
+        newIndices,
+        newIndicesNext,
+        temp = new Array(newLen),
+        tempNodes = new Array(newLen),
+        tempRows = this._rows ? new Array(newLen) : undefined,
+        tempIndexes = this._indexes ? new Array(newLen) : undefined;
+      for (
+        start = 0, end = Math.min(this._len, newLen);
+        start < end &&
+        (this._items[start] === newItems[start] ||
+          (this._rows && compare(this._key, this._items[start], newItems[start])));
+        start++
+      ) {
+        if (this._rows) setSignal(this._rows[start], newItems[start]);
       }
-      for (end = this._len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this._items[end] === newItems[newEnd] || this._rows && compare(this._key, this._items[end], newItems[newEnd])); end--, newEnd--) {
+      for (
+        end = this._len - 1, newEnd = newLen - 1;
+        end >= start &&
+        newEnd >= start &&
+        (this._items[end] === newItems[newEnd] ||
+          (this._rows && compare(this._key, this._items[end], newItems[newEnd])));
+        end--, newEnd--
+      ) {
         temp[newEnd] = this._mappings[end];
         tempNodes[newEnd] = this._nodes[end];
         tempRows && (tempRows[newEnd] = this._rows[end]);
         tempIndexes && (tempIndexes[newEnd] = this._indexes[end]);
       }
-      newIndices = /* @__PURE__ */ new Map();
+      newIndices = new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
         key = this._key ? this._key(item) : item;
         i = newIndices.get(key);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
         item = this._items[i];
         key = this._key ? this._key(item) : item;
         j = newIndices.get(key);
-        if (j !== void 0 && j !== -1) {
+        if (j !== undefined && j !== -1) {
           temp[j] = this._mappings[i];
           tempNodes[j] = this._nodes[i];
           tempRows && (tempRows[j] = this._rows[i]);
           tempIndexes && (tempIndexes[j] = this._indexes[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
-        } else
-          this._nodes[i].dispose();
+        } else this._nodes[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
@@ -1915,10 +1853,10 @@ function updateKeyedMap() {
             setSignal(this._indexes[j], j);
           }
         } else {
-          this._mappings[j] = runWithOwner(this._nodes[j] = createOwner(), mapper);
+          this._mappings[j] = runWithOwner((this._nodes[j] = createOwner()), mapper);
         }
       }
-      this._mappings = this._mappings.slice(0, this._len = newLen);
+      this._mappings = this._mappings.slice(0, (this._len = newLen));
       this._items = newItems.slice(0);
     }
   });
@@ -1949,23 +1887,17 @@ function updateRepeat() {
         this._len = 0;
       }
       if (this._fallback && !this._mappings[0]) {
-        this._mappings[0] = runWithOwner(
-          this._nodes[0] = createOwner(),
-          this._fallback
-        );
+        this._mappings[0] = runWithOwner((this._nodes[0] = createOwner()), this._fallback);
       }
       return;
     }
     const to = from + newLen;
     const prevTo = this._offset + this._len;
-    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._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();
+      while (i < from && i < this._len) this._nodes[i++].dispose();
       this._nodes.splice(0, from - this._offset);
       this._mappings.splice(0, from - this._offset);
     } else if (this._offset > from) {
@@ -1977,17 +1909,15 @@ function updateRepeat() {
         this._mappings[i] = this._mappings[i - difference];
         i--;
       }
-      for (let i2 = 0; i2 < difference; i2++) {
-        this._mappings[i2] = runWithOwner(
-          this._nodes[i2] = createOwner(),
-          () => this._map(i2 + from)
+      for (let i = 0; i < difference; i++) {
+        this._mappings[i] = runWithOwner((this._nodes[i] = createOwner()), () =>
+          this._map(i + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this._mappings[i - from] = runWithOwner(
-        this._nodes[i - from] = createOwner(),
-        () => this._map(i)
+      this._mappings[i - from] = runWithOwner((this._nodes[i - from] = createOwner()), () =>
+        this._map(i)
       );
     }
     this._mappings = this._mappings.slice(0, newLen);
@@ -1999,16 +1929,14 @@ function updateRepeat() {
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
-
-// src/boundaries.ts
 function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, void 0, {
+  const node = computed(fn, undefined, {
     _internal: {
       _notifyQueue() {
         let flags = this._statusFlags;
         this._statusFlags &= ~this._propagationMask;
-        if (this._propagationMask & 1 /* Pending */ && !(this._statusFlags & 4 /* Uninitialized */)) {
-          flags &= ~1 /* Pending */;
+        if (this._propagationMask & STATUS_PENDING && !(this._statusFlags & STATUS_UNINITIALIZED)) {
+          flags &= ~STATUS_PENDING;
         }
         this._queue.notify(this, this._propagationMask, flags);
       },
@@ -2020,49 +1948,46 @@ function boundaryComputed(fn, propagationMask) {
 }
 function createBoundChildren(owner, fn, queue, mask) {
   const parentQueue = owner._queue;
-  parentQueue.addChild(owner._queue = queue);
+  parentQueue.addChild((owner._queue = queue));
   onCleanup(() => parentQueue.removeChild(owner._queue));
   return runWithOwner(owner, () => {
     const c = computed(fn);
     return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
   });
 }
-var ConditionalQueue = class extends Queue {
+class ConditionalQueue extends Queue {
   _disabled;
-  _errorNodes = /* @__PURE__ */ new Set();
-  _pendingNodes = /* @__PURE__ */ new Set();
+  _errorNodes = new Set();
+  _pendingNodes = new Set();
   constructor(disabled) {
     super();
     this._disabled = disabled;
   }
   run(type) {
-    if (!type || read(this._disabled))
-      return;
+    if (!type || read(this._disabled)) return;
     return super.run(type);
   }
   notify(node, type, flags) {
     if (read(this._disabled)) {
-      if (type & 1 /* Pending */) {
-        if (flags & 1 /* Pending */) {
+      if (type & STATUS_PENDING) {
+        if (flags & STATUS_PENDING) {
           this._pendingNodes.add(node);
-          type &= ~1 /* Pending */;
-        } else if (this._pendingNodes.delete(node))
-          type &= ~1 /* Pending */;
+          type &= ~STATUS_PENDING;
+        } else if (this._pendingNodes.delete(node)) type &= ~STATUS_PENDING;
       }
-      if (type & 2 /* Error */) {
-        if (flags & 2 /* Error */) {
+      if (type & STATUS_ERROR) {
+        if (flags & STATUS_ERROR) {
           this._errorNodes.add(node);
-          type &= ~2 /* Error */;
-        } else if (this._errorNodes.delete(node))
-          type &= ~2 /* Error */;
+          type &= ~STATUS_ERROR;
+        } else if (this._errorNodes.delete(node)) type &= ~STATUS_ERROR;
       }
     }
     return type ? super.notify(node, type, flags) : true;
   }
-};
-var CollectionQueue = class extends Queue {
+}
+class CollectionQueue extends Queue {
   _collectionType;
-  _nodes = /* @__PURE__ */ new Set();
+  _nodes = new Set();
   _disabled = signal(false, { pureWrite: true });
   _initialized = false;
   constructor(type) {
@@ -2070,43 +1995,46 @@ var CollectionQueue = class extends Queue {
     this._collectionType = type;
   }
   run(type) {
-    if (!type || read(this._disabled))
-      return;
+    if (!type || read(this._disabled)) return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this._collectionType) || this._collectionType & 1 /* Pending */ && this._initialized)
+    if (
+      !(type & this._collectionType) ||
+      (this._collectionType & STATUS_PENDING && this._initialized)
+    )
       return super.notify(node, type, flags);
     if (flags & this._collectionType) {
       this._nodes.add(node);
-      if (this._nodes.size === 1)
-        setSignal(this._disabled, true);
+      if (this._nodes.size === 1) setSignal(this._disabled, true);
     } else if (this._nodes.size > 0) {
       this._nodes.delete(node);
-      if (this._nodes.size === 0)
-        setSignal(this._disabled, false);
+      if (this._nodes.size === 0) setSignal(this._disabled, false);
     }
     type &= ~this._collectionType;
     return type ? super.notify(node, type, flags) : true;
   }
-};
+}
+var BoundaryMode;
+(function (BoundaryMode) {
+  BoundaryMode["VISIBLE"] = "visible";
+  BoundaryMode["HIDDEN"] = "hidden";
+})(BoundaryMode || (BoundaryMode = {}));
 function createBoundary(fn, condition) {
   const owner = createOwner();
-  const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
+  const queue = new ConditionalQueue(computed(() => condition() === BoundaryMode.HIDDEN));
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
     const disabled = read(queue._disabled);
-    tree._propagationMask = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
+    tree._propagationMask = disabled ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!disabled) {
-      queue._pendingNodes.forEach(
-        (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
-      );
-      queue._errorNodes.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue._pendingNodes.forEach(node => queue.notify(node, STATUS_PENDING, STATUS_PENDING));
+      queue._errorNodes.forEach(node => queue.notify(node, STATUS_ERROR, STATUS_ERROR));
       queue._pendingNodes.clear();
       queue._errorNodes.clear();
     }
   });
-  return () => read(queue._disabled) ? void 0 : read(tree);
+  return () => (read(queue._disabled) ? undefined : read(tree));
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = createOwner();
@@ -2115,8 +2043,7 @@ function createCollectionBoundary(type, fn, fallback) {
   const decision = computed(() => {
     if (!read(queue._disabled)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled)))
-        queue._initialized = true;
+      if (!untrack(() => read(queue._disabled))) queue._initialized = true;
       return resolved;
     }
     return fallback(queue);
@@ -2124,27 +2051,43 @@ function createCollectionBoundary(type, fn, fallback) {
   return read.bind(null, decision);
 }
 function createLoadBoundary(fn, fallback) {
-  return createCollectionBoundary(1 /* Pending */, fn, () => fallback());
+  return createCollectionBoundary(STATUS_PENDING, fn, () => fallback());
+}
+function collectErrorSources(node, sources) {
+  let root = true;
+  let dep = node._deps;
+  while (dep !== null) {
+    const source = dep._dep;
+    if (source._deps && source._statusFlags & STATUS_ERROR) {
+      root = false;
+      collectErrorSources(source, sources);
+    }
+    dep = dep._nextDep;
+  }
+  root && sources.push(node);
 }
 function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(2 /* Error */, fn, (queue) => {
+  return createCollectionBoundary(STATUS_ERROR, fn, queue => {
     let node = queue._nodes.values().next().value;
     return fallback(node._error, () => {
-      for (let node2 of queue._nodes) {
-        recompute(node2, true);
-      }
+      const sources = [];
+      for (const node of queue._nodes) collectErrorSources(node, sources);
+      for (const source of sources) recompute(source);
+      schedule();
     });
   });
 }
 function flatten(children, options) {
   if (typeof children === "function" && !children.length) {
-    if (options?.doNotUnwrap)
-      return children;
+    if (options?.doNotUnwrap) return children;
     do {
       children = children();
     } while (typeof children === "function" && !children.length);
   }
-  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
+  if (
+    options?.skipNonRendered &&
+    (children == null || children === true || children === false || children === "")
+  )
     return;
   if (Array.isArray(children)) {
     let results = [];
@@ -2177,18 +2120,64 @@ function flattenArray(children, results = [], options) {
       }
       if (Array.isArray(child)) {
         needsUnwrap = flattenArray(child, results, options);
-      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
+      } else if (
+        options?.skipNonRendered &&
+        (child == null || child === true || child === false || child === "")
+      ) {
+      } else results.push(child);
     } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
+      if (!(e instanceof NotReadyError)) throw e;
       notReady = e;
     }
   }
-  if (notReady)
-    throw notReady;
+  if (notReady) throw notReady;
   return needsUnwrap;
 }
-
-export { $PROXY, $TARGET, $TRACK, ContextNotFoundError, NoOwnerError, NotReadyError, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createLoadBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getContext, getNextChildId, getObserver, getOwner, isEqual, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, untrack };
+export {
+  $PROXY,
+  $TARGET,
+  $TRACK,
+  ContextNotFoundError,
+  NoOwnerError,
+  NotReadyError,
+  SUPPORTS_PROXY,
+  createAsync,
+  createBoundary,
+  createContext,
+  createEffect,
+  createErrorBoundary,
+  createLoadBoundary,
+  createMemo,
+  createOptimistic,
+  createOptimisticStore,
+  createProjection,
+  createReaction,
+  createRenderEffect,
+  createRoot,
+  createSignal,
+  createStore,
+  createTrackedEffect,
+  deep,
+  flatten,
+  flush,
+  getContext,
+  getNextChildId,
+  getObserver,
+  getOwner,
+  isEqual,
+  isPending,
+  isWrappable,
+  mapArray,
+  merge,
+  omit,
+  onCleanup,
+  onSettled,
+  pending,
+  reconcile,
+  repeat,
+  resolve,
+  runWithOwner,
+  setContext,
+  snapshot,
+  untrack
+};