@solidjs/signals 0.0.7 → 0.0.9

package/dist/prod.js

@@ -13,13 +13,18 @@ var ContextNotFoundError = class extends Error {
     );
   }
 };
+var EffectError = class extends Error {
+  constructor(effect, cause) {
+    super("");
+    this.cause = cause;
+  }
+};
 
 // src/core/constants.ts
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
 var STATE_DIRTY = 2;
-var STATE_UNINITIALIZED = 3;
-var STATE_DISPOSED = 4;
+var STATE_DISPOSED = 3;
 var EFFECT_PURE = 0;
 var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
@@ -99,82 +104,82 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
-  o = null;
-  m = null;
-  p = null;
+  r = null;
+  n = null;
+  s = null;
   a = STATE_CLEAN;
-  j = null;
-  n = defaultContext;
-  k = null;
-  e = null;
+  l = null;
+  p = defaultContext;
+  m = null;
+  b = null;
   constructor(signal = false) {
     if (currentOwner && !signal)
       currentOwner.append(this);
   }
   append(child) {
-    child.o = this;
-    child.p = this;
-    if (this.m)
-      this.m.p = child;
-    child.m = this.m;
-    this.m = child;
-    if (child.n !== this.n) {
-      child.n = { ...this.n, ...child.n };
+    child.r = this;
+    child.s = this;
+    if (this.n)
+      this.n.s = child;
+    child.n = this.n;
+    this.n = child;
+    if (child.p !== this.p) {
+      child.p = { ...this.p, ...child.p };
     }
-    if (this.k) {
-      child.k = !child.k ? this.k : [...child.k, ...this.k];
+    if (this.m) {
+      child.m = !child.m ? this.m : [...child.m, ...this.m];
     }
-    if (this.e)
-      child.e = this.e;
+    if (this.b)
+      child.b = this.b;
   }
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.p || this.o : this, current = this.m, next = null;
-    while (current && current.o === this) {
+    let head = self ? this.s || this.r : this, current = this.n, next = null;
+    while (current && current.r === this) {
       current.dispose(true);
-      current.x();
-      next = current.m;
-      current.m = null;
+      current.z();
+      next = current.n;
+      current.n = null;
       current = next;
     }
     if (self)
-      this.x();
+      this.z();
     if (current)
-      current.p = !self ? this : this.p;
+      current.s = !self ? this : this.s;
     if (head)
-      head.m = current;
-  }
-  x() {
-    if (this.p)
-      this.p.m = null;
-    this.o = null;
-    this.p = null;
-    this.n = defaultContext;
-    this.k = null;
+      head.n = current;
+  }
+  z() {
+    if (this.s)
+      this.s.n = null;
+    this.r = null;
+    this.s = null;
+    this.p = defaultContext;
+    this.m = null;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.j)
+    if (!this.l)
       return;
-    if (Array.isArray(this.j)) {
-      for (let i = 0; i < this.j.length; i++) {
-        const callable = this.j[i];
+    if (Array.isArray(this.l)) {
+      for (let i = 0; i < this.l.length; i++) {
+        const callable = this.l[i];
         callable.call(callable);
       }
     } else {
-      this.j.call(this.j);
+      this.l.call(this.l);
     }
-    this.j = null;
+    this.l = null;
   }
   handleError(error) {
-    if (!this.k)
+    if (!this.m)
       throw error;
-    let i = 0, len = this.k.length;
+    let i = 0, len = this.m.length;
     for (i = 0; i < len; i++) {
       try {
-        this.k[i](error);
+        this.m[i](error);
         break;
       } catch (e) {
         error = e;
@@ -191,7 +196,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.n[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.p[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -201,24 +206,24 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.n = {
-    ...owner.n,
+  owner.p = {
+    ...owner.p,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.n[context.id]);
+  return !isUndefined(owner?.p[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.j) {
-    node.j = fn;
-  } else if (Array.isArray(node.j)) {
-    node.j.push(fn);
+  if (!node.l) {
+    node.l = fn;
+  } else if (Array.isArray(node.l)) {
+    node.l.push(fn);
   } else {
-    node.j = [node.j, fn];
+    node.l = [node.l, fn];
   }
   return fn;
 }
@@ -228,6 +233,8 @@ var ERROR_OFFSET = 0;
 var ERROR_BIT = 1 << ERROR_OFFSET;
 var LOADING_OFFSET = 1;
 var LOADING_BIT = 1 << LOADING_OFFSET;
+var UNINITIALIZED_OFFSET = 2;
+var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
 var DEFAULT_FLAGS = ERROR_BIT;
 
 // src/core/core.ts
@@ -237,53 +244,59 @@ var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
 var clock = 0;
-var syncResolve = false;
+var notStale = false;
 var updateCheck = null;
+var staleCheck = null;
 function getObserver() {
   return currentObserver;
 }
+function getClock() {
+  return clock;
+}
 function incrementClock() {
   clock++;
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  c = null;
-  b = null;
-  d;
-  C;
+  g = null;
+  e = null;
+  c;
+  D;
+  t;
   // Used in __DEV__ mode, hopefully removed in production
-  V;
+  Z;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  G = isEqual;
-  O;
+  N = isEqual;
+  T;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  f = 0;
+  d = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  D = DEFAULT_FLAGS;
-  z = null;
-  H = null;
-  I = -1;
+  O = DEFAULT_FLAGS;
+  P = null;
+  A = -1;
+  H = false;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.C = compute2;
-    this.a = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
-    this.d = initialValue;
+    this.t = compute2;
+    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.c = initialValue;
     if (options?.equals !== void 0)
-      this.G = options.equals;
+      this.N = options.equals;
     if (options?.unobserved)
-      this.O = options?.unobserved;
+      this.T = options?.unobserved;
   }
-  P() {
-    if (this.C)
-      this.t();
-    if (!this.C || this.c?.length)
+  U() {
+    if (this.t)
+      this.x();
+    if (!this.t || this.g?.length)
       track(this);
-    newFlags |= this.f & ~currentMask;
-    if (this.f & ERROR_BIT) {
-      throw this.d;
+    newFlags |= this.d & ~currentMask;
+    if (this.d & ERROR_BIT) {
+      throw this.D;
     } else {
-      return this.d;
+      return this.c;
     }
   }
   /**
@@ -291,7 +304,7 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    return this.P();
+    return this.U();
   }
   /**
    * Return the current value of this computation
@@ -301,10 +314,15 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (!syncResolve && this.loading()) {
+    if (this.t && this.d & ERROR_BIT && this.A <= clock) {
+      update(this);
+    }
+    if ((notStale || this.d & UNINITIALIZED_BIT) && this.loading()) {
       throw new NotReadyError();
     }
-    return this.P();
+    if (staleCheck && this.d & LOADING_BIT)
+      staleCheck.c = true;
+    return this.U();
   }
   /**
    * Return true if the computation is the value is dependent on an unresolved promise
@@ -314,51 +332,44 @@ var Computation = class extends Owner {
    * loading state changes
    */
   loading() {
-    if (this.H === null) {
-      this.H = loadingState(this);
-    }
-    return this.H.read();
-  }
-  /**
-   * Return true if the computation is the computation threw an error
-   * Triggers re-execution of the computation when the error state changes
-   */
-  error() {
-    if (this.z === null) {
-      this.z = errorState(this);
+    if (this.P === null) {
+      this.P = loadingState(this);
     }
-    return this.z.read();
+    return this.P.read();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    const newValue = !raw && typeof value === "function" ? value(this.d) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.a === STATE_UNINITIALIZED || this.G === false || !this.G(this.d, newValue));
-    if (valueChanged)
-      this.d = newValue;
-    const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
-    this.f = flags;
-    this.I = clock + 1;
-    if (this.b) {
-      for (let i = 0; i < this.b.length; i++) {
+    const newValue = !raw && typeof value === "function" ? value(this.c) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.d & UNINITIALIZED_BIT) || this.N === false || !this.N(this.c, newValue));
+    if (valueChanged) {
+      this.c = newValue;
+      this.D = void 0;
+    }
+    const changedFlagsMask = this.d ^ flags, changedFlags = changedFlagsMask & flags;
+    this.d = flags;
+    this.A = clock + 1;
+    if (this.e) {
+      for (let i = 0; i < this.e.length; i++) {
         if (valueChanged) {
-          this.b[i].u(STATE_DIRTY);
+          this.e[i].q(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.b[i].Q(changedFlagsMask, changedFlags);
+          this.e[i].V(changedFlagsMask, changedFlags);
         }
       }
     }
-    return this.d;
+    return this.c;
   }
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  u(state) {
-    if (this.a >= state)
+  q(state, skipQueue) {
+    if (this.a >= state && !this.H)
       return;
+    this.H = !!skipQueue;
     this.a = state;
-    if (this.b) {
-      for (let i = 0; i < this.b.length; i++) {
-        this.b[i].u(STATE_CHECK);
+    if (this.e) {
+      for (let i = 0; i < this.e.length; i++) {
+        this.e[i].q(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -368,30 +379,31 @@ 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.
    */
-  Q(mask, newFlags2) {
+  V(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.D) {
-      this.u(STATE_DIRTY);
+    if (mask & this.O) {
+      this.q(STATE_DIRTY);
       return;
     }
     if (this.a >= STATE_CHECK)
       return;
-    const prevFlags = this.f & mask;
+    const prevFlags = this.d & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.u(STATE_CHECK);
+      this.q(STATE_CHECK);
     } else {
-      this.f ^= deltaFlags;
-      if (this.b) {
-        for (let i = 0; i < this.b.length; i++) {
-          this.b[i].Q(mask, newFlags2);
+      this.d ^= deltaFlags;
+      if (this.e) {
+        for (let i = 0; i < this.e.length; i++) {
+          this.e[i].V(mask, newFlags2);
         }
       }
     }
   }
-  J(error) {
-    this.write(error, this.f | ERROR_BIT);
+  I(error) {
+    this.D = error;
+    this.write(UNCHANGED, this.d & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -400,7 +412,7 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  t() {
+  x() {
     if (this.a === STATE_DISPOSED) {
       throw new Error("Tried to read a disposed computation");
     }
@@ -409,15 +421,15 @@ var Computation = class extends Owner {
     }
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].t();
-        observerFlags |= this.c[i].f;
+      for (let i = 0; i < this.g.length; i++) {
+        this.g[i].x();
+        observerFlags |= this.g[i].d;
         if (this.a === STATE_DIRTY) {
           break;
         }
       }
     }
-    if (this.a === STATE_DIRTY || this.a === STATE_UNINITIALIZED) {
+    if (this.a === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
@@ -427,49 +439,33 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  x() {
+  z() {
     if (this.a === STATE_DISPOSED)
       return;
-    if (this.c)
+    if (this.g)
       removeSourceObservers(this, 0);
-    super.x();
+    super.z();
   }
 };
 function loadingState(node) {
-  const prevOwner = setOwner(node.o);
-  const options = void 0;
-  const computation = new Computation(
-    void 0,
-    () => {
-      track(node);
-      node.t();
-      return !!(node.f & LOADING_BIT);
-    },
-    options
-  );
-  computation.D = ERROR_BIT | LOADING_BIT;
-  setOwner(prevOwner);
-  return computation;
-}
-function errorState(node) {
-  const prevOwner = setOwner(node.o);
+  const prevOwner = setOwner(node.r);
   const options = void 0;
   const computation = new Computation(
     void 0,
     () => {
       track(node);
-      node.t();
-      return !!(node.f & ERROR_BIT);
+      node.x();
+      return !!(node.d & LOADING_BIT);
     },
     options
   );
-  computation.D = ERROR_BIT;
+  computation.O = ERROR_BIT | LOADING_BIT;
   setOwner(prevOwner);
   return computation;
 }
 function track(computation) {
   if (currentObserver) {
-    if (!newSources && currentObserver.c && currentObserver.c[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.g && currentObserver.g[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -477,7 +473,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.d = computation.I > currentObserver.I;
+      updateCheck.c = computation.A > currentObserver.A;
     }
   }
 }
@@ -489,55 +485,56 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.C, node);
+    const result = compute(node, node.t, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.d & UNINITIALIZED_BIT);
     } else {
-      node.J(error);
+      node.I(error);
     }
   } finally {
     if (newSources) {
-      if (node.c)
+      if (node.g)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.c && newSourcesIndex > 0) {
-        node.c.length = newSourcesIndex + newSources.length;
+      if (node.g && newSourcesIndex > 0) {
+        node.g.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.c[newSourcesIndex + i] = newSources[i];
+          node.g[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.c = newSources;
+        node.g = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.c.length; i++) {
-        source = node.c[i];
-        if (!source.b)
-          source.b = [node];
+      for (let i = newSourcesIndex; i < node.g.length; i++) {
+        source = node.g[i];
+        if (!source.e)
+          source.e = [node];
         else
-          source.b.push(node);
+          source.e.push(node);
       }
-    } else if (node.c && newSourcesIndex < node.c.length) {
+    } else if (node.g && newSourcesIndex < node.g.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.c.length = newSourcesIndex;
+      node.g.length = newSourcesIndex;
     }
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
+    node.A = clock + 1;
     node.a = STATE_CLEAN;
   }
 }
 function removeSourceObservers(node, index) {
   let source;
   let swap;
-  for (let i = index; i < node.c.length; i++) {
-    source = node.c[i];
-    if (source.b) {
-      swap = source.b.indexOf(node);
-      source.b[swap] = source.b[source.b.length - 1];
-      source.b.pop();
-      if (!source.b.length)
-        source.O?.();
+  for (let i = index; i < node.g.length; i++) {
+    source = node.g[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.T?.();
     }
   }
 }
@@ -551,43 +548,58 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { d: false };
+  updateCheck = { c: false };
   try {
     fn();
-    return updateCheck.d;
+    return updateCheck.c;
   } finally {
     updateCheck = current;
   }
 }
-function isPending(fn) {
+function isStale(fn) {
+  const current = staleCheck;
+  staleCheck = { c: false };
   try {
-    fn();
-    return false;
-  } catch (e) {
-    return e instanceof NotReadyError;
+    latest(fn);
+    return staleCheck.c;
+  } catch {
+  } finally {
+    staleCheck = current;
   }
+  return false;
 }
 function latest(fn) {
   const prevFlags = newFlags;
-  syncResolve = true;
+  const prevNotStale = notStale;
+  notStale = false;
   try {
     return fn();
-  } catch {
   } finally {
     newFlags = prevFlags;
-    syncResolve = false;
+    notStale = prevNotStale;
   }
 }
-function compute(owner, compute2, observer) {
-  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
+function catchError(fn) {
+  try {
+    fn();
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return e;
+  }
+}
+function compute(owner, fn, observer) {
+  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.D ?? DEFAULT_FLAGS;
+  currentMask = observer?.O ?? DEFAULT_FLAGS;
+  notStale = true;
   try {
-    return compute2(observer ? observer.d : void 0);
+    return fn(observer ? observer.c : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
     currentMask = prevMask;
+    notStale = prevNotStale;
   }
 }
 
@@ -597,93 +609,84 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.E)
+  if (!globalQueue.J)
     queueMicrotask(flushSync);
 }
 var Queue = class {
-  E = false;
-  q = [[], [], []];
-  A = [];
+  J = false;
+  u = [[], [], []];
+  E = [];
   enqueue(type, node) {
-    this.q[0].push(node);
+    this.u[0].push(node);
     if (type)
-      this.q[type].push(node);
+      this.u[type].push(node);
     schedule();
   }
   run(type) {
-    if (this.q[type].length) {
+    if (this.u[type].length) {
       if (type === EFFECT_PURE) {
-        runPureQueue(this.q[type]);
-        this.q[type] = [];
+        runPureQueue(this.u[type]);
+        this.u[type] = [];
       } else {
-        const effects = this.q[type];
-        this.q[type] = [];
+        const effects = this.u[type];
+        this.u[type] = [];
         runEffectQueue(effects);
       }
     }
     let rerun = false;
-    for (let i = 0; i < this.A.length; i++) {
-      rerun = this.A[i].run(type) || rerun;
+    for (let i = 0; i < this.E.length; i++) {
+      rerun = this.E[i].run(type) || rerun;
     }
-    if (type === EFFECT_PURE && this.q[type].length)
+    if (type === EFFECT_PURE && this.u[type].length)
       return true;
   }
   flush() {
-    if (this.E)
+    if (this.J)
       return;
-    this.E = true;
+    this.J = true;
     try {
       while (this.run(EFFECT_PURE)) {
       }
-      ;
       incrementClock();
       scheduled = false;
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.E = false;
+      this.J = false;
     }
   }
   addChild(child) {
-    this.A.push(child);
+    this.E.push(child);
   }
   removeChild(child) {
-    const index = this.A.indexOf(child);
+    const index = this.E.indexOf(child);
     if (index >= 0)
-      this.A.splice(index, 1);
+      this.E.splice(index, 1);
   }
 };
 var globalQueue = new Queue();
-var globalTasks = [];
 function flushSync() {
   while (scheduled) {
     globalQueue.flush();
-    for (let i = 0; i < globalTasks.length; i++)
-      globalTasks[i]();
-    globalTasks.length = 0;
   }
 }
-function queueTask(fn) {
-  globalTasks.push(fn);
-  schedule();
-}
 function createBoundary(fn, queue) {
   const owner = new Owner();
-  const parentQueue = owner.e || globalQueue;
-  parentQueue.addChild(owner.e = queue);
-  onCleanup(() => parentQueue.removeChild(owner.e));
+  const parentQueue = owner.b || globalQueue;
+  parentQueue.addChild(owner.b = queue);
+  onCleanup(() => parentQueue.removeChild(owner.b));
   return compute(owner, fn, null);
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.o) {
+  for (let current = node; current !== null; current = current.r) {
     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].t();
+      ancestors[i].x();
   }
 }
 function runPureQueue(queue) {
@@ -694,110 +697,157 @@ function runPureQueue(queue) {
 }
 function runEffectQueue(queue) {
   for (let i = 0; i < queue.length; i++)
-    queue[i].R();
+    queue[i].W();
 }
 
 // src/core/effect.ts
 var Effect = class extends Computation {
   K;
-  L = false;
-  F;
+  L;
   B;
-  e;
-  constructor(initialValue, compute2, effect, options) {
+  Q = false;
+  M;
+  y;
+  b;
+  constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.K = effect;
-    this.F = initialValue;
-    this.B = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    this.e = getOwner()?.e || globalQueue;
-    this.t();
-    this.B === EFFECT_USER ? this.e.enqueue(this.B, this) : this.R();
+    this.L = error;
+    this.M = initialValue;
+    this.y = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.y === EFFECT_RENDER) {
+      this.t = (p) => latest(() => compute2(p));
+    }
+    this.b = getOwner()?.b || globalQueue;
+    if (!options?.defer) {
+      this.x();
+      this.y === EFFECT_USER ? this.b.enqueue(this.y, this) : this.W();
+    }
   }
   write(value, flags = 0) {
-    const currentFlags = this.f;
-    this.f = flags;
-    if (this.B === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.e.S?.(this);
+    if (this.a == STATE_DIRTY) {
+      const currentFlags = this.d;
+      this.d = flags;
+      if (this.y === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+        this.b.R?.(this);
+      }
     }
     if (value === UNCHANGED)
-      return this.d;
-    this.d = value;
-    this.L = true;
+      return this.c;
+    this.c = value;
+    this.Q = true;
     return value;
   }
-  u(state) {
-    if (this.a >= state)
+  q(state, skipQueue) {
+    if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.e.enqueue(this.B, this);
+      this.b.enqueue(this.y, this);
     this.a = state;
   }
-  J(error) {
+  I(error) {
+    this.B?.();
+    if (this.d & LOADING_BIT) {
+      this.d = 0;
+      this.b.R?.(this);
+    }
+    if (this.y === EFFECT_USER) {
+      try {
+        return this.L ? this.B = this.L(error) : console.error(new EffectError(this.K, error));
+      } catch (e) {
+        error = e;
+      }
+    }
     this.handleError(error);
   }
-  x() {
+  z() {
+    if (this.a === STATE_DISPOSED)
+      return;
     this.K = void 0;
-    this.F = void 0;
-    super.x();
-  }
-  R() {
-    if (this.L && this.a !== STATE_DISPOSED) {
-      this.K(this.d, this.F);
-      this.F = this.d;
-      this.L = false;
+    this.M = void 0;
+    this.L = void 0;
+    this.B?.();
+    this.B = void 0;
+    super.z();
+  }
+  W() {
+    if (this.Q && this.a !== STATE_DISPOSED) {
+      this.B?.();
+      try {
+        this.B = this.K(this.c, this.M);
+      } catch (e) {
+        this.handleError(e);
+      } finally {
+        this.M = this.c;
+        this.Q = false;
+      }
     }
   }
 };
 var EagerComputation = class extends Computation {
-  e;
+  b;
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    this.e = getOwner()?.e || globalQueue;
-    this.t();
+    this.b = getOwner()?.b || globalQueue;
+    this.x();
   }
-  u(state) {
-    if (this.a >= state)
+  q(state, skipQueue) {
+    if (this.a >= state && !this.H)
       return;
-    if (this.a === STATE_CLEAN)
-      this.e.enqueue(EFFECT_PURE, this);
-    super.u(state);
+    if (this.a === STATE_CLEAN && !skipQueue)
+      this.b.enqueue(EFFECT_PURE, this);
+    super.q(state, skipQueue);
+  }
+};
+var ProjectionComputation = class extends Computation {
+  b;
+  constructor(compute2) {
+    super(null, compute2);
+    this.b = getOwner()?.b || globalQueue;
+  }
+  q(state, skipQueue) {
+    if (this.a >= state && !this.H)
+      return;
+    if (this.a === STATE_CLEAN && !skipQueue)
+      this.b.enqueue(EFFECT_PURE, this);
+    super.q(state, true);
   }
 };
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
-  g = /* @__PURE__ */ new Set();
-  r = false;
-  M = new Computation(false, null);
+  f = /* @__PURE__ */ new Set();
+  o = false;
+  S = new Computation(false, null);
   run(type) {
-    if (type && this.r)
+    if (type && this.o)
       return;
     return super.run(type);
   }
-  S(node) {
-    if (node.f & LOADING_BIT) {
-      this.g.add(node);
-      if (!this.r) {
-        this.r = true;
-        queueTask(() => this.M.write(true));
+  R(node) {
+    if (node.d & LOADING_BIT) {
+      this.f.add(node);
+      if (!this.o) {
+        this.o = true;
+        this.S.write(true);
       }
     } else {
-      this.g.delete(node);
-      if (this.g.size === 0) {
-        this.r = false;
-        queueTask(() => this.M.write(false));
+      this.f.delete(node);
+      if (this.f.size === 0) {
+        this.o = false;
+        this.S.write(false);
       }
     }
   }
 };
 var LiveComputation = class extends EagerComputation {
   write(value, flags = 0) {
-    const currentFlags = this.f;
+    const currentFlags = this.d;
     super.write(value, flags);
     if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.e.S?.(this);
+      this.b.R?.(this);
     }
-    return this.d;
+    return this.c;
   }
 };
 function createSuspense(fn, fallback) {
@@ -806,7 +856,7 @@ function createSuspense(fn, fallback) {
     const child = new Computation(null, fn);
     return new LiveComputation(null, () => flatten(child.wait()));
   }, queue);
-  const equality = new Computation(null, () => queue.M.read() || queue.r);
+  const equality = new Computation(null, () => queue.S.read() || queue.o);
   const comp = new Computation(null, () => equality.read() ? fallback() : tree.read());
   return comp.read.bind(comp);
 }
@@ -837,24 +887,25 @@ function createMemo(compute2, value, options) {
   return () => {
     if (node) {
       resolvedValue = node.wait();
-      if (!node.c?.length && node.m?.o !== node) {
+      if (!node.g?.length && node.n?.r !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node.o && !node.b?.length) {
+      } else if (!node.r && !node.e?.length) {
         node.dispose();
-        node.a = STATE_UNINITIALIZED;
+        node.a = STATE_DIRTY;
       }
     }
     return resolvedValue;
   };
 }
 function createAsync(compute2, value, options) {
+  let uninitialized = value === void 0;
   const lhs = new EagerComputation(
     {
-      d: value
+      c: value
     },
     (p) => {
-      const value2 = p?.d;
+      const value2 = p?.c;
       const source = compute2(value2);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
@@ -863,18 +914,28 @@ function createAsync(compute2, value, options) {
           wait() {
             return source;
           },
-          d: source
+          c: source
         };
       }
       const signal = new Computation(value2, null, options);
-      signal.write(UNCHANGED, LOADING_BIT);
+      const w = signal.wait;
+      signal.wait = function() {
+        if (signal.d & ERROR_BIT && signal.A <= getClock()) {
+          lhs.q(STATE_DIRTY);
+          throw new NotReadyError();
+        }
+        return w.call(this);
+      };
+      signal.write(UNCHANGED, LOADING_BIT | (uninitialized ? UNINITIALIZED_BIT : 0));
       if (isPromise) {
         source.then(
           (value3) => {
+            uninitialized = false;
             signal.write(value3, 0, true);
           },
           (error) => {
-            signal.write(error, ERROR_BIT);
+            uninitialized = true;
+            signal.I(error);
           }
         );
       } else {
@@ -897,16 +958,17 @@ function createAsync(compute2, value, options) {
   );
   return () => lhs.wait().wait();
 }
-function createEffect(compute2, effect, value, options) {
+function createEffect(compute2, effect, error, value, options) {
   void new Effect(
     value,
     compute2,
     effect,
+    error,
     void 0
   );
 }
 function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, {
+  void new Effect(value, compute2, effect, void 0, {
     render: true,
     ...void 0
   });
@@ -927,14 +989,14 @@ function createErrorBoundary(fn, fallback) {
   const owner = new Owner();
   const error = new Computation(null, null);
   const reset = new Computation(null, null, { equals: false });
-  const handler = (err) => error.write({ z: err });
-  owner.k = owner.k ? [handler, ...owner.k] : [handler];
+  const handler = (err) => error.write({ D: err });
+  owner.m = owner.m ? [handler, ...owner.m] : [handler];
   const guarded = compute(
     owner,
     () => {
       const c = new Computation(null, () => (reset.read(), fn()));
       const f = new Computation(null, () => flatten(c.read()));
-      f.J = function(error2) {
+      f.I = function(error2) {
         this.handleError(error2);
       };
       return f;
@@ -947,13 +1009,69 @@ function createErrorBoundary(fn, fallback) {
       if (!error.read())
         return resolved;
     }
-    return fallback(error.read().z, () => {
+    return fallback(error.read().D, () => {
       error.write(null);
       reset.write(null);
     });
   });
   return decision.read.bind(decision);
 }
+function resolve(fn) {
+  return new Promise((res, rej) => {
+    let node = new EagerComputation(void 0, () => {
+      try {
+        res(fn());
+      } catch (err) {
+        if (err instanceof NotReadyError)
+          throw err;
+        rej(err);
+      }
+      node.dispose(true);
+    });
+  });
+}
+function createReaction(effect, error, options) {
+  const node = new Effect(void 0, () => {
+  }, effect, error, {
+    defer: true,
+    ...void 0
+  });
+  return (tracking) => {
+    node.t = tracking;
+    node.a = STATE_DIRTY;
+    node.x();
+    node.t = null;
+  };
+}
+
+// src/store/projection.ts
+function createProjection(fn, initialValue = {}) {
+  const [store, setStore] = createStore(initialValue);
+  const node = new ProjectionComputation(() => {
+    setStore(fn);
+  });
+  const wrapped = /* @__PURE__ */ new WeakMap();
+  return wrap(store, node, wrapped);
+}
+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");
+    }
+  });
+  wrapped.set(source, wrap3);
+  return wrap3;
+}
 
 // src/store/store.ts
 var $RAW = Symbol(0);
@@ -963,7 +1081,7 @@ var $PROXY = Symbol(0);
 var STORE_VALUE = "v";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
-function wrap(value) {
+function wrap2(value) {
   let p = value[$PROXY];
   if (!p) {
     let target;
@@ -1071,8 +1189,8 @@ var proxyTraps = {
         return desc.get.call(receiver);
     }
     if (Writing.has(storeValue)) {
-      const value2 = tracked ? tracked.d : storeValue[property];
-      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap(value2)) : value2;
+      const value2 = tracked ? tracked.c : storeValue[property];
+      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
     let value = tracked ? nodes[property].read() : storeValue[property];
     if (!tracked) {
@@ -1080,10 +1198,10 @@ var proxyTraps = {
         let proto;
         return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        value = getNode(nodes, property, isWrappable(value) ? wrap(value) : value).read();
+        value = getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
       }
     }
-    return isWrappable(value) ? wrap(value) : value;
+    return isWrappable(value) ? wrap2(value) : value;
   },
   has(target, property) {
     if (property === $RAW || property === $PROXY || property === $TRACK || property === "__proto__")
@@ -1125,13 +1243,16 @@ function setProperty(state, property, value, deleting = false) {
   const nodes = getNodes(target, STORE_NODE);
   let node;
   if (node = nodes[property])
-    node.write(isWrappable(value) ? wrap(value) : value);
+    node.write(isWrappable(value) ? wrap2(value) : value);
   Array.isArray(state) && state.length !== len && (node = nodes.length) && node.write(state.length);
   (node = nodes[$TRACK]) && node.write(void 0);
 }
 function createStore(first, second) {
-  const derived = typeof first === "function", store = derived ? second : first, unwrappedStore = unwrap(store, false);
-  const wrappedStore = wrap(unwrappedStore);
+  const derived = typeof first === "function", store = derived ? second : first;
+  if (derived)
+    return createProjection(first, store);
+  const unwrappedStore = unwrap(store, false);
+  const wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1140,15 +1261,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
-  if (derived) {
-    new EagerComputation(void 0, () => setStore(first));
-  }
   return [wrappedStore, setStore];
 }
-function createProjection(fn, initialValue = {}) {
-  const [store] = createStore(fn, initialValue);
-  return store;
-}
 
 // src/store/reconcile.ts
 function applyState(next, state, keyFn) {
@@ -1169,7 +1283,7 @@ function applyState(next, state, keyFn) {
     if (next.length && previous.length && 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], wrap(previous[start]), keyFn);
+        applyState(next[start], wrap2(previous[start]), keyFn);
       }
       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--) {
@@ -1178,11 +1292,11 @@ function applyState(next, state, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         }
@@ -1210,17 +1324,17 @@ function applyState(next, state, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         } else
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
       }
       if (start < next.length)
         changed = true;
     } else if (previous.length && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        isWrappable(previous[i]) && applyState(next[i], wrap(previous[i]), keyFn);
+        isWrappable(previous[i]) && applyState(next[i], wrap2(previous[i]), keyFn);
       }
     }
     if (previous.length !== next.length) {
@@ -1240,9 +1354,9 @@ function applyState(next, state, keyFn) {
       if (previousValue === nextValue)
         continue;
       if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
-        node.write(isWrappable(nextValue) ? wrap(nextValue) : nextValue);
+        node.write(isWrappable(nextValue) ? wrap2(nextValue) : nextValue);
       else
-        applyState(nextValue, wrap(previousValue), keyFn);
+        applyState(nextValue, wrap2(previousValue), keyFn);
     }
   }
   if (nodes = target[STORE_HAS]) {
@@ -1414,123 +1528,169 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    T: new Owner(),
-    w: 0,
-    U: list,
-    s: [],
-    N: map,
-    l: [],
-    g: [],
-    y: keyFn,
-    h: keyFn || options?.keyed === false ? [] : void 0,
-    i: map.length > 1 ? [] : void 0,
-    r: options?.fallback
+    F: new Owner(),
+    i: 0,
+    X: list,
+    w: [],
+    G: map,
+    h: [],
+    f: [],
+    C: keyFn,
+    j: keyFn || options?.keyed === false ? [] : void 0,
+    k: map.length > 1 ? [] : void 0,
+    o: options?.fallback
   });
 }
 function updateKeyedMap() {
-  const newItems = this.U() || [], newLen = newItems.length;
+  const newItems = this.X() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.T, () => {
-    let i, j, mapper = this.h ? () => {
-      this.h[j] = new Computation(newItems[j], null);
-      this.i && (this.i[j] = new Computation(j, null));
-      return this.N(
-        Computation.prototype.read.bind(this.h[j]),
-        this.i ? Computation.prototype.read.bind(this.i[j]) : void 0
+  runWithOwner(this.F, () => {
+    let i, j, mapper = this.j ? () => {
+      this.j[j] = new Computation(newItems[j], null);
+      this.k && (this.k[j] = new Computation(j, null));
+      return this.G(
+        Computation.prototype.read.bind(this.j[j]),
+        this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
       );
-    } : this.i ? () => {
+    } : this.k ? () => {
       const item = newItems[j];
-      this.i[j] = new Computation(j, null);
-      return this.N(() => item, Computation.prototype.read.bind(this.i[j]));
+      this.k[j] = new Computation(j, null);
+      return this.G(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
-      return this.N(() => item);
+      return this.G(() => item);
     };
     if (newLen === 0) {
-      if (this.w !== 0) {
-        this.T.dispose(false);
-        this.g = [];
-        this.s = [];
-        this.l = [];
-        this.w = 0;
-        this.h && (this.h = []);
-        this.i && (this.i = []);
+      if (this.i !== 0) {
+        this.F.dispose(false);
+        this.f = [];
+        this.w = [];
+        this.h = [];
+        this.i = 0;
+        this.j && (this.j = []);
+        this.k && (this.k = []);
       }
-      if (this.r && !this.l[0]) {
-        this.l[0] = compute(
-          this.g[0] = new Owner(),
-          this.r,
+      if (this.o && !this.h[0]) {
+        this.h[0] = compute(
+          this.f[0] = new Owner(),
+          this.o,
           null
         );
       }
-    } else if (this.w === 0) {
-      if (this.g[0])
-        this.g[0].dispose();
-      this.l = new Array(newLen);
+    } else if (this.i === 0) {
+      if (this.f[0])
+        this.f[0].dispose();
+      this.h = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.s[j] = newItems[j];
-        this.l[j] = compute(this.g[j] = new Owner(), mapper, null);
+        this.w[j] = newItems[j];
+        this.h[j] = compute(this.f[j] = new Owner(), mapper, null);
       }
-      this.w = newLen;
+      this.i = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.h ? new Array(newLen) : void 0, tempIndexes = this.i ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.s[start] === newItems[start] || this.h && compare(this.y, this.s[start], newItems[start])); start++) {
-        if (this.h)
-          this.h[start].write(newItems[start]);
+      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.w[start] === newItems[start] || this.j && compare(this.C, this.w[start], newItems[start])); start++) {
+        if (this.j)
+          this.j[start].write(newItems[start]);
       }
-      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.s[end] === newItems[newEnd] || this.h && compare(this.y, this.s[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.l[end];
-        tempNodes[newEnd] = this.g[end];
-        tempRows && (tempRows[newEnd] = this.h[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.i[end]);
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.C, this.w[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.h[end];
+        tempNodes[newEnd] = this.f[end];
+        tempRows && (tempRows[newEnd] = this.j[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.k[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.y ? this.y(item) : item;
+        key = this.C ? this.C(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.s[i];
-        key = this.y ? this.y(item) : item;
+        item = this.w[i];
+        key = this.C ? this.C(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.l[i];
-          tempNodes[j] = this.g[i];
-          tempRows && (tempRows[j] = this.h[i]);
-          tempIndexes && (tempIndexes[j] = this.i[i]);
+          temp[j] = this.h[i];
+          tempNodes[j] = this.f[i];
+          tempRows && (tempRows[j] = this.j[i]);
+          tempIndexes && (tempIndexes[j] = this.k[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.g[i].dispose();
+          this.f[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.l[j] = temp[j];
-          this.g[j] = tempNodes[j];
+          this.h[j] = temp[j];
+          this.f[j] = tempNodes[j];
           if (tempRows) {
-            this.h[j] = tempRows[j];
-            this.h[j].write(newItems[j]);
+            this.j[j] = tempRows[j];
+            this.j[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.i[j] = tempIndexes[j];
-            this.i[j].write(j);
+            this.k[j] = tempIndexes[j];
+            this.k[j].write(j);
           }
         } else {
-          this.l[j] = compute(this.g[j] = new Owner(), mapper, null);
+          this.h[j] = compute(this.f[j] = new Owner(), mapper, null);
         }
       }
-      this.l = this.l.slice(0, this.w = newLen);
-      this.s = newItems.slice(0);
+      this.h = this.h.slice(0, this.i = newLen);
+      this.w = newItems.slice(0);
+    }
+  });
+  return this.h;
+}
+function repeat(count, map, options) {
+  return updateRepeat.bind({
+    F: new Owner(),
+    i: 0,
+    Y: count,
+    G: map,
+    f: [],
+    h: [],
+    o: options?.fallback
+  });
+}
+function updateRepeat() {
+  const newLen = this.Y();
+  runWithOwner(this.F, () => {
+    if (newLen === 0) {
+      if (this.i !== 0) {
+        this.F.dispose(false);
+        this.f = [];
+        this.h = [];
+        this.i = 0;
+      }
+      if (this.o && !this.h[0]) {
+        this.h[0] = compute(
+          this.f[0] = new Owner(),
+          this.o,
+          null
+        );
+      }
+    } else {
+      if (this.i === 0 && this.f[0])
+        this.f[0].dispose();
+      for (let i = this.i; i < newLen; i++) {
+        this.h[i] = compute(
+          this.f[i] = new Owner(),
+          () => this.G(i),
+          null
+        );
+      }
+      for (let i = newLen; i < this.i; i++)
+        this.f[i].dispose();
+      this.h = this.h.slice(0, newLen);
+      this.i = newLen;
     }
   });
-  return this.l;
+  return this.h;
 }
 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, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isStale, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, untrack, unwrap };