@solidjs/signals 0.2.5 → 0.3.1

package/dist/prod.js

@@ -43,11 +43,12 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.J)
+  if (!globalQueue.K)
     queueMicrotask(flushSync);
 }
 var Queue = class {
-  J = false;
+  n = null;
+  K = false;
   s = [[], [], []];
   F = [];
   created = clock;
@@ -72,13 +73,13 @@ var Queue = class {
     for (let i = 0; i < this.F.length; i++) {
       rerun = this.F[i].run(type) || rerun;
     }
-    if (type === EFFECT_PURE && this.s[type].length)
-      return true;
+    if (type === EFFECT_PURE)
+      return rerun || !!this.s[type].length;
   }
   flush() {
-    if (this.J)
+    if (this.K)
       return;
-    this.J = true;
+    this.K = true;
     try {
       while (this.run(EFFECT_PURE)) {
       }
@@ -87,17 +88,23 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.J = false;
+      this.K = false;
     }
   }
   addChild(child) {
     this.F.push(child);
+    child.n = this;
   }
   removeChild(child) {
     const index = this.F.indexOf(child);
     if (index >= 0)
       this.F.splice(index, 1);
   }
+  notify(...args) {
+    if (this.n)
+      return this.n.notify(...args);
+    return false;
+  }
 };
 var globalQueue = new Queue();
 function flushSync() {
@@ -107,14 +114,14 @@ function flushSync() {
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.t) {
+  for (let current = node; current !== null; current = current.n) {
     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].z();
+      ancestors[i].x();
   }
 }
 function runPureQueue(queue) {
@@ -125,13 +132,33 @@ function runPureQueue(queue) {
 }
 function runEffectQueue(queue) {
   for (let i = 0; i < queue.length; i++)
-    queue[i].U();
+    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];
+  }
+}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -144,34 +171,40 @@ 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
-  t = null;
   n = null;
-  u = null;
+  m = null;
+  t = null;
   a = STATE_CLEAN;
   l = null;
-  p = defaultContext;
-  m = null;
+  o = defaultContext;
   h = globalQueue;
-  constructor(signal = false) {
-    if (currentOwner && !signal)
-      currentOwner.append(this);
+  W = 0;
+  id = null;
+  constructor(id = null, skipAppend = false) {
+    this.id = id;
+    if (currentOwner) {
+      if (!id && currentOwner.id)
+        this.id = currentOwner.getNextChildId();
+      !skipAppend && currentOwner.append(this);
+    }
   }
   append(child) {
+    child.n = this;
     child.t = this;
-    child.u = this;
-    if (this.n)
-      this.n.u = child;
-    child.n = this.n;
-    this.n = child;
-    if (child.p !== this.p) {
-      child.p = { ...this.p, ...child.p };
-    }
-    if (this.m) {
-      child.m = !child.m ? this.m : [...child.m, ...this.m];
+    if (this.m)
+      this.m.t = child;
+    child.m = this.m;
+    this.m = child;
+    if (child.o !== this.o) {
+      child.o = { ...this.o, ...child.o };
     }
     if (this.h)
       child.h = this.h;
@@ -179,28 +212,28 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.u || this.t : this, current = this.n, next = null;
-    while (current && current.t === this) {
+    let head = self ? this.t || this.n : this, current = this.m, next = null;
+    while (current && current.n === this) {
       current.dispose(true);
-      current.A();
-      next = current.n;
-      current.n = null;
+      current.y();
+      next = current.m;
+      current.m = null;
       current = next;
     }
+    this.W = 0;
     if (self)
-      this.A();
+      this.y();
     if (current)
-      current.u = !self ? this : this.u;
+      current.t = !self ? this : this.t;
     if (head)
-      head.n = current;
+      head.m = current;
   }
-  A() {
-    if (this.u)
-      this.u.n = null;
+  y() {
+    if (this.t)
+      this.t.m = null;
+    this.n = null;
     this.t = null;
-    this.u = null;
-    this.p = defaultContext;
-    this.m = null;
+    this.o = defaultContext;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -217,20 +250,10 @@ var Owner = class {
     }
     this.l = null;
   }
-  handleError(error) {
-    if (!this.m)
-      throw error;
-    let i = 0, len = this.m.length;
-    for (i = 0; i < len; i++) {
-      try {
-        this.m[i](error, this);
-        break;
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (i === len)
-      throw error;
+  getNextChildId() {
+    if (this.id)
+      return formatId(this.id, this.W++);
+    throw new Error("Cannot get child id from owner without an id");
   }
 };
 function createContext(defaultValue, description) {
@@ -240,7 +263,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.p[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.o[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -250,13 +273,13 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.p = {
-    ...owner.p,
+  owner.o = {
+    ...owner.o,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.p[context.id]);
+  return !isUndefined(owner?.o[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
@@ -295,44 +318,42 @@ function getObserver() {
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  b = null;
+  c = null;
   e = null;
   g;
   G;
-  B;
+  z;
   // Used in __DEV__ mode, hopefully removed in production
-  $;
+  ba;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  O = isEqual;
-  V;
+  S = isEqual;
+  X;
   /** 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. */
-  P = DEFAULT_FLAGS;
-  Q = null;
-  y = -1;
-  K = false;
+  T = DEFAULT_FLAGS;
+  A = -1;
+  B = false;
   constructor(initialValue, compute2, options) {
-    super(compute2 === null);
-    this.B = compute2;
+    super(null, 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.O = options.equals;
+      this.S = options.equals;
     if (options?.unobserved)
-      this.V = options?.unobserved;
+      this.X = options?.unobserved;
   }
-  W() {
-    if (this.B) {
-      if (this.f & ERROR_BIT && this.y <= getClock())
+  Y() {
+    if (this.z) {
+      if (this.f & ERROR_BIT && this.A <= getClock())
         update(this);
       else
-        this.z();
+        this.x();
     }
-    if (!this.B || this.b?.length)
-      track(this);
+    track(this);
     newFlags |= this.f & ~currentMask;
     if (this.f & ERROR_BIT) {
       throw this.G;
@@ -345,7 +366,7 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    return this.W();
+    return this.Y();
   }
   /**
    * Return the current value of this computation
@@ -355,46 +376,37 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this.B && this.f & ERROR_BIT && this.y <= getClock()) {
+    if (this.z && this.f & ERROR_BIT && this.A <= getClock()) {
       update(this);
+    } else {
+      this.x();
     }
-    if ((notStale || this.f & UNINITIALIZED_BIT) && this.loading()) {
+    track(this);
+    if ((notStale || this.f & UNINITIALIZED_BIT) && this.f & LOADING_BIT) {
       throw new NotReadyError();
     }
-    if (staleCheck && this.loading())
+    if (staleCheck && this.f & LOADING_BIT) {
       staleCheck.g = true;
-    return this.W();
-  }
-  /**
-   * Return true if the computation is the value is dependent on an unresolved promise
-   * Triggers re-execution of the computation when the loading state changes
-   *
-   * This is useful especially when effects want to re-execute when a computation's
-   * loading state changes
-   */
-  loading() {
-    if (this.Q === null) {
-      this.Q = loadingState(this);
     }
-    return this.Q.read();
+    return this.Y();
   }
   /** 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.O === false || !this.O(this.g, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || this.f & LOADING_BIT & ~flags || this.S === false || !this.S(this.g, newValue));
     if (valueChanged) {
       this.g = newValue;
       this.G = void 0;
     }
     const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
     this.f = flags;
-    this.y = getClock() + 1;
+    this.A = getClock() + 1;
     if (this.e) {
       for (let i = 0; i < this.e.length; i++) {
         if (valueChanged) {
-          this.e[i].q(STATE_DIRTY);
+          this.e[i].r(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.e[i].X(changedFlagsMask, changedFlags);
+          this.e[i].Z(changedFlagsMask, changedFlags);
         }
       }
     }
@@ -403,14 +415,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  q(state, skipQueue) {
-    if (this.a >= state && !this.K)
+  r(state, skipQueue) {
+    if (this.a >= state && !this.B)
       return;
-    this.K = !!skipQueue;
+    this.B = !!skipQueue;
     this.a = state;
     if (this.e) {
       for (let i = 0; i < this.e.length; i++) {
-        this.e[i].q(STATE_CHECK, skipQueue);
+        this.e[i].r(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -420,11 +432,11 @@ var Computation = class extends Owner {
    * @param mask A bitmask for which flag(s) were changed.
    * @param newFlags The source's new flags, masked to just the changed ones.
    */
-  X(mask, newFlags2) {
+  Z(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.P) {
-      this.q(STATE_DIRTY);
+    if (mask & this.T) {
+      this.r(STATE_DIRTY);
       return;
     }
     if (this.a >= STATE_CHECK)
@@ -432,17 +444,17 @@ var Computation = class extends Owner {
     const prevFlags = this.f & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.q(STATE_CHECK);
+      this.r(STATE_CHECK);
     } else {
       this.f ^= deltaFlags;
       if (this.e) {
         for (let i = 0; i < this.e.length; i++) {
-          this.e[i].X(mask, newFlags2);
+          this.e[i].Z(mask, newFlags2);
         }
       }
     }
   }
-  H(error) {
+  L(error) {
     this.G = error;
     this.write(UNCHANGED, this.f & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
@@ -453,18 +465,21 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  z() {
+  x() {
+    if (!this.z) {
+      return;
+    }
     if (this.a === STATE_DISPOSED) {
-      throw new Error("Tried to read a disposed computation");
+      return;
     }
     if (this.a === STATE_CLEAN) {
       return;
     }
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.b.length; i++) {
-        this.b[i].z();
-        observerFlags |= this.b[i].f;
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].x();
+        observerFlags |= this.c[i].f;
         if (this.a === STATE_DIRTY) {
           break;
         }
@@ -480,33 +495,17 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  A() {
+  y() {
     if (this.a === STATE_DISPOSED)
       return;
-    if (this.b)
+    if (this.c)
       removeSourceObservers(this, 0);
-    super.A();
+    super.y();
   }
 };
-function loadingState(node) {
-  const prevOwner = setOwner(node.t);
-  const options = void 0;
-  const computation = new Computation(
-    void 0,
-    () => {
-      track(node);
-      node.z();
-      return !!(node.f & LOADING_BIT);
-    },
-    options
-  );
-  computation.P = ERROR_BIT | LOADING_BIT;
-  setOwner(prevOwner);
-  return computation;
-}
 function track(computation) {
   if (currentObserver) {
-    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.c && currentObserver.c[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -514,7 +513,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.g = computation.y > currentObserver.y;
+      updateCheck.g = computation.A > currentObserver.A;
     }
   }
 }
@@ -526,56 +525,56 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.B, node);
+    const result = compute(node, node.z, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
       node.write(UNCHANGED, newFlags | LOADING_BIT | node.f & UNINITIALIZED_BIT);
     } else {
-      node.H(error);
+      node.L(error);
     }
   } finally {
     if (newSources) {
-      if (node.b)
+      if (node.c)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.b && newSourcesIndex > 0) {
-        node.b.length = newSourcesIndex + newSources.length;
+      if (node.c && newSourcesIndex > 0) {
+        node.c.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.b[newSourcesIndex + i] = newSources[i];
+          node.c[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.b = newSources;
+        node.c = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.b.length; i++) {
-        source = node.b[i];
+      for (let i = newSourcesIndex; i < node.c.length; i++) {
+        source = node.c[i];
         if (!source.e)
           source.e = [node];
         else
           source.e.push(node);
       }
-    } else if (node.b && newSourcesIndex < node.b.length) {
+    } else if (node.c && newSourcesIndex < node.c.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.b.length = newSourcesIndex;
+      node.c.length = newSourcesIndex;
     }
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.y = getClock() + 1;
+    node.A = getClock() + 1;
     node.a = STATE_CLEAN;
   }
 }
 function removeSourceObservers(node, index) {
   let source;
   let swap;
-  for (let i = index; i < node.b.length; i++) {
-    source = node.b[i];
+  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.V?.();
+        source.X?.();
     }
   }
 }
@@ -597,8 +596,7 @@ function hasUpdated(fn) {
     updateCheck = current;
   }
 }
-function isPending(fn, loadingValue) {
-  const argLength = arguments.length;
+function pendingCheck(fn, loadingValue) {
   const current = staleCheck;
   staleCheck = { g: false };
   try {
@@ -607,13 +605,20 @@ function isPending(fn, loadingValue) {
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
-    if (argLength > 1)
+    if (loadingValue !== void 0)
       return loadingValue;
     throw err;
   } finally {
     staleCheck = current;
   }
 }
+function isPending(fn, loadingValue) {
+  if (!currentObserver)
+    return pendingCheck(fn, loadingValue);
+  const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
+  c.T |= LOADING_BIT;
+  return c.read();
+}
 function latest(fn, fallback) {
   const argLength = arguments.length;
   const prevFlags = newFlags;
@@ -630,19 +635,10 @@ function latest(fn, fallback) {
     notStale = prevNotStale;
   }
 }
-function catchError(fn) {
-  try {
-    fn();
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return e;
-  }
-}
 function runWithObserver(observer, run) {
   const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
   newSources = null;
-  newSourcesIndex = observer.b ? observer.b.length : 0;
+  newSourcesIndex = observer.c ? observer.c.length : 0;
   newFlags = 0;
   try {
     return compute(observer, run, observer);
@@ -653,21 +649,21 @@ function runWithObserver(observer, run) {
         newFlags | LOADING_BIT | observer.f & UNINITIALIZED_BIT
       );
     } else {
-      observer.H(error);
+      observer.L(error);
     }
   } finally {
     if (newSources) {
       if (newSourcesIndex > 0) {
-        observer.b.length = newSourcesIndex + newSources.length;
+        observer.c.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          observer.b[newSourcesIndex + i] = newSources[i];
+          observer.c[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        observer.b = newSources;
+        observer.c = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < observer.b.length; i++) {
-        source = observer.b[i];
+      for (let i = newSourcesIndex; i < observer.c.length; i++) {
+        source = observer.c[i];
         if (!source.e)
           source.e = [observer];
         else
@@ -682,7 +678,7 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.P ?? DEFAULT_FLAGS;
+  currentMask = observer?.T ?? DEFAULT_FLAGS;
   notStale = true;
   try {
     return fn(observer ? observer.g : void 0);
@@ -755,90 +751,84 @@ function flattenArray(children, results = [], options) {
     throw notReady;
   return needsUnwrap;
 }
-function createBoundary(fn, queue) {
-  const owner = new Owner();
-  const parentQueue = owner.h;
-  parentQueue.addChild(owner.h = queue);
-  onCleanup(() => parentQueue.removeChild(owner.h));
-  return compute(owner, fn, null);
-}
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  L;
   M;
-  C;
-  R = false;
   N;
-  w;
+  C;
+  U = false;
+  O;
+  u;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.L = effect;
-    this.M = error;
-    this.N = initialValue;
-    this.w = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.w === EFFECT_RENDER) {
-      this.B = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+    this.M = effect;
+    this.N = error;
+    this.O = initialValue;
+    this.u = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.u === EFFECT_RENDER) {
+      this.z = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
-    this.z();
-    !options?.defer && (this.w === EFFECT_USER ? this.h.enqueue(this.w, this) : this.U());
+    this.x();
+    !options?.defer && (this.u === EFFECT_USER ? this.h.enqueue(this.u, this) : this.V());
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
-      const currentFlags = this.f;
+      this.f;
       this.f = flags;
-      if (this.w === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-        this.h.S?.(this);
+      if (this.u === EFFECT_RENDER) {
+        this.h.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
       return this.g;
     this.g = value;
-    this.R = true;
+    this.U = true;
     return value;
   }
-  q(state, skipQueue) {
+  r(state, skipQueue) {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.w, this);
+      this.h.enqueue(this.u, this);
     this.a = state;
   }
-  H(error) {
+  L(error) {
+    this.G = error;
     this.C?.();
-    if (this.f & LOADING_BIT) {
-      this.h.S?.(this);
-    }
+    this.h.notify(this, LOADING_BIT, 0);
     this.f = ERROR_BIT;
-    if (this.w === EFFECT_USER) {
+    if (this.u === EFFECT_USER) {
       try {
-        return this.M ? this.C = this.M(error) : console.error(new EffectError(this.L, error));
+        return this.N ? this.C = this.N(error) : console.error(new EffectError(this.M, error));
       } catch (e) {
         error = e;
       }
     }
-    this.handleError(error);
+    if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
+      throw error;
   }
-  A() {
+  y() {
     if (this.a === STATE_DISPOSED)
       return;
-    this.L = void 0;
-    this.N = void 0;
     this.M = void 0;
+    this.O = void 0;
+    this.N = void 0;
     this.C?.();
     this.C = void 0;
-    super.A();
+    super.y();
   }
-  U() {
-    if (this.R && this.a !== STATE_DISPOSED) {
+  V() {
+    if (this.U && this.a !== STATE_DISPOSED) {
       this.C?.();
       try {
-        this.C = this.L(this.g, this.N);
+        this.C = this.M(this.g, this.O);
       } catch (e) {
-        this.handleError(e);
+        if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
+          throw e;
       } finally {
-        this.N = this.g;
-        this.R = false;
+        this.O = this.g;
+        this.U = false;
       }
     }
   }
@@ -846,75 +836,154 @@ var Effect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.z();
+    !options?.defer && this.x();
   }
-  q(state, skipQueue) {
-    if (this.a >= state && !this.K)
+  r(state, skipQueue) {
+    if (this.a >= state && !this.B)
       return;
     if (this.a === STATE_CLEAN && !skipQueue)
       this.h.enqueue(EFFECT_PURE, this);
-    super.q(state, skipQueue);
+    super.r(state, skipQueue);
   }
 };
 var ProjectionComputation = class extends Computation {
   constructor(compute2) {
-    super(null, compute2);
+    super(void 0, compute2);
   }
-  q(state, skipQueue) {
-    if (this.a >= state && !this.K)
+  r(state, skipQueue) {
+    if (this.a >= state && !this.B)
       return;
-    if (this.a === STATE_CLEAN && !skipQueue)
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.B))
       this.h.enqueue(EFFECT_PURE, this);
-    super.q(state, true);
+    super.r(state, true);
+    this.B = !!skipQueue;
   }
 };
 
-// src/core/suspense.ts
-var SuspenseQueue = class extends Queue {
-  c = /* @__PURE__ */ new Set();
-  o = false;
-  T = new Computation(false, null);
+// src/core/boundaries.ts
+var BoundaryComputation = class extends EagerComputation {
+  H;
+  constructor(compute2, propagationMask) {
+    super(void 0, compute2, { defer: true });
+    this.H = propagationMask;
+  }
+  write(value, flags) {
+    super.write(value, flags & ~this.H);
+    if (this.H & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
+      flags &= ~LOADING_BIT;
+    }
+    this.h.notify(this, this.H, 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 {
+  p;
+  P = /* @__PURE__ */ new Set();
+  Q = /* @__PURE__ */ new Set();
+  constructor(disabled) {
+    super();
+    this.p = disabled;
+  }
   run(type) {
-    if (type && this.o)
+    if (type && this.p.read())
       return;
     return super.run(type);
   }
-  S(node) {
-    if (node.f & LOADING_BIT) {
-      this.c.add(node);
-      if (!this.o) {
-        this.o = true;
-        this.T.write(true);
+  notify(node, type, flags) {
+    if (this.p.read()) {
+      if (type === LOADING_BIT) {
+        flags & LOADING_BIT ? this.Q.add(node) : this.Q.delete(node);
       }
-    } else {
-      this.c.delete(node);
-      if (this.c.size === 0) {
-        this.o = false;
-        this.T.write(false);
+      if (type === ERROR_BIT) {
+        flags & ERROR_BIT ? this.P.add(node) : this.P.delete(node);
       }
+      return true;
     }
+    return super.notify(node, type, flags);
   }
 };
-var LiveComputation = class extends EagerComputation {
-  write(value, flags = 0) {
-    const currentFlags = this.f;
-    const dirty = this.a === STATE_DIRTY;
-    super.write(value, flags);
-    if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.h.S?.(this);
+var CollectionQueue = class extends Queue {
+  R;
+  b = /* @__PURE__ */ new Set();
+  p = new Computation(false, null);
+  constructor(type) {
+    super();
+    this.R = 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.p.write(true);
+    } else {
+      this.b.delete(node);
+      if (this.b.size === 0)
+        this.p.write(false);
     }
-    return this.g;
+    type &= ~this.R;
+    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.p.read();
+    tree.H = 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.p.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.p.read()) {
+      const resolved = tree.read();
+      if (!queue.p.read())
+        return resolved;
+    }
+    return fallback(queue);
+  });
+  return decision.read.bind(decision);
+}
 function createSuspense(fn, fallback) {
-  const queue = new SuspenseQueue();
-  const tree = createBoundary(() => {
-    const child = new Computation(null, fn);
-    return new LiveComputation(null, () => flatten(child.wait()));
-  }, queue);
-  const equality = new Computation(null, () => queue.T.read() || queue.o);
-  const comp = new Computation(null, () => equality.read() ? fallback() : tree.read());
-  return comp.read.bind(comp);
+  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
+}
+function createErrorBoundary(fn, fallback) {
+  return createCollectionBoundary(
+    ERROR_BIT,
+    fn,
+    (queue) => fallback(queue.b.values().next().value.G, () => {
+      incrementClock();
+      for (let node of queue.b) {
+        node.a = STATE_DIRTY;
+        node.h?.enqueue(node.u, node);
+      }
+    })
+  );
 }
 
 // src/signals.ts
@@ -942,77 +1011,64 @@ function createMemo(compute2, value, options) {
   let resolvedValue;
   return () => {
     if (node) {
+      if (node.a === STATE_DISPOSED) {
+        node = void 0;
+        return resolvedValue;
+      }
       resolvedValue = node.wait();
-      if (!node.b?.length && node.n?.t !== node) {
+      if (!node.c?.length && node.m?.n !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node.t && !node.e?.length) {
-        node.dispose();
-        node.a = STATE_DIRTY;
       }
     }
     return resolvedValue;
   };
 }
 function createAsync(compute2, value, options) {
-  let uninitialized = value === void 0;
-  const lhs = new EagerComputation(
-    {
-      g: value
-    },
+  const node = new EagerComputation(
+    value,
     (p) => {
-      const value2 = p?.g;
-      const source = compute2(value2);
+      const source = compute2(p);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
       if (!isPromise && !iterator) {
-        return {
-          wait() {
-            return source;
-          },
-          g: source
-        };
+        return source;
       }
-      const signal = new Computation(value2, null, iterator ? { ...options, equals: false } : options);
-      const w = signal.wait;
-      signal.wait = function() {
-        if (signal.f & ERROR_BIT && signal.y <= getClock()) {
-          lhs.q(STATE_DIRTY);
-          throw new NotReadyError();
-        }
-        return w.call(this);
-      };
-      signal.write(UNCHANGED, LOADING_BIT | (uninitialized ? UNINITIALIZED_BIT : 0));
+      let abort = false;
+      onCleanup(() => abort = true);
       if (isPromise) {
         source.then(
           (value3) => {
-            uninitialized = false;
-            signal.write(value3, 0, true);
+            if (abort)
+              return;
+            node.write(value3, 0, true);
           },
           (error) => {
-            uninitialized = true;
-            signal.H(error);
+            if (abort)
+              return;
+            node.L(error);
           }
         );
       } else {
-        let abort = false;
-        onCleanup(() => abort = true);
         (async () => {
           try {
             for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value3, 0, true);
+              node.write(value3, 0, true);
             }
           } catch (error) {
-            signal.write(error, ERROR_BIT);
+            if (abort)
+              return;
+            node.write(error, ERROR_BIT);
           }
         })();
       }
-      return signal;
-    }
+      throw new NotReadyError();
+    },
+    options
   );
-  return () => lhs.wait().wait();
+  return node.wait.bind(node);
 }
 function createEffect(compute2, effect, error, value, options) {
   void new Effect(
@@ -1029,62 +1085,13 @@ function createRenderEffect(compute2, effect, value, options) {
     ...options
   });
 }
-function createRoot(init) {
-  const owner = new Owner();
+function createRoot(init, options) {
+  const owner = new Owner(options?.id);
   return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
 }
 function runWithOwner(owner, run) {
   return compute(owner, run, null);
 }
-function createErrorBoundary(fn, fallback) {
-  const owner = new Owner();
-  const error = new Computation(void 0, null);
-  const nodes = /* @__PURE__ */ new Set();
-  function handler(err, node) {
-    if (nodes.has(node))
-      return;
-    compute(
-      node,
-      () => onCleanup(() => {
-        nodes.delete(node);
-        if (!nodes.size)
-          error.write(void 0);
-      }),
-      null
-    );
-    nodes.add(node);
-    if (nodes.size === 1)
-      error.write({ G: err });
-  }
-  owner.m = owner.m ? [handler, ...owner.m] : [handler];
-  const guarded = compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      const f = new EagerComputation(void 0, () => flatten(c.read()), { defer: true });
-      f.H = function(error2) {
-        this.handleError(error2);
-      };
-      return f;
-    },
-    null
-  );
-  const decision = new Computation(null, () => {
-    if (!error.read()) {
-      const resolved = guarded.read();
-      if (!error.read())
-        return resolved;
-    }
-    return fallback(error.read().G, () => {
-      incrementClock();
-      for (let node of nodes) {
-        node.a = STATE_DIRTY;
-        node.h?.enqueue(node.w, node);
-      }
-    });
-  });
-  return decision.read.bind(decision);
-}
 function resolve(fn) {
   return new Promise((res, rej) => {
     createRoot((dispose) => {
@@ -1230,7 +1237,7 @@ function ownKeys(target) {
   trackSelf(target);
   return Reflect.ownKeys(target[STORE_VALUE]);
 }
-var Writing = /* @__PURE__ */ new Set();
+var Writing = null;
 var proxyTraps = {
   get(target, property, receiver) {
     if (property === $TARGET)
@@ -1251,7 +1258,7 @@ var proxyTraps = {
       if (desc && desc.get)
         return desc.get.call(receiver);
     }
-    if (Writing.has(storeValue)) {
+    if (Writing?.has(storeValue)) {
       const value2 = tracked ? tracked.g : storeValue[property];
       return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
@@ -1274,11 +1281,11 @@ var proxyTraps = {
     return has;
   },
   set(target, property, value) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
     return true;
   },
   deleteProperty(target, property) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
     return true;
   },
   ownKeys,
@@ -1361,11 +1368,14 @@ function createStore(first, second) {
   const unwrappedStore = unwrap(store);
   let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
+    const prevWriting = Writing;
+    Writing = /* @__PURE__ */ new Set();
+    Writing.add(unwrappedStore);
     try {
-      Writing.add(unwrappedStore);
       fn(wrappedStore);
     } finally {
       Writing.clear();
+      Writing = prevWriting;
     }
   };
   if (derived)
@@ -1643,19 +1653,19 @@ function mapArray(list, map, options) {
   return updateKeyedMap.bind({
     I: new Owner(),
     i: 0,
-    Y: list,
-    x: [],
+    _: list,
+    w: [],
     D: map,
     d: [],
-    c: [],
+    b: [],
     E: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
-    o: options?.fallback
+    J: options?.fallback
   });
 }
 function updateKeyedMap() {
-  const newItems = this.Y() || [], newLen = newItems.length;
+  const newItems = this._() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this.I, () => {
     let i, j, mapper = this.j ? () => {
@@ -1676,38 +1686,38 @@ function updateKeyedMap() {
     if (newLen === 0) {
       if (this.i !== 0) {
         this.I.dispose(false);
-        this.c = [];
-        this.x = [];
+        this.b = [];
+        this.w = [];
         this.d = [];
         this.i = 0;
         this.j && (this.j = []);
         this.k && (this.k = []);
       }
-      if (this.o && !this.d[0]) {
+      if (this.J && !this.d[0]) {
         this.d[0] = compute(
-          this.c[0] = new Owner(),
-          this.o,
+          this.b[0] = new Owner(),
+          this.J,
           null
         );
       }
     } else if (this.i === 0) {
-      if (this.c[0])
-        this.c[0].dispose();
+      if (this.b[0])
+        this.b[0].dispose();
       this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.x[j] = newItems[j];
-        this.d[j] = compute(this.c[j] = new Owner(), mapper, null);
+        this.w[j] = newItems[j];
+        this.d[j] = compute(this.b[j] = new Owner(), mapper, null);
       }
       this.i = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.j ? new Array(newLen) : void 0, tempIndexes = this.k ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.x[start] === newItems[start] || this.j && compare(this.E, this.x[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.w[start] === newItems[start] || this.j && compare(this.E, this.w[start], newItems[start])); start++) {
         if (this.j)
           this.j[start].write(newItems[start]);
       }
-      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.x[end] === newItems[newEnd] || this.j && compare(this.E, this.x[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.E, this.w[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.d[end];
-        tempNodes[newEnd] = this.c[end];
+        tempNodes[newEnd] = this.b[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
         tempIndexes && (tempIndexes[newEnd] = this.k[end]);
       }
@@ -1721,23 +1731,23 @@ function updateKeyedMap() {
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.x[i];
+        item = this.w[i];
         key = this.E ? this.E(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.d[i];
-          tempNodes[j] = this.c[i];
+          tempNodes[j] = this.b[i];
           tempRows && (tempRows[j] = this.j[i]);
           tempIndexes && (tempIndexes[j] = this.k[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.c[i].dispose();
+          this.b[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
           this.d[j] = temp[j];
-          this.c[j] = tempNodes[j];
+          this.b[j] = tempNodes[j];
           if (tempRows) {
             this.j[j] = tempRows[j];
             this.j[j].write(newItems[j]);
@@ -1747,11 +1757,11 @@ function updateKeyedMap() {
             this.k[j].write(j);
           }
         } else {
-          this.d[j] = compute(this.c[j] = new Owner(), mapper, null);
+          this.d[j] = compute(this.b[j] = new Owner(), mapper, null);
         }
       }
       this.d = this.d.slice(0, this.i = newLen);
-      this.x = newItems.slice(0);
+      this.w = newItems.slice(0);
     }
   });
   return this.d;
@@ -1760,59 +1770,59 @@ function repeat(count, map, options) {
   return updateRepeat.bind({
     I: new Owner(),
     i: 0,
-    r: 0,
-    Z: count,
+    q: 0,
+    $: count,
     D: map,
-    c: [],
+    b: [],
     d: [],
-    _: options?.from,
-    o: options?.fallback
+    aa: options?.from,
+    J: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.Z();
-  const from = this._?.() || 0;
+  const newLen = this.$();
+  const from = this.aa?.() || 0;
   runWithOwner(this.I, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
         this.I.dispose(false);
-        this.c = [];
+        this.b = [];
         this.d = [];
         this.i = 0;
       }
-      if (this.o && !this.d[0]) {
+      if (this.J && !this.d[0]) {
         this.d[0] = compute(
-          this.c[0] = new Owner(),
-          this.o,
+          this.b[0] = new Owner(),
+          this.J,
           null
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.r + this.i;
-    if (this.i === 0 && this.c[0])
-      this.c[0].dispose();
+    const prevTo = this.q + this.i;
+    if (this.i === 0 && this.b[0])
+      this.b[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.c[i - this.r].dispose();
-    if (this.r < from) {
-      let i = this.r;
+      this.b[i - this.q].dispose();
+    if (this.q < from) {
+      let i = this.q;
       while (i < from && i < this.i)
-        this.c[i++].dispose();
-      this.c.splice(0, from - this.r);
-      this.d.splice(0, from - this.r);
-    } else if (this.r > from) {
-      let i = prevTo - this.r - 1;
-      let difference = this.r - from;
-      this.c.length = this.d.length = newLen;
+        this.b[i++].dispose();
+      this.b.splice(0, from - this.q);
+      this.d.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;
       while (i >= difference) {
-        this.c[i] = this.c[i - difference];
+        this.b[i] = this.b[i - difference];
         this.d[i] = this.d[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
         this.d[i2] = compute(
-          this.c[i2] = new Owner(),
+          this.b[i2] = new Owner(),
           () => this.D(i2 + from),
           null
         );
@@ -1820,13 +1830,13 @@ function updateRepeat() {
     }
     for (let i = prevTo; i < to; i++) {
       this.d[i - from] = compute(
-        this.c[i - from] = new Owner(),
+        this.b[i - from] = new Owner(),
         () => this.D(i),
         null
       );
     }
     this.d = this.d.slice(0, newLen);
-    this.r = from;
+    this.q = from;
     this.i = newLen;
   });
   return this.d;
@@ -1835,4 +1845,4 @@ 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, catchError, 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, untrack, unwrap };
+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 };