npm - @solidjs/signals - Versions diffs - 0.8.3 → 0.8.5 - Mend

@solidjs/signals 0.8.3 → 0.8.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/dev.js +761 -815
package/dist/node.cjs +1614 -1858
package/dist/prod.js +1635 -1790
package/dist/types/boundaries.d.ts +1 -1
package/dist/types/core/constants.d.ts +16 -21
package/dist/types/core/core.d.ts +6 -5
package/dist/types/core/heap.d.ts +1 -2
package/dist/types/core/scheduler.d.ts +3 -3
package/package.json +8 -3

package/dist/dev.js CHANGED Viewed

@@ -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];
     }
   }
@@ -130,11 +122,7 @@ function adjustHeight(el, heap) {
   for (let d = el._deps; d; d = d._nextDep) {
     const dep1 = d._dep;
     const dep = dep1._firewall || dep1;
-    if (dep._fn) {
-      if (dep._height >= newHeight) {
-        newHeight = dep._height + 1;
-      }
-    }
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
   }
   if (el._height !== newHeight) {
     el._height = newHeight;
@@ -143,32 +131,18 @@ function adjustHeight(el, heap) {
     }
   }
 }
-// src/core/scheduler.ts
-var clock = 0;
-var activeTransition = null;
-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 = [];
@@ -185,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) {
@@ -200,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) {
@@ -224,72 +196,69 @@ 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;
     }
   }
   notify(node, mask, flags) {
-    if (mask & 1 /* Pending */) {
-      if (flags & 1 /* Pending */) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node._error.cause))
+    if (mask & STATUS_PENDING) {
+      if (flags & STATUS_PENDING) {
+        if (activeTransition && !activeTransition.asyncNodes.includes(node._error.cause)) {
           activeTransition.asyncNodes.push(node._error.cause);
+          schedule();
+        }
       }
       return true;
     }
     return false;
   }
   initTransition(node) {
-    if (activeTransition && activeTransition.time === clock)
-      return;
+    if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
       activeTransition = node._transition ?? {
         time: clock,
@@ -300,14 +269,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();
@@ -318,52 +287,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;
 }
-// src/core/core.ts
+function runInTransition(el, recompute) {
+  const prevTransition = activeTransition;
+  activeTransition = el._transition;
+  recompute(el);
+  activeTransition = prevTransition;
+}
 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 {
@@ -377,29 +351,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;
@@ -407,70 +379,68 @@ 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 honoraryOptimistic = el._type && el._transition != activeTransition;
+  const valueChanged =
+    !el._equals ||
+    !el._equals(
+      el._pendingValue === NOT_PENDING || el._optimistic || honoraryOptimistic
+        ? 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)
-        el._value = value;
+      if (create || el._optimistic || honoraryOptimistic) 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._transition && honoraryOptimistic) 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 = 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?.();
@@ -480,7 +450,7 @@ function unlinkSubs(link2) {
   return nextDep;
 }
 function unobserved(el) {
-  deleteFromHeap(el, el._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
   let dep = el._deps;
   while (dep !== null) {
     dep = unlinkSubs(dep);
@@ -490,11 +460,9 @@ function unobserved(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) {
@@ -503,59 +471,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);
     }
@@ -573,16 +520,14 @@ function dispose(node) {
   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);
@@ -603,8 +548,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];
@@ -613,61 +557,53 @@ 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,
+    _transition: 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;
@@ -676,15 +612,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;
@@ -694,37 +629,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();
@@ -739,45 +672,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,
-        _firewall: 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();
@@ -787,13 +710,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 = el._firewall || el;
     if (owner._fn) {
-      const isZombie = el._flags & 32 /* Zombie */;
+      const isZombie = el._flags & REACTIVE_ZOMBIE;
       if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
@@ -806,25 +728,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 {
@@ -833,18 +751,13 @@ function read(el) {
       pendingValueCheck = true;
     }
   }
-  if (el._statusFlags & 1 /* Pending */) {
-    if (c && !stale || el._statusFlags & 4 /* Uninitialized */)
-      throw el._error;
-    else if (c && stale && !pendingCheck) {
-      setStatusFlags(
-        c,
-        c._statusFlags | 1,
-        el._error
-      );
+  if (el._statusFlags & STATUS_PENDING && !pendingCheck) {
+    if ((c && !stale) || el._statusFlags & STATUS_UNINITIALIZED) throw el._error;
+    else if (c && stale) {
+      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);
@@ -852,31 +765,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 && 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();
@@ -889,8 +806,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;
@@ -909,7 +825,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,
@@ -962,141 +878,123 @@ function pending(fn) {
     pendingValueCheck = prevLatest;
   }
 }
-function isPending(fn, loadingValue) {
+function isPending(fn) {
   const current = pendingCheck;
   pendingCheck = { _value: false };
   try {
     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;
     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);
@@ -1109,54 +1007,49 @@ 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 createTrackedEffect(compute, options) {}
 function createReaction(effectFn, options) {
-  let cleanup = void 0;
+  let cleanup = undefined;
   onCleanup(() => cleanup?.());
-  return (tracking2) => {
-    effect(
-      () => (tracking2(), getOwner()),
-      (node) => {
-        cleanup?.();
-        cleanup = (effectFn.effect || effectFn)?.();
-        dispose(node);
-      },
-      effectFn.error,
-      void 0,
-      {
-        defer: true,
-        ...{ ...options, name: options?.name ?? "effect" }
-      }
-    );
+  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((dispose2) => {
+    createRoot(dispose => {
       computed(() => {
         try {
           res(fn());
         } catch (err) {
-          if (err instanceof NotReadyError)
-            throw err;
+          if (err instanceof NotReadyError) throw err;
           rej(err);
         }
-        dispose2();
+        dispose();
       });
     });
   });
@@ -1167,48 +1060,61 @@ function createOptimistic(first, second, third) {
 function onSettled(callback) {
   let cleanup;
   const o = getOwner();
-  if (o)
-    onCleanup(() => cleanup?.());
-  globalQueue.enqueue(2 /* User */, () => {
+  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) {
@@ -1223,7 +1129,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);
@@ -1231,14 +1139,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);
@@ -1249,11 +1157,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);
@@ -1275,16 +1181,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];
@@ -1293,26 +1201,21 @@ 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 wrapProjection = (source) => {
-    if (wrappedMap.has(source))
-      return wrappedMap.get(source);
-    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
-      return source;
+  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,
@@ -1325,50 +1228,45 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   };
   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";
-var STORE_FIREWALL = "f";
+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) {
@@ -1376,60 +1274,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, firewall, equals = isEqual) {
-  if (nodes[property])
-    return nodes[property];
-  return nodes[property] = signal(
+  if (nodes[property]) return nodes[property];
+  return (nodes[property] = signal(
     value,
     {
-      equals,
+      equals: equals,
       unobserved() {
         delete nodes[property];
       }
     },
     firewall
-  );
+  ));
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(
-    getNode(getNodes(target, STORE_NODE), symbol, void 0, target[STORE_FIREWALL]?.(), 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;
@@ -1441,24 +1331,35 @@ 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(
@@ -1473,10 +1374,13 @@ var storeTraps = {
     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, target[STORE_FIREWALL]?.()));
+    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) {
@@ -1485,31 +1389,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;
@@ -1517,22 +1422,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;
@@ -1542,8 +1449,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) {
@@ -1552,22 +1458,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];
         });
       }
     }
@@ -1577,28 +1480,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) {
@@ -1610,16 +1511,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;
@@ -1640,27 +1537,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;
@@ -1672,11 +1564,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;
       }
     }
@@ -1685,8 +1575,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) {
@@ -1702,15 +1591,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,
@@ -1733,39 +1620,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;
         },
@@ -1779,7 +1658,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--) {
@@ -1791,29 +1670,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;
@@ -1824,13 +1698,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
@@ -1840,15 +1714,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(),
@@ -1859,35 +1733,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);
@@ -1899,54 +1777,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) {
@@ -1961,10 +1856,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);
     }
   });
@@ -1995,23 +1890,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) {
@@ -2023,17 +1912,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);
@@ -2045,16 +1932,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);
       },
@@ -2066,49 +1951,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) {
@@ -2116,43 +1998,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();
@@ -2161,8 +2046,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);
@@ -2170,27 +2054,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 = [];
@@ -2223,18 +2123,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
+};