@solidjs/signals 0.3.2 → 0.4.0

package/dist/prod.js

@@ -13,12 +13,6 @@ var ContextNotFoundError = class extends Error {
     );
   }
 };
-var EffectError = class extends Error {
-  constructor(effect, cause) {
-    super("");
-    this.cause = cause;
-  }
-};
 
 // src/core/constants.ts
 var STATE_CLEAN = 0;
@@ -44,7 +38,7 @@ function schedule() {
     return;
   scheduled = true;
   if (!globalQueue.J)
-    queueMicrotask(flushSync);
+    queueMicrotask(flush);
 }
 var pureQueue = [];
 var Queue = class {
@@ -53,21 +47,21 @@ var Queue = class {
   K = [[], []];
   E = [];
   created = clock;
-  enqueue(type, node) {
-    pureQueue.push(node);
+  enqueue(type, fn) {
+    pureQueue.push(fn);
     if (type)
-      this.K[type - 1].push(node);
+      this.K[type - 1].push(fn);
     schedule();
   }
   run(type) {
     if (type === EFFECT_PURE) {
-      pureQueue.length && runPureQueue(pureQueue);
+      pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
     } else if (this.K[type - 1].length) {
       const effects = this.K[type - 1];
       this.K[type - 1] = [];
-      runEffectQueue(effects);
+      runQueue(effects, type);
     }
     for (let i = 0; i < this.E.length; i++) {
       this.E[i].run(type);
@@ -103,57 +97,14 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
-function flushSync() {
+function flush() {
   while (scheduled) {
     globalQueue.flush();
   }
 }
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current.o) {
-    if (current.a !== STATE_CLEAN) {
-      ancestors.push(current);
-    }
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].x();
-  }
-}
-function runPureQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    if (queue[i].a !== STATE_CLEAN)
-      runTop(queue[i]);
-  }
-}
-function runEffectQueue(queue) {
+function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
-    queue[i].V();
-}
-
-// src/core/utils.ts
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-function tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(
-        (v2) => [void 0, v2],
-        (e) => {
-          if (e instanceof NotReadyError)
-            throw e;
-          return [e];
-        }
-      );
-    }
-    return [void 0, v];
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return [e];
-  }
+    queue[i](type);
 }
 
 // src/core/owner.ts
@@ -167,17 +118,13 @@ function setOwner(owner) {
   currentOwner = owner;
   return out;
 }
-function formatId(prefix, id) {
-  const num = id.toString(36), len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
-}
 var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
   o = null;
   m = null;
-  s = null;
+  t = null;
   a = STATE_CLEAN;
   l = null;
   p = defaultContext;
@@ -187,18 +134,18 @@ var Owner = class {
   constructor(id = null, skipAppend = false) {
     this.id = id;
     if (currentOwner) {
-      if (id == null && currentOwner.id != null)
-        this.id = currentOwner.getNextChildId();
       !skipAppend && currentOwner.append(this);
     }
   }
   append(child) {
     child.o = this;
-    child.s = this;
+    child.t = this;
     if (this.m)
-      this.m.s = child;
+      this.m.t = child;
     child.m = this.m;
     this.m = child;
+    if (this.id != null && child.id == null)
+      child.id = this.getNextChildId();
     if (child.p !== this.p) {
       child.p = { ...this.p, ...child.p };
     }
@@ -208,7 +155,7 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.s || this.o : this, current = this.m, next = null;
+    let head = self ? this.t || this.o : this, current = this.m, next = null;
     while (current && current.o === this) {
       current.dispose(true);
       current.y();
@@ -220,15 +167,15 @@ var Owner = class {
     if (self)
       this.y();
     if (current)
-      current.s = !self ? this : this.s;
+      current.t = !self ? this : this.t;
     if (head)
       head.m = current;
   }
   y() {
-    if (this.s)
-      this.s.m = null;
+    if (this.t)
+      this.t.m = null;
     this.o = null;
-    this.s = null;
+    this.t = null;
     this.p = defaultContext;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
@@ -290,6 +237,13 @@ function onCleanup(fn) {
   }
   return fn;
 }
+function formatId(prefix, id) {
+  const num = id.toString(36), len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
 
 // src/core/flags.ts
 var ERROR_OFFSET = 0;
@@ -306,6 +260,7 @@ var currentMask = DEFAULT_FLAGS;
 var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
+var unobserved = [];
 var notStale = false;
 var updateCheck = null;
 var staleCheck = null;
@@ -315,30 +270,33 @@ function getObserver() {
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
   c = null;
-  e = null;
+  d = null;
   g;
   F;
   z;
   // Used in __DEV__ mode, hopefully removed in production
-  ba;
+  ca;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  S = isEqual;
+  R = isEqual;
   X;
+  _ = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
   f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  T = DEFAULT_FLAGS;
+  S = DEFAULT_FLAGS;
   A = -1;
   w = false;
   constructor(initialValue, compute2, options) {
-    super(null, compute2 === null);
+    super(options?.id, compute2 === null);
     this.z = compute2;
     this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this.f = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.g = initialValue;
     if (options?.equals !== void 0)
-      this.S = options.equals;
+      this.R = options.equals;
+    if (options?.pureWrite)
+      this._ = true;
     if (options?.unobserved)
       this.X = options?.unobserved;
   }
@@ -389,7 +347,8 @@ var Computation = class extends Owner {
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this.g) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || this.f & LOADING_BIT & ~flags || this.S === false || !this.S(this.g, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    this.R === false || !this.R(this.g, newValue));
     if (valueChanged) {
       this.g = newValue;
       this.F = void 0;
@@ -397,12 +356,12 @@ var Computation = class extends Owner {
     const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
     this.f = flags;
     this.A = getClock() + 1;
-    if (this.e) {
-      for (let i = 0; i < this.e.length; i++) {
+    if (this.d) {
+      for (let i = 0; i < this.d.length; i++) {
         if (valueChanged) {
-          this.e[i].r(STATE_DIRTY);
+          this.d[i].r(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.e[i].Z(changedFlagsMask, changedFlags);
+          this.d[i].Z(changedFlagsMask, changedFlags);
         }
       }
     }
@@ -416,9 +375,9 @@ var Computation = class extends Owner {
       return;
     this.w = !!skipQueue;
     this.a = state;
-    if (this.e) {
-      for (let i = 0; i < this.e.length; i++) {
-        this.e[i].r(STATE_CHECK, skipQueue);
+    if (this.d) {
+      for (let i = 0; i < this.d.length; i++) {
+        this.d[i].r(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -431,7 +390,7 @@ var Computation = class extends Owner {
   Z(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.T) {
+    if (mask & this.S) {
       this.r(STATE_DIRTY);
       return;
     }
@@ -443,9 +402,9 @@ var Computation = class extends Owner {
       this.r(STATE_CHECK);
     } else {
       this.f ^= deltaFlags;
-      if (this.e) {
-        for (let i = 0; i < this.e.length; i++) {
-          this.e[i].Z(mask, newFlags2);
+      if (this.d) {
+        for (let i = 0; i < this.d.length; i++) {
+          this.d[i].Z(mask, newFlags2);
         }
       }
     }
@@ -544,15 +503,16 @@ function update(node) {
       let source;
       for (let i = newSourcesIndex; i < node.c.length; i++) {
         source = node.c[i];
-        if (!source.e)
-          source.e = [node];
+        if (!source.d)
+          source.d = [node];
         else
-          source.e.push(node);
+          source.d.push(node);
       }
     } else if (node.c && newSourcesIndex < node.c.length) {
       removeSourceObservers(node, newSourcesIndex);
       node.c.length = newSourcesIndex;
     }
+    unobserved.length && notifyUnobserved();
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
@@ -565,15 +525,23 @@ function removeSourceObservers(node, index) {
   let swap;
   for (let i = index; i < node.c.length; i++) {
     source = node.c[i];
-    if (source.e) {
-      swap = source.e.indexOf(node);
-      source.e[swap] = source.e[source.e.length - 1];
-      source.e.pop();
-      if (!source.e.length)
-        source.X?.();
+    if (source.d) {
+      swap = source.d.indexOf(node);
+      source.d[swap] = source.d[source.d.length - 1];
+      source.d.pop();
+      if (!source.d.length)
+        unobserved.push(source);
     }
   }
 }
+function notifyUnobserved() {
+  for (let i = 0; i < unobserved.length; i++) {
+    const source = unobserved[i];
+    if (!source.d || !source.d.length)
+      unobserved[i].X?.();
+  }
+  unobserved = [];
+}
 function isEqual(a, b) {
   return a === b;
 }
@@ -612,7 +580,7 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.T |= LOADING_BIT;
+  c.S |= LOADING_BIT;
   return c.read();
 }
 function latest(fn, fallback) {
@@ -660,10 +628,10 @@ function runWithObserver(observer, run) {
       let source;
       for (let i = newSourcesIndex; i < observer.c.length; i++) {
         source = observer.c[i];
-        if (!source.e)
-          source.e = [observer];
+        if (!source.d)
+          source.d = [observer];
         else
-          source.e.push(observer);
+          source.d.push(observer);
       }
     }
     newSources = prevSources;
@@ -674,7 +642,7 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.T ?? DEFAULT_FLAGS;
+  currentMask = observer?.S ?? DEFAULT_FLAGS;
   notStale = true;
   try {
     return fn(observer ? observer.g : void 0);
@@ -685,94 +653,32 @@ function compute(owner, fn, observer) {
     notStale = prevNotStale;
   }
 }
-function flatten(children, options) {
-  try {
-    if (typeof children === "function" && !children.length) {
-      if (options?.doNotUnwrap)
-        return children;
-      do {
-        children = children();
-      } while (typeof children === "function" && !children.length);
-    }
-    if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
-      return;
-    if (Array.isArray(children)) {
-      let results = [];
-      if (flattenArray(children, results, options)) {
-        return () => {
-          let nested = [];
-          flattenArray(results, nested, { ...options, doNotUnwrap: false });
-          return nested;
-        };
-      }
-      return results;
-    }
-    return children;
-  } catch (e) {
-    if (options?.skipNonRendered && e instanceof NotReadyError) {
-      newFlags |= LOADING_BIT;
-      return void 0;
-    }
-    throw e;
-  }
-}
-function flattenArray(children, results = [], options) {
-  let notReady = null;
-  let needsUnwrap = false;
-  for (let i = 0; i < children.length; i++) {
-    try {
-      let child = children[i];
-      if (typeof child === "function" && !child.length) {
-        if (options?.doNotUnwrap) {
-          results.push(child);
-          needsUnwrap = true;
-          continue;
-        }
-        do {
-          child = child();
-        } while (typeof child === "function" && !child.length);
-      }
-      if (Array.isArray(child)) {
-        needsUnwrap = flattenArray(child, results, options);
-      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
-    } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
-      notReady = e;
-    }
-  }
-  if (notReady)
-    throw notReady;
-  return needsUnwrap;
-}
 
 // src/core/effect.ts
 var Effect = class extends Computation {
+  T;
   M;
-  N;
   B;
   U = false;
-  O;
-  t;
+  N;
+  s;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.M = effect;
-    this.N = error;
-    this.O = initialValue;
-    this.t = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.t === EFFECT_RENDER) {
+    this.T = effect;
+    this.M = error;
+    this.N = initialValue;
+    this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.s === EFFECT_RENDER) {
       this.z = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this.x();
-    !options?.defer && (this.t === EFFECT_USER ? this.h.enqueue(this.t, this) : this.V());
+    !options?.defer && (this.s === EFFECT_USER ? this.h.enqueue(this.s, this.V.bind(this)) : this.V(this.s));
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
       this.f;
       this.f = flags;
-      if (this.t === EFFECT_RENDER) {
+      if (this.s === EFFECT_RENDER) {
         this.h.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
@@ -786,17 +692,19 @@ var Effect = class extends Computation {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.t, this);
+      this.h.enqueue(this.s, this.V.bind(this));
     this.a = state;
   }
   L(error) {
     this.F = error;
-    this.B?.();
     this.h.notify(this, LOADING_BIT, 0);
     this.f = ERROR_BIT;
-    if (this.t === EFFECT_USER) {
+    if (this.s === EFFECT_USER) {
       try {
-        return this.N ? this.B = this.N(error) : console.error(new EffectError(this.M, error));
+        return this.M ? this.M(error, () => {
+          this.B?.();
+          this.B = void 0;
+        }) : console.error(error);
       } catch (e) {
         error = e;
       }
@@ -807,28 +715,34 @@ var Effect = class extends Computation {
   y() {
     if (this.a === STATE_DISPOSED)
       return;
-    this.M = void 0;
-    this.O = void 0;
+    this.T = void 0;
     this.N = void 0;
+    this.M = void 0;
     this.B?.();
     this.B = void 0;
     super.y();
   }
-  V() {
-    if (this.U && this.a !== STATE_DISPOSED) {
-      this.B?.();
-      try {
-        this.B = this.M(this.g, this.O);
-      } catch (e) {
-        if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
-          throw e;
-      } finally {
-        this.O = this.g;
-        this.U = false;
+  V(type) {
+    if (type) {
+      if (this.U && this.a !== STATE_DISPOSED) {
+        this.B?.();
+        try {
+          this.B = this.T(this.g, this.N);
+        } catch (e) {
+          if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
+            throw e;
+        } finally {
+          this.N = this.g;
+          this.U = false;
+        }
       }
-    }
+    } else
+      this.a !== STATE_CLEAN && runTop(this);
   }
 };
+function runComputation() {
+  this.a !== STATE_CLEAN && runTop(this);
+}
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
@@ -838,11 +752,12 @@ var EagerComputation = class extends Computation {
     if (this.a >= state && !this.w)
       return;
     if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
-      this.h.enqueue(EFFECT_PURE, this);
+      this.h.enqueue(EFFECT_PURE, runComputation.bind(this));
     super.r(state, skipQueue);
   }
 };
-var ProjectionComputation = class extends Computation {
+var FirewallComputation = class extends Computation {
+  firewall = true;
   constructor(compute2) {
     super(void 0, compute2);
   }
@@ -850,141 +765,22 @@ var ProjectionComputation = class extends Computation {
     if (this.a >= state && !this.w)
       return;
     if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
-      this.h.enqueue(EFFECT_PURE, this);
+      this.h.enqueue(EFFECT_PURE, runComputation.bind(this));
     super.r(state, true);
     this.w = !!skipQueue;
   }
 };
-
-// src/core/boundaries.ts
-var BoundaryComputation = class extends EagerComputation {
-  G;
-  constructor(compute2, propagationMask) {
-    super(void 0, compute2, { defer: true });
-    this.G = propagationMask;
-  }
-  write(value, flags) {
-    super.write(value, flags & ~this.G);
-    if (this.G & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
-      flags &= ~LOADING_BIT;
-    }
-    this.h.notify(this, this.G, flags);
-    return this.g;
-  }
-};
-function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.h;
-  parentQueue.addChild(owner.h = queue);
-  onCleanup(() => parentQueue.removeChild(owner.h));
-  return compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => flatten(c.wait()), mask);
-    },
-    null
-  );
-}
-var ConditionalQueue = class extends Queue {
-  n;
-  P = /* @__PURE__ */ new Set();
-  Q = /* @__PURE__ */ new Set();
-  constructor(disabled) {
-    super();
-    this.n = disabled;
-  }
-  run(type) {
-    if (!type || this.n.read())
-      return;
-    return super.run(type);
-  }
-  notify(node, type, flags) {
-    if (this.n.read()) {
-      if (type === LOADING_BIT) {
-        flags & LOADING_BIT ? this.Q.add(node) : this.Q.delete(node);
-      }
-      if (type === ERROR_BIT) {
-        flags & ERROR_BIT ? this.P.add(node) : this.P.delete(node);
-      }
-      return true;
+function runTop(node) {
+  const ancestors = [];
+  for (let current = node; current !== null; current = current.o) {
+    if (current.a !== STATE_CLEAN) {
+      ancestors.push(current);
     }
-    return super.notify(node, type, flags);
   }
-};
-var CollectionQueue = class extends Queue {
-  R;
-  b = /* @__PURE__ */ new Set();
-  n = new Computation(false, null);
-  constructor(type) {
-    super();
-    this.R = type;
-  }
-  run(type) {
-    if (!type || this.n.read())
-      return;
-    return super.run(type);
-  }
-  notify(node, type, flags) {
-    if (!(type & this.R))
-      return super.notify(node, type, flags);
-    if (flags & this.R) {
-      this.b.add(node);
-      if (this.b.size === 1)
-        this.n.write(true);
-    } else {
-      this.b.delete(node);
-      if (this.b.size === 0)
-        this.n.write(false);
-    }
-    type &= ~this.R;
-    return type ? super.notify(node, type, flags) : true;
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (ancestors[i].a !== STATE_DISPOSED)
+      ancestors[i].x();
   }
-};
-function createBoundary(fn, condition) {
-  const owner = new Owner();
-  const queue = new ConditionalQueue(new Computation(void 0, () => condition() === "hidden" /* HIDDEN */));
-  const tree = createBoundChildren(owner, fn, queue, 0);
-  new EagerComputation(void 0, () => {
-    const disabled = queue.n.read();
-    tree.G = disabled ? ERROR_BIT | LOADING_BIT : 0;
-    if (!disabled) {
-      queue.Q.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue.P.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.Q.clear();
-      queue.P.clear();
-    }
-  });
-  return () => queue.n.read() ? void 0 : tree.read();
-}
-function createCollectionBoundary(type, fn, fallback) {
-  const owner = new Owner();
-  const queue = new CollectionQueue(type);
-  const tree = createBoundChildren(owner, fn, queue, type);
-  const decision = new Computation(void 0, () => {
-    if (!queue.n.read()) {
-      const resolved = tree.read();
-      if (!queue.n.read())
-        return resolved;
-    }
-    return fallback(queue);
-  });
-  return decision.read.bind(decision);
-}
-function createSuspense(fn, fallback) {
-  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
-}
-function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(
-    ERROR_BIT,
-    fn,
-    (queue) => fallback(queue.b.values().next().value.F, () => {
-      incrementClock();
-      for (let node of queue.b) {
-        node.a = STATE_DIRTY;
-        node.h?.enqueue(node.t, node);
-      }
-    })
-  );
 }
 
 // src/signals.ts
@@ -1000,7 +796,13 @@ function createSignal(first, second, third) {
     });
     return [() => memo()[0](), (value) => memo()[1](value)];
   }
-  const node = new Computation(first, null, second);
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = new Computation(
+    first,
+    null,
+    needsId ? { id: o.getNextChildId(), ...second } : second
+  );
   return [node.read.bind(node), node.write.bind(node)];
 }
 function createMemo(compute2, value, options) {
@@ -1026,10 +828,12 @@ function createMemo(compute2, value, options) {
   };
 }
 function createAsync(compute2, value, options) {
+  let refreshing = false;
   const node = new EagerComputation(
     value,
     (p) => {
-      const source = compute2(p);
+      const source = compute2(p, refreshing);
+      refreshing = false;
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
       if (!isPromise && !iterator) {
@@ -1069,14 +873,20 @@ function createAsync(compute2, value, options) {
     },
     options
   );
-  return node.wait.bind(node);
+  const read = node.wait.bind(node);
+  read.refresh = () => {
+    node.a = STATE_DIRTY;
+    refreshing = true;
+    node.x();
+  };
+  return read;
 }
-function createEffect(compute2, effect, error, value, options) {
+function createEffect(compute2, effect, value, options) {
   void new Effect(
     value,
     compute2,
-    effect,
-    error,
+    effect.effect ? effect.effect : effect,
+    effect.error,
     options
   );
 }
@@ -1109,101 +919,97 @@ function resolve(fn) {
     });
   });
 }
+function tryCatch(fn) {
+  try {
+    const v = fn();
+    if (v instanceof Promise) {
+      return v.then(
+        (v2) => [void 0, v2],
+        (e) => {
+          if (e instanceof NotReadyError)
+            throw e;
+          return [e];
+        }
+      );
+    }
+    return [void 0, v];
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return [e];
+  }
+}
+function transition(fn) {
+}
+function createOptimistic(initial, compute2, options) {
+  return [];
+}
 
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
-  const [store] = createStore(fn, initialValue);
-  return store;
-}
-function wrapProjection(fn, store, setStore) {
-  const node = new ProjectionComputation(() => {
-    setStore(fn);
+  let wrappedStore;
+  const node = new FirewallComputation(() => {
+    storeSetter(wrappedStore, fn);
   });
-  const wrapped = /* @__PURE__ */ new WeakMap();
-  return [wrap(store, node, wrapped), setStore];
-}
-function wrap(source, node, wrapped) {
-  if (wrapped.has(source))
-    return wrapped.get(source);
-  const wrap3 = new Proxy(source, {
-    get(target, property) {
-      node.read();
-      const v = target[property];
-      return isWrappable(v) ? wrap3(v, node, wrapped) : v;
-    },
-    set() {
-      throw new Error("Projections are readonly");
-    },
-    deleteProperty() {
-      throw new Error("Projections are readonly");
+  const wrappedMap = /* @__PURE__ */ new WeakMap();
+  const traps = {
+    ...storeTraps,
+    get(target, property, receiver) {
+      const o = getOwner();
+      (!o || o !== node) && node.wait();
+      return storeTraps.get(target, property, receiver);
     }
-  });
-  wrapped.set(source, wrap3);
-  return wrap3;
+  };
+  function wrapProjection(source) {
+    if (wrappedMap.has(source))
+      return wrappedMap.get(source);
+    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
+      return source;
+    const wrapped = createStoreProxy(source, traps, {
+      [STORE_WRAP]: wrapProjection,
+      [STORE_LOOKUP]: wrappedMap
+    });
+    wrappedMap.set(source, wrapped);
+    return wrapped;
+  }
+  return wrappedStore = wrapProjection(initialValue);
 }
 
 // src/store/store.ts
-var $RAW = Symbol(0);
 var $TRACK = Symbol(0);
 var $DEEP = Symbol(0);
 var $TARGET = Symbol(0);
 var $PROXY = Symbol(0);
+var $DELETED = Symbol(0);
 var PARENTS = /* @__PURE__ */ new WeakMap();
 var STORE_VALUE = "v";
+var STORE_OVERRIDE = "o";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
-function wrap2(value) {
-  let p = value[$PROXY];
-  if (!p) {
-    let target;
-    if (Array.isArray(value)) {
-      target = [];
-      target.v = value;
-    } else
-      target = { v: value };
-    Object.defineProperty(value, $PROXY, {
-      value: p = new Proxy(target, proxyTraps),
-      writable: true
-    });
-  }
+var STORE_WRAP = "w";
+var STORE_LOOKUP = "l";
+function createStoreProxy(value, traps = storeTraps, extend) {
+  let newTarget;
+  if (Array.isArray(value)) {
+    newTarget = [];
+    newTarget.v = value;
+  } else
+    newTarget = { v: value };
+  extend && Object.assign(newTarget, extend);
+  return newTarget[$PROXY] = new Proxy(newTarget, traps);
+}
+var storeLookup = /* @__PURE__ */ new WeakMap();
+function 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));
   return p;
 }
 function isWrappable(obj) {
   return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
-function unwrap(item, deep2 = true, set) {
-  let result, unwrapped, v, prop;
-  if (result = item != null && item[$RAW])
-    return result;
-  if (!deep2)
-    return item;
-  if (!isWrappable(item) || set?.has(item))
-    return item;
-  if (!set)
-    set = /* @__PURE__ */ new Set();
-  set.add(item);
-  if (Array.isArray(item)) {
-    for (let i = 0, l = item.length; i < l; i++) {
-      v = item[i];
-      if ((unwrapped = unwrap(v, deep2, set)) !== v)
-        item[i] = unwrapped;
-    }
-  } else {
-    if (!deep2)
-      return item;
-    const keys = Object.keys(item);
-    for (let i = 0, l = keys.length; i < l; i++) {
-      prop = keys[i];
-      const desc = Object.getOwnPropertyDescriptor(item, prop);
-      if (desc.get)
-        continue;
-      v = item[prop];
-      if ((unwrapped = unwrap(v, deep2, set)) !== v)
-        item[prop] = unwrapped;
-    }
-  }
-  return item;
-}
 function getNodes(target, type) {
   let nodes = target[type];
   if (!nodes)
@@ -1220,31 +1026,38 @@ function getNode(nodes, property, value, equals = isEqual) {
     }
   });
 }
-function proxyDescriptor(target, property) {
-  if (property === $PROXY)
-    return { value: target[$PROXY], writable: true, configurable: true };
-  const desc = Reflect.getOwnPropertyDescriptor(target[STORE_VALUE], property);
-  if (!desc || desc.get || !desc.configurable)
-    return desc;
-  delete desc.value;
-  delete desc.writable;
-  desc.get = () => target[STORE_VALUE][$PROXY][property];
-  return desc;
-}
 function trackSelf(target, symbol = $TRACK) {
   getObserver() && getNode(getNodes(target, STORE_NODE), symbol, void 0, false).read();
 }
-function ownKeys(target) {
-  trackSelf(target);
-  return Reflect.ownKeys(target[STORE_VALUE]);
+function getKeys(source, override, enumerable = true) {
+  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);
+  }
+  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;
+  }
+  return Reflect.getOwnPropertyDescriptor(value, property);
 }
 var Writing = null;
-var proxyTraps = {
+var storeTraps = {
   get(target, property, receiver) {
     if (property === $TARGET)
       return target;
-    if (property === $RAW)
-      return target[STORE_VALUE];
     if (property === $PROXY)
       return receiver;
     if (property === $TRACK || property === $DEEP) {
@@ -1252,92 +1065,156 @@ var proxyTraps = {
       return receiver;
     }
     const nodes = getNodes(target, STORE_NODE);
-    const storeValue = target[STORE_VALUE];
     const tracked = nodes[property];
+    const overridden = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE];
+    const proxySource = !!target[STORE_VALUE][$TARGET];
+    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 (Writing?.has(storeValue)) {
-      const value2 = tracked ? tracked.g : storeValue[property];
-      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
-    }
-    let value = tracked ? nodes[property].read() : storeValue[property];
+    if (Writing?.has(receiver)) {
+      let value2 = tracked && (overridden || !proxySource) ? tracked.g : storeValue[property];
+      value2 === $DELETED && (value2 = void 0);
+      if (!isWrappable(value2))
+        return value2;
+      const wrapped = wrap(value2, target);
+      Writing.add(wrapped);
+      return wrapped;
+    }
+    let value = tracked ? overridden || !proxySource ? nodes[property].read() : (nodes[property].read(), storeValue[property]) : storeValue[property];
+    value === $DELETED && (value = void 0);
     if (!tracked) {
-      if (typeof value === "function" && !storeValue.hasOwnProperty(property)) {
+      if (!overridden && typeof value === "function" && !storeValue.hasOwnProperty(property)) {
         let proto;
-        return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && 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 getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
+        return getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value).read();
       }
     }
-    return isWrappable(value) ? wrap2(value) : value;
+    return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
-    if (property === $RAW || property === $PROXY || property === $TRACK || property === "__proto__")
+    if (property === $PROXY || property === $TRACK || property === "__proto__")
       return true;
-    const has = property in target[STORE_VALUE];
+    const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
     getObserver() && getNode(getNodes(target, STORE_HAS), property, has).read();
     return has;
   },
-  set(target, property, value) {
-    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
+  set(target, property, rawValue) {
+    const store = target[$PROXY];
+    if (Writing?.has(target[$PROXY])) {
+      untrack(() => {
+        const state = target[STORE_VALUE];
+        const base = state[property];
+        const prev = target[STORE_OVERRIDE]?.[property] || base;
+        const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
+        if (prev === value)
+          return true;
+        const len = target[STORE_OVERRIDE]?.length || state.length;
+        if (value !== void 0 && value === base)
+          delete target[STORE_OVERRIDE][property];
+        else
+          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ 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);
+        target[STORE_HAS]?.[property]?.write(true);
+        const nodes = getNodes(target, STORE_NODE);
+        nodes[property]?.write(wrappable ? wrap(value, target) : value);
+        if (Array.isArray(state)) {
+          const index = parseInt(property) + 1;
+          if (index > len)
+            nodes.length?.write(index);
+        }
+        nodes[$TRACK]?.write(void 0);
+      });
+    }
     return true;
   },
   deleteProperty(target, property) {
-    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
+    if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
+      untrack(() => {
+        const prev = 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;
+        } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
+          delete target[STORE_OVERRIDE][property];
+        } else
+          return true;
+        if (isWrappable(prev)) {
+          const parents = PARENTS.get(prev);
+          parents && (parents instanceof Set ? parents.delete(target) : PARENTS.delete(prev));
+        }
+        target[STORE_HAS]?.[property]?.write(false);
+        const nodes = getNodes(target, STORE_NODE);
+        nodes[property]?.write(void 0);
+        nodes[$TRACK]?.write(void 0);
+      });
+    }
     return true;
   },
-  ownKeys,
-  getOwnPropertyDescriptor: proxyDescriptor,
+  ownKeys(target) {
+    trackSelf(target);
+    return getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
+  },
+  getOwnPropertyDescriptor(target, property) {
+    if (property === $PROXY)
+      return { value: target[$PROXY], writable: true, configurable: true };
+    return getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
+  },
   getPrototypeOf(target) {
     return Object.getPrototypeOf(target[STORE_VALUE]);
   }
 };
-function setProperty(state, property, value, deleting = false) {
-  const prev = state[property];
-  if (!deleting && prev === value)
-    return;
-  const len = state.length;
-  if (deleting)
-    delete state[property];
-  else
-    state[property] = value;
-  const wrappable = isWrappable(value);
-  if (isWrappable(prev)) {
-    const parents = PARENTS.get(prev);
-    parents && (parents instanceof Set ? parents.delete(state) : PARENTS.delete(prev));
-  }
-  if (recursivelyNotify(state) && wrappable)
-    recursivelyAddParent(value[$RAW] || value, state);
-  const target = state[$PROXY]?.[$TARGET];
-  if (!target)
-    return;
-  if (deleting)
-    target[STORE_HAS]?.[property]?.write(false);
-  else
-    target[STORE_HAS]?.[property]?.write(true);
-  const nodes = getNodes(target, STORE_NODE);
-  nodes[property]?.write(wrappable ? wrap2(value) : value);
-  Array.isArray(state) && state.length !== len && nodes.length?.write(state.length);
-  nodes[$TRACK]?.write(void 0);
-}
-function recursivelyNotify(state) {
-  let target = state[$PROXY]?.[$TARGET];
+function storeSetter(store, fn) {
+  const prevWriting = Writing;
+  Writing = /* @__PURE__ */ new Set();
+  Writing.add(store);
+  try {
+    fn(store);
+  } finally {
+    Writing.clear();
+    Writing = prevWriting;
+  }
+}
+function createStore(first, second) {
+  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second) : wrap(first);
+  return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
+}
+function recursivelyNotify(state, lookup) {
+  let target = state[$TARGET] || lookup?.get(state)?.[$TARGET];
   let notified = false;
-  target && (getNodes(target, STORE_NODE)[$DEEP]?.write(void 0), notified = true);
-  const parents = PARENTS.get(state);
+  if (target) {
+    const deep2 = getNodes(target, STORE_NODE)[$DEEP];
+    if (deep2) {
+      deep2.write(void 0);
+      notified = true;
+    }
+    lookup = target[STORE_LOOKUP] || lookup;
+  }
+  const parents = PARENTS.get(target?.[STORE_VALUE] || state);
   if (!parents)
     return notified;
   if (parents instanceof Set) {
     for (let parent of parents)
-      notified = recursivelyNotify(parent) || notified;
+      notified = recursivelyNotify(parent, lookup) || notified;
   } else
-    notified = recursivelyNotify(parents) || notified;
+    notified = recursivelyNotify(parents, lookup) || notified;
   return notified;
 }
 function recursivelyAddParent(state, parent) {
+  let override;
+  const target = state[$TARGET];
+  if (target) {
+    override = target[STORE_OVERRIDE];
+    state = target[STORE_VALUE];
+  }
   if (parent) {
     let parents = PARENTS.get(state);
     if (!parents)
@@ -1352,80 +1229,73 @@ function recursivelyAddParent(state, parent) {
       return;
   }
   if (Array.isArray(state)) {
-    for (let i = 0; i < state.length; i++) {
-      const item = state[i];
-      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+    const len = override?.length || state.length;
+    for (let i = 0; i < len; i++) {
+      const item = override && i in override ? override[i] : state[i];
+      isWrappable(item) && recursivelyAddParent(item, state);
     }
   } else {
-    const keys = Object.keys(state);
+    const keys = getKeys(state, override);
     for (let i = 0; i < keys.length; i++) {
-      const item = state[keys[i]];
-      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+      const key = keys[i];
+      const item = override && key in override ? override[key] : state[key];
+      isWrappable(item) && recursivelyAddParent(item, state);
     }
   }
 }
-function createStore(first, second) {
-  const derived = typeof first === "function", store = derived ? second : first;
-  const unwrappedStore = unwrap(store);
-  let wrappedStore = wrap2(unwrappedStore);
-  const setStore = (fn) => {
-    const prevWriting = Writing;
-    Writing = /* @__PURE__ */ new Set();
-    Writing.add(unwrappedStore);
-    try {
-      fn(wrappedStore);
-    } finally {
-      Writing.clear();
-      Writing = prevWriting;
-    }
-  };
-  if (derived)
-    return wrapProjection(first, wrappedStore, setStore);
-  return [wrappedStore, setStore];
-}
 function deep(store) {
-  recursivelyAddParent(store[$RAW] || store);
+  recursivelyAddParent(store);
   return store[$DEEP];
 }
 
 // src/store/reconcile.ts
-function applyState(next, state, keyFn) {
+function unwrap(value) {
+  return value?.[$TARGET]?.[STORE_NODE] ?? value;
+}
+function getOverrideValue(value, override, key) {
+  return 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]));
+}
+function applyState(next, state, keyFn, all) {
   const target = state?.[$TARGET];
   if (!target)
     return;
   const previous = target[STORE_VALUE];
-  if (next === previous)
+  const override = target[STORE_OVERRIDE];
+  if (next === previous && !override)
     return;
-  Object.defineProperty(next, $PROXY, {
-    value: previous[$PROXY],
-    writable: true
-  });
-  previous[$PROXY] = null;
+  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
   target[STORE_VALUE] = next;
+  target[STORE_OVERRIDE] = void 0;
   if (Array.isArray(previous)) {
     let changed = false;
-    if (next.length && previous.length && next[0] && keyFn(next[0]) != null) {
+    const prevLength = getOverrideValue(previous, override, "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(previous.length, next.length); start < end && (previous[start] === next[start] || previous[start] && next[start] && keyFn(previous[start]) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap2(previous[start]), keyFn);
+      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, 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 = previous.length - 1, newEnd = next.length - 1; end >= start && newEnd >= start && (previous[end] === next[newEnd] || previous[end] && next[newEnd] && keyFn(previous[end]) === keyFn(next[newEnd])); end--, newEnd--) {
-        temp[newEnd] = previous[end];
+      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
+        temp[newEnd] = item;
       }
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j]?.write(wrap2(next[j]));
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap2(temp[j]);
+          const wrapped = wrap(temp[j], target);
           target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyState(next[j], wrapped, keyFn, all);
         }
         changed && target[STORE_NODE][$TRACK]?.write(void 0);
-        previous.length !== next.length && target[STORE_NODE].length?.write(next.length);
+        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
         return;
       }
       newIndicesNext = new Array(newEnd + 1);
@@ -1437,31 +1307,32 @@ function applyState(next, state, keyFn) {
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
-        item = previous[i];
+        item = getOverrideValue(previous, override, i);
         keyVal = item ? keyFn(item) : item;
         j = newIndices.get(keyVal);
         if (j !== void 0 && j !== -1) {
-          temp[j] = previous[i];
+          temp[j] = item;
           j = newIndicesNext[j];
           newIndices.set(keyVal, j);
         }
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap2(temp[j]);
+          const wrapped = wrap(temp[j], target);
           target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn);
+          applyState(next[j], wrapped, keyFn, all);
         } else
-          target[STORE_NODE][j]?.write(wrap2(next[j]));
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
       }
       if (start < next.length)
         changed = true;
-    } else if (previous.length && next.length) {
+    } else if (prevLength && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        isWrappable(previous[i]) && applyState(next[i], wrap2(previous[i]), keyFn);
+        const item = getOverrideValue(previous, override, i);
+        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
       }
     }
-    if (previous.length !== next.length) {
+    if (prevLength !== next.length) {
       changed = true;
       target[STORE_NODE].length?.write(next.length);
     }
@@ -1470,17 +1341,20 @@ function applyState(next, state, keyFn) {
   }
   let nodes = target[STORE_NODE];
   if (nodes) {
-    const keys = Object.keys(nodes);
+    const tracked = nodes[$TRACK];
+    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
-      const node = nodes[keys[i]];
-      const previousValue = unwrap(previous[keys[i]], false);
-      let nextValue = unwrap(next[keys[i]], false);
+      const key = keys[i];
+      const node = nodes[key];
+      const previousValue = unwrap(getOverrideValue(previous, override, key));
+      let nextValue = unwrap(next[key]);
       if (previousValue === nextValue)
         continue;
-      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
-        node.write(isWrappable(nextValue) ? wrap2(nextValue) : nextValue);
-      else
-        applyState(nextValue, wrap2(previousValue), keyFn);
+      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
+        tracked?.write(void 0);
+        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+      } else
+        applyState(nextValue, wrap(previousValue, target), keyFn, all);
     }
   }
   if (nodes = target[STORE_HAS]) {
@@ -1490,17 +1364,69 @@ function applyState(next, state, keyFn) {
     }
   }
 }
-function reconcile(value, key) {
+function reconcile(value, key, all = false) {
   return (state) => {
     const keyFn = typeof key === "string" ? (item) => item[key] : key;
-    if (keyFn(value) !== keyFn(state))
+    const eq = keyFn(state);
+    if (eq !== void 0 && keyFn(value) !== keyFn(state))
       throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn);
-    return state;
+    applyState(value, state, keyFn, all);
   };
 }
 
 // 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]) {
+    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]
+    );
+    item = target[STORE_VALUE];
+    lookup = storeLookup;
+  } else {
+    isArray = Array.isArray(item);
+    map.set(item, item);
+  }
+  if (isArray) {
+    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 ((unwrapped = snapshot(v, map, lookup)) !== v || result) {
+        if (!result)
+          map.set(item, result = [...item]);
+        result[i] = unwrapped;
+      }
+    }
+  } else {
+    const keys = getKeys(item, override);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      let prop = keys[i];
+      const desc = getPropertyDescriptor(item, override, prop);
+      if (desc.get)
+        continue;
+      v = override && prop in override ? override[prop] : item[prop];
+      if ((unwrapped = snapshot(v, map, lookup)) !== item[prop] || result) {
+        if (!result) {
+          result = Object.create(Object.getPrototypeOf(item));
+          Object.assign(result, item);
+        }
+        result[prop] = unwrapped;
+      }
+    }
+  }
+  return result || item;
+}
 function trueFn() {
   return true;
 }
@@ -1652,33 +1578,34 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    H: new Owner(),
+    G: new Owner(),
     i: 0,
-    _: list,
+    $: list,
     u: [],
     C: map,
-    d: [],
+    e: [],
     b: [],
     D: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
-    I: options?.fallback
+    H: options?.fallback
   });
 }
+var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this._() || [], newLen = newItems.length;
+  const newItems = this.$() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.H, () => {
+  runWithOwner(this.G, () => {
     let i, j, mapper = this.j ? () => {
-      this.j[j] = new Computation(newItems[j], null);
-      this.k && (this.k[j] = new Computation(j, null));
+      this.j[j] = new Computation(newItems[j], null, pureOptions);
+      this.k && (this.k[j] = new Computation(j, null, pureOptions));
       return this.C(
         Computation.prototype.read.bind(this.j[j]),
         this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
       );
     } : this.k ? () => {
       const item = newItems[j];
-      this.k[j] = new Computation(j, null);
+      this.k[j] = new Computation(j, null, pureOptions);
       return this.C(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
@@ -1686,28 +1613,28 @@ function updateKeyedMap() {
     };
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.H.dispose(false);
+        this.G.dispose(false);
         this.b = [];
         this.u = [];
-        this.d = [];
+        this.e = [];
         this.i = 0;
         this.j && (this.j = []);
         this.k && (this.k = []);
       }
-      if (this.I && !this.d[0]) {
-        this.d[0] = compute(
+      if (this.H && !this.e[0]) {
+        this.e[0] = compute(
           this.b[0] = new Owner(),
-          this.I,
+          this.H,
           null
         );
       }
     } else if (this.i === 0) {
       if (this.b[0])
         this.b[0].dispose();
-      this.d = new Array(newLen);
+      this.e = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this.u[j] = newItems[j];
-        this.d[j] = compute(this.b[j] = new Owner(), mapper, null);
+        this.e[j] = compute(this.b[j] = new Owner(), mapper, null);
       }
       this.i = newLen;
     } else {
@@ -1717,7 +1644,7 @@ function updateKeyedMap() {
           this.j[start].write(newItems[start]);
       }
       for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.u[end] === newItems[newEnd] || this.j && compare(this.D, this.u[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.d[end];
+        temp[newEnd] = this.e[end];
         tempNodes[newEnd] = this.b[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
         tempIndexes && (tempIndexes[newEnd] = this.k[end]);
@@ -1736,7 +1663,7 @@ function updateKeyedMap() {
         key = this.D ? this.D(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.d[i];
+          temp[j] = this.e[i];
           tempNodes[j] = this.b[i];
           tempRows && (tempRows[j] = this.j[i]);
           tempIndexes && (tempIndexes[j] = this.k[i]);
@@ -1747,7 +1674,7 @@ function updateKeyedMap() {
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.d[j] = temp[j];
+          this.e[j] = temp[j];
           this.b[j] = tempNodes[j];
           if (tempRows) {
             this.j[j] = tempRows[j];
@@ -1758,43 +1685,43 @@ function updateKeyedMap() {
             this.k[j].write(j);
           }
         } else {
-          this.d[j] = compute(this.b[j] = new Owner(), mapper, null);
+          this.e[j] = compute(this.b[j] = new Owner(), mapper, null);
         }
       }
-      this.d = this.d.slice(0, this.i = newLen);
+      this.e = this.e.slice(0, this.i = newLen);
       this.u = newItems.slice(0);
     }
   });
-  return this.d;
+  return this.e;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    H: new Owner(),
+    G: new Owner(),
     i: 0,
     q: 0,
-    $: count,
+    aa: count,
     C: map,
     b: [],
-    d: [],
-    aa: options?.from,
-    I: options?.fallback
+    e: [],
+    ba: options?.from,
+    H: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.$();
-  const from = this.aa?.() || 0;
-  runWithOwner(this.H, () => {
+  const newLen = this.aa();
+  const from = this.ba?.() || 0;
+  runWithOwner(this.G, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.H.dispose(false);
+        this.G.dispose(false);
         this.b = [];
-        this.d = [];
+        this.e = [];
         this.i = 0;
       }
-      if (this.I && !this.d[0]) {
-        this.d[0] = compute(
+      if (this.H && !this.e[0]) {
+        this.e[0] = compute(
           this.b[0] = new Owner(),
-          this.I,
+          this.H,
           null
         );
       }
@@ -1811,18 +1738,18 @@ function updateRepeat() {
       while (i < from && i < this.i)
         this.b[i++].dispose();
       this.b.splice(0, from - this.q);
-      this.d.splice(0, from - this.q);
+      this.e.splice(0, from - this.q);
     } else if (this.q > from) {
       let i = prevTo - this.q - 1;
       let difference = this.q - from;
-      this.b.length = this.d.length = newLen;
+      this.b.length = this.e.length = newLen;
       while (i >= difference) {
         this.b[i] = this.b[i - difference];
-        this.d[i] = this.d[i - difference];
+        this.e[i] = this.e[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.d[i2] = compute(
+        this.e[i2] = compute(
           this.b[i2] = new Owner(),
           () => this.C(i2 + from),
           null
@@ -1830,20 +1757,214 @@ function updateRepeat() {
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.d[i - from] = compute(
+      this.e[i - from] = compute(
         this.b[i - from] = new Owner(),
         () => this.C(i),
         null
       );
     }
-    this.d = this.d.slice(0, newLen);
+    this.e = this.e.slice(0, newLen);
     this.q = from;
     this.i = newLen;
   });
-  return this.d;
+  return this.e;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, tryCatch, untrack, unwrap };
+// src/boundaries.ts
+var BoundaryComputation = class extends EagerComputation {
+  I;
+  constructor(compute2, propagationMask) {
+    super(void 0, compute2, { defer: true });
+    this.I = propagationMask;
+  }
+  write(value, flags) {
+    super.write(value, flags & ~this.I);
+    if (this.I & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
+      flags &= ~LOADING_BIT;
+    }
+    this.h.notify(this, this.I, flags);
+    return this.g;
+  }
+};
+function createBoundChildren(owner, fn, queue, mask) {
+  const parentQueue = owner.h;
+  parentQueue.addChild(owner.h = queue);
+  onCleanup(() => parentQueue.removeChild(owner.h));
+  return compute(
+    owner,
+    () => {
+      const c = new Computation(void 0, fn);
+      return new BoundaryComputation(() => flatten(c.wait()), mask);
+    },
+    null
+  );
+}
+var ConditionalQueue = class extends Queue {
+  n;
+  O = /* @__PURE__ */ new Set();
+  P = /* @__PURE__ */ new Set();
+  constructor(disabled) {
+    super();
+    this.n = disabled;
+  }
+  run(type) {
+    if (!type || this.n.read())
+      return;
+    return super.run(type);
+  }
+  notify(node, type, flags) {
+    if (this.n.read()) {
+      if (type & LOADING_BIT) {
+        if (flags & LOADING_BIT) {
+          this.P.add(node);
+          type &= ~LOADING_BIT;
+        } else if (this.P.delete(node))
+          type &= ~LOADING_BIT;
+      }
+      if (type & ERROR_BIT) {
+        if (flags & ERROR_BIT) {
+          this.O.add(node);
+          type &= ~ERROR_BIT;
+        } else if (this.O.delete(node))
+          type &= ~ERROR_BIT;
+      }
+    }
+    return type ? super.notify(node, type, flags) : true;
+  }
+};
+var CollectionQueue = class extends Queue {
+  Q;
+  b = /* @__PURE__ */ new Set();
+  n = new Computation(false, null, { pureWrite: true });
+  constructor(type) {
+    super();
+    this.Q = type;
+  }
+  run(type) {
+    if (!type || this.n.read())
+      return;
+    return super.run(type);
+  }
+  notify(node, type, flags) {
+    if (!(type & this.Q))
+      return super.notify(node, type, flags);
+    if (flags & this.Q) {
+      this.b.add(node);
+      if (this.b.size === 1)
+        this.n.write(true);
+    } else {
+      this.b.delete(node);
+      if (this.b.size === 0)
+        this.n.write(false);
+    }
+    type &= ~this.Q;
+    return type ? super.notify(node, type, flags) : true;
+  }
+};
+function createBoundary(fn, condition) {
+  const owner = new Owner();
+  const queue = new ConditionalQueue(
+    new Computation(void 0, () => condition() === "hidden" /* HIDDEN */)
+  );
+  const tree = createBoundChildren(owner, fn, queue, 0);
+  new EagerComputation(void 0, () => {
+    const disabled = queue.n.read();
+    tree.I = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    if (!disabled) {
+      queue.P.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.O.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue.P.clear();
+      queue.O.clear();
+    }
+  });
+  return () => queue.n.read() ? void 0 : tree.read();
+}
+function createCollectionBoundary(type, fn, fallback) {
+  const owner = new Owner();
+  const queue = new CollectionQueue(type);
+  const tree = createBoundChildren(owner, fn, queue, type);
+  const decision = new Computation(void 0, () => {
+    if (!queue.n.read()) {
+      const resolved = tree.read();
+      if (!queue.n.read())
+        return resolved;
+    }
+    return fallback(queue);
+  });
+  return decision.read.bind(decision);
+}
+function createSuspense(fn, fallback) {
+  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
+}
+function createErrorBoundary(fn, fallback) {
+  return createCollectionBoundary(
+    ERROR_BIT,
+    fn,
+    (queue) => fallback(queue.b.values().next().value.F, () => {
+      incrementClock();
+      for (let node of queue.b) {
+        node.a = STATE_DIRTY;
+        node.h?.enqueue(node.s, node);
+      }
+    })
+  );
+}
+function flatten(children, options) {
+  if (typeof children === "function" && !children.length) {
+    if (options?.doNotUnwrap)
+      return children;
+    do {
+      children = children();
+    } while (typeof children === "function" && !children.length);
+  }
+  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
+    return;
+  if (Array.isArray(children)) {
+    let results = [];
+    if (flattenArray(children, results, options)) {
+      return () => {
+        let nested = [];
+        flattenArray(results, nested, { ...options, doNotUnwrap: false });
+        return nested;
+      };
+    }
+    return results;
+  }
+  return children;
+}
+function flattenArray(children, results = [], options) {
+  let notReady = null;
+  let needsUnwrap = false;
+  for (let i = 0; i < children.length; i++) {
+    try {
+      let child = children[i];
+      if (typeof child === "function" && !child.length) {
+        if (options?.doNotUnwrap) {
+          results.push(child);
+          needsUnwrap = true;
+          continue;
+        }
+        do {
+          child = child();
+        } while (typeof child === "function" && !child.length);
+      }
+      if (Array.isArray(child)) {
+        needsUnwrap = flattenArray(child, results, options);
+      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
+      } else
+        results.push(child);
+    } catch (e) {
+      if (!(e instanceof NotReadyError))
+        throw e;
+      notReady = e;
+    }
+  }
+  if (notReady)
+    throw notReady;
+  return needsUnwrap;
+}
+
+export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, tryCatch, untrack };