@solidjs/signals 0.3.2 → 0.4.1

package/dist/dev.js

@@ -13,15 +13,6 @@ var ContextNotFoundError = class extends Error {
     );
   }
 };
-var EffectError = class extends Error {
-  constructor(effect, cause) {
-    super(`Uncaught error while running effect:
-
-  ${effect.toString()}
-` );
-    this.cause = cause;
-  }
-};
 
 // src/core/constants.ts
 var STATE_CLEAN = 0;
@@ -47,7 +38,7 @@ function schedule() {
     return;
   scheduled = true;
   if (!globalQueue._running)
-    queueMicrotask(flushSync);
+    queueMicrotask(flush);
 }
 var pureQueue = [];
 var Queue = class {
@@ -56,21 +47,21 @@ var Queue = class {
   _queues = [[], []];
   _children = [];
   created = clock;
-  enqueue(type, node) {
-    pureQueue.push(node);
+  enqueue(type, fn) {
+    pureQueue.push(fn);
     if (type)
-      this._queues[type - 1].push(node);
+      this._queues[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._queues[type - 1].length) {
       const effects = this._queues[type - 1];
       this._queues[type - 1] = [];
-      runEffectQueue(effects);
+      runQueue(effects, type);
     }
     for (let i = 0; i < this._children.length; i++) {
       this._children[i].run(type);
@@ -106,7 +97,7 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
-function flushSync() {
+function flush() {
   let count = 0;
   while (scheduled) {
     if (++count === 1e5)
@@ -114,52 +105,9 @@ function flushSync() {
     globalQueue.flush();
   }
 }
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current._parent) {
-    if (current._state !== STATE_CLEAN) {
-      ancestors.push(current);
-    }
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i]._state !== STATE_DISPOSED)
-      ancestors[i]._updateIfNecessary();
-  }
-}
-function runPureQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    if (queue[i]._state !== STATE_CLEAN)
-      runTop(queue[i]);
-  }
-}
-function runEffectQueue(queue) {
+function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
-    queue[i]._runEffect();
-}
-
-// 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
@@ -173,10 +121,6 @@ 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
@@ -193,8 +137,6 @@ 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);
     }
   }
@@ -205,6 +147,8 @@ var Owner = class {
       this._nextSibling._prevSibling = child;
     child._nextSibling = this._nextSibling;
     this._nextSibling = child;
+    if (this.id != null && child.id == null)
+      child.id = this.getNextChildId();
     if (child._context !== this._context) {
       child._context = { ...this._context, ...child._context };
     }
@@ -296,6 +240,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;
@@ -312,6 +263,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;
@@ -331,6 +283,7 @@ var Computation = class extends Owner {
   // which could enable more efficient DIRTY notification
   _equals = isEqual;
   _unobserved;
+  _pureWrite = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
   _stateFlags = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
@@ -338,7 +291,7 @@ var Computation = class extends Owner {
   _time = -1;
   _forceNotify = false;
   constructor(initialValue, compute2, options) {
-    super(null, compute2 === null);
+    super(options?.id, compute2 === null);
     this._compute = compute2;
     this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this._stateFlags = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
@@ -346,6 +299,8 @@ var Computation = class extends Owner {
     this._name = options?.name ?? (this._compute ? "computed" : "signal");
     if (options?.equals !== void 0)
       this._equals = options.equals;
+    if (options?.pureWrite)
+      this._pureWrite = true;
     if (options?.unobserved)
       this._unobserved = options?.unobserved;
   }
@@ -395,8 +350,11 @@ var Computation = class extends Owner {
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
+    if (!this._compute && !this._pureWrite && getOwner() && !getOwner().firewall)
+      console.warn("A Signal was written to in an owned scope.");
     const newValue = !raw && typeof value === "function" ? value(this._value) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || this._stateFlags & LOADING_BIT & ~flags || this._equals === false || !this._equals(this._value, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    this._equals === false || !this._equals(this._value, newValue));
     if (valueChanged) {
       this._value = newValue;
       this._error = void 0;
@@ -560,6 +518,7 @@ function update(node) {
       removeSourceObservers(node, newSourcesIndex);
       node._sources.length = newSourcesIndex;
     }
+    unobserved.length && notifyUnobserved();
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
@@ -577,10 +536,18 @@ function removeSourceObservers(node, index) {
       source._observers[swap] = source._observers[source._observers.length - 1];
       source._observers.pop();
       if (!source._observers.length)
-        source._unobserved?.();
+        unobserved.push(source);
     }
   }
 }
+function notifyUnobserved() {
+  for (let i = 0; i < unobserved.length; i++) {
+    const source = unobserved[i];
+    if (!source._observers || !source._observers.length)
+      unobserved[i]._unobserved?.();
+  }
+  unobserved = [];
+}
 function isEqual(a, b) {
   return a === b;
 }
@@ -692,68 +659,6 @@ 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 {
@@ -773,7 +678,7 @@ var Effect = class extends Computation {
       this._compute = (p) => getClock() > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this._updateIfNecessary();
-    !options?.defer && (this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect());
+    !options?.defer && (this._type === EFFECT_USER ? this._queue.enqueue(this._type, this._run.bind(this)) : this._run(this._type));
     if (!this._parent)
       console.warn("Effects created outside a reactive context will never be disposed");
   }
@@ -795,17 +700,19 @@ var Effect = class extends Computation {
     if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
-      this._queue.enqueue(this._type, this);
+      this._queue.enqueue(this._type, this._run.bind(this));
     this._state = state;
   }
   _setError(error) {
     this._error = error;
-    this._cleanup?.();
     this._queue.notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
-        return this._onerror ? this._cleanup = this._onerror(error) : console.error(new EffectError(this._effect, error));
+        return this._onerror ? this._onerror(error, () => {
+          this._cleanup?.();
+          this._cleanup = void 0;
+        }) : console.error(error);
       } catch (e) {
         error = e;
       }
@@ -823,19 +730,22 @@ var Effect = class extends Computation {
     this._cleanup = void 0;
     super._disposeNode();
   }
-  _runEffect() {
-    if (this._modified && this._state !== STATE_DISPOSED) {
-      this._cleanup?.();
-      try {
-        this._cleanup = this._effect(this._value, this._prevValue);
-      } catch (e) {
-        if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
-          throw e;
-      } finally {
-        this._prevValue = this._value;
-        this._modified = false;
+  _run(type) {
+    if (type) {
+      if (this._modified && this._state !== STATE_DISPOSED) {
+        this._cleanup?.();
+        try {
+          this._cleanup = this._effect(this._value, this._prevValue);
+        } catch (e) {
+          if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+            throw e;
+        } finally {
+          this._prevValue = this._value;
+          this._modified = false;
+        }
       }
-    }
+    } else
+      this._state !== STATE_CLEAN && runTop(this);
   }
 };
 var EagerComputation = class extends Computation {
@@ -849,11 +759,15 @@ var EagerComputation = class extends Computation {
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this);
+      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, skipQueue);
   }
+  _run() {
+    this._state !== STATE_CLEAN && runTop(this);
+  }
 };
-var ProjectionComputation = class extends Computation {
+var FirewallComputation = class extends Computation {
+  firewall = true;
   constructor(compute2) {
     super(void 0, compute2);
     if (!this._parent)
@@ -863,141 +777,25 @@ var ProjectionComputation = class extends Computation {
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this);
+      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, true);
     this._forceNotify = !!skipQueue;
   }
-};
-
-// src/core/boundaries.ts
-var BoundaryComputation = class extends EagerComputation {
-  _propagationMask;
-  constructor(compute2, propagationMask) {
-    super(void 0, compute2, { defer: true });
-    this._propagationMask = propagationMask;
-  }
-  write(value, flags) {
-    super.write(value, flags & ~this._propagationMask);
-    if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT)) {
-      flags &= ~LOADING_BIT;
-    }
-    this._queue.notify(this, this._propagationMask, flags);
-    return this._value;
+  _run() {
+    this._state !== STATE_CLEAN && runTop(this);
   }
 };
-function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner._queue;
-  parentQueue.addChild(owner._queue = queue);
-  onCleanup(() => parentQueue.removeChild(owner._queue));
-  return compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => flatten(c.wait()), mask);
-    },
-    null
-  );
-}
-var ConditionalQueue = class extends Queue {
-  _disabled;
-  _errorNodes = /* @__PURE__ */ new Set();
-  _pendingNodes = /* @__PURE__ */ new Set();
-  constructor(disabled) {
-    super();
-    this._disabled = disabled;
-  }
-  run(type) {
-    if (!type || this._disabled.read())
-      return;
-    return super.run(type);
-  }
-  notify(node, type, flags) {
-    if (this._disabled.read()) {
-      if (type === LOADING_BIT) {
-        flags & LOADING_BIT ? this._pendingNodes.add(node) : this._pendingNodes.delete(node);
-      }
-      if (type === ERROR_BIT) {
-        flags & ERROR_BIT ? this._errorNodes.add(node) : this._errorNodes.delete(node);
-      }
-      return true;
+function runTop(node) {
+  const ancestors = [];
+  for (let current = node; current !== null; current = current._parent) {
+    if (current._state !== STATE_CLEAN) {
+      ancestors.push(current);
     }
-    return super.notify(node, type, flags);
-  }
-};
-var CollectionQueue = class extends Queue {
-  _collectionType;
-  _nodes = /* @__PURE__ */ new Set();
-  _disabled = new Computation(false, null);
-  constructor(type) {
-    super();
-    this._collectionType = type;
-  }
-  run(type) {
-    if (!type || this._disabled.read())
-      return;
-    return super.run(type);
   }
-  notify(node, type, flags) {
-    if (!(type & this._collectionType))
-      return super.notify(node, type, flags);
-    if (flags & this._collectionType) {
-      this._nodes.add(node);
-      if (this._nodes.size === 1)
-        this._disabled.write(true);
-    } else {
-      this._nodes.delete(node);
-      if (this._nodes.size === 0)
-        this._disabled.write(false);
-    }
-    type &= ~this._collectionType;
-    return type ? super.notify(node, type, flags) : true;
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (ancestors[i]._state !== STATE_DISPOSED)
+      ancestors[i]._updateIfNecessary();
   }
-};
-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._disabled.read();
-    tree._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
-    if (!disabled) {
-      queue._pendingNodes.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue._errorNodes.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue._pendingNodes.clear();
-      queue._errorNodes.clear();
-    }
-  });
-  return () => queue._disabled.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._disabled.read()) {
-      const resolved = tree.read();
-      if (!queue._disabled.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._nodes.values().next().value._error, () => {
-      incrementClock();
-      for (let node of queue._nodes) {
-        node._state = STATE_DIRTY;
-        node._queue?.enqueue(node._type, node);
-      }
-    })
-  );
 }
 
 // src/signals.ts
@@ -1013,7 +811,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) {
@@ -1039,10 +843,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) {
@@ -1082,14 +888,20 @@ function createAsync(compute2, value, options) {
     },
     options
   );
-  return node.wait.bind(node);
+  const read = node.wait.bind(node);
+  read.refresh = () => {
+    node._state = STATE_DIRTY;
+    refreshing = true;
+    node._updateIfNecessary();
+  };
+  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, name: options?.name ?? "effect" } 
   );
 }
@@ -1122,101 +934,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("STORE_RAW" );
 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";
-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)
@@ -1233,31 +1041,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) {
@@ -1265,92 +1080,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._value : 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._value : 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)
@@ -1365,80 +1244,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);
@@ -1450,31 +1322,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);
     }
@@ -1483,17 +1356,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]) {
@@ -1503,17 +1379,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;
 }
@@ -1678,20 +1606,21 @@ function mapArray(list, map, options) {
     _fallback: options?.fallback
   });
 }
+var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
   const newItems = this._list() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this._owner, () => {
     let i, j, mapper = this._rows ? () => {
-      this._rows[j] = new Computation(newItems[j], null);
-      this._indexes && (this._indexes[j] = new Computation(j, null));
+      this._rows[j] = new Computation(newItems[j], null, pureOptions);
+      this._indexes && (this._indexes[j] = new Computation(j, null, pureOptions));
       return this._map(
         Computation.prototype.read.bind(this._rows[j]),
         this._indexes ? Computation.prototype.read.bind(this._indexes[j]) : void 0
       );
     } : this._indexes ? () => {
       const item = newItems[j];
-      this._indexes[j] = new Computation(j, null);
+      this._indexes[j] = new Computation(j, null, pureOptions);
       return this._map(() => item, Computation.prototype.read.bind(this._indexes[j]));
     } : () => {
       const item = newItems[j];
@@ -1859,4 +1788,198 @@ 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 {
+  _propagationMask;
+  constructor(compute2, propagationMask) {
+    super(void 0, compute2, { defer: true });
+    this._propagationMask = propagationMask;
+  }
+  write(value, flags) {
+    super.write(value, flags & ~this._propagationMask);
+    if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT)) {
+      flags &= ~LOADING_BIT;
+    }
+    this._queue.notify(this, this._propagationMask, flags);
+    return this._value;
+  }
+};
+function createBoundChildren(owner, fn, queue, mask) {
+  const parentQueue = owner._queue;
+  parentQueue.addChild(owner._queue = queue);
+  onCleanup(() => parentQueue.removeChild(owner._queue));
+  return compute(
+    owner,
+    () => {
+      const c = new Computation(void 0, fn);
+      return new BoundaryComputation(() => flatten(c.wait()), mask);
+    },
+    null
+  );
+}
+var ConditionalQueue = class extends Queue {
+  _disabled;
+  _errorNodes = /* @__PURE__ */ new Set();
+  _pendingNodes = /* @__PURE__ */ new Set();
+  constructor(disabled) {
+    super();
+    this._disabled = disabled;
+  }
+  run(type) {
+    if (!type || this._disabled.read())
+      return;
+    return super.run(type);
+  }
+  notify(node, type, flags) {
+    if (this._disabled.read()) {
+      if (type & LOADING_BIT) {
+        if (flags & LOADING_BIT) {
+          this._pendingNodes.add(node);
+          type &= ~LOADING_BIT;
+        } else if (this._pendingNodes.delete(node))
+          type &= ~LOADING_BIT;
+      }
+      if (type & ERROR_BIT) {
+        if (flags & ERROR_BIT) {
+          this._errorNodes.add(node);
+          type &= ~ERROR_BIT;
+        } else if (this._errorNodes.delete(node))
+          type &= ~ERROR_BIT;
+      }
+    }
+    return type ? super.notify(node, type, flags) : true;
+  }
+};
+var CollectionQueue = class extends Queue {
+  _collectionType;
+  _nodes = /* @__PURE__ */ new Set();
+  _disabled = new Computation(false, null, { pureWrite: true });
+  constructor(type) {
+    super();
+    this._collectionType = type;
+  }
+  run(type) {
+    if (!type || this._disabled.read())
+      return;
+    return super.run(type);
+  }
+  notify(node, type, flags) {
+    if (!(type & this._collectionType))
+      return super.notify(node, type, flags);
+    if (flags & this._collectionType) {
+      this._nodes.add(node);
+      if (this._nodes.size === 1)
+        this._disabled.write(true);
+    } else {
+      this._nodes.delete(node);
+      if (this._nodes.size === 0)
+        this._disabled.write(false);
+    }
+    type &= ~this._collectionType;
+    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._disabled.read();
+    tree._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    if (!disabled) {
+      queue._pendingNodes.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue._errorNodes.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue._pendingNodes.clear();
+      queue._errorNodes.clear();
+    }
+  });
+  return () => queue._disabled.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._disabled.read()) {
+      const resolved = tree.read();
+      if (!queue._disabled.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._nodes.values().next().value._error, () => {
+      incrementClock();
+      for (let node of queue._nodes) {
+        node._state = STATE_DIRTY;
+        node._queue?.enqueue(node._type, node._run.bind(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 };