@solidjs/signals 0.9.4 → 0.9.6

package/dist/prod.js

@@ -23,12 +23,14 @@ const REACTIVE_IN_HEAP = 1 << 3;
 const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
 const REACTIVE_ZOMBIE = 1 << 5;
 const REACTIVE_DISPOSED = 1 << 6;
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
 const EFFECT_RENDER = 1;
 const EFFECT_USER = 2;
+const EFFECT_TRACKED = 3;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
@@ -45,7 +47,7 @@ function actualInsertIntoHeap(e, t) {
     e.T = t;
     r.T = e;
   }
-  if (i > t.h) t.h = i;
+  if (i > t.O) t.O = i;
 }
 function insertIntoHeap(e, t) {
   let n = e.S;
@@ -70,10 +72,10 @@ function deleteFromHeap(e, t) {
   else {
     const n = e.R;
     const r = t.l[i];
-    const s = n ?? r;
+    const o = n ?? r;
     if (e === r) t.l[i] = n;
     else e.T.R = n;
-    s.T = e.T;
+    o.T = e.T;
   }
   e.T = e;
   e.R = undefined;
@@ -81,7 +83,7 @@ function deleteFromHeap(e, t) {
 function markHeap(e) {
   if (e._) return;
   e._ = true;
-  for (let t = 0; t <= e.h; t++) {
+  for (let t = 0; t <= e.O; t++) {
     for (let n = e.l[t]; n !== undefined; n = n.R) {
       if (n.S & REACTIVE_IN_HEAP) markNode(n);
     }
@@ -91,69 +93,77 @@ function markNode(e, t = REACTIVE_DIRTY) {
   const n = e.S;
   if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
   e.S = (n & -4) | t;
-  for (let t = e.O; t !== null; t = t.p) {
-    markNode(t.A, REACTIVE_CHECK);
+  for (let t = e.p; t !== null; t = t.I) {
+    markNode(t.h, REACTIVE_CHECK);
   }
-  if (e.N !== null) {
-    for (let t = e.N; t !== null; t = t.I) {
-      for (let e = t.O; e !== null; e = e.p) {
-        markNode(e.A, REACTIVE_CHECK);
+  if (e.A !== null) {
+    for (let t = e.A; t !== null; t = t.P) {
+      for (let e = t.p; e !== null; e = e.I) {
+        markNode(e.h, REACTIVE_CHECK);
       }
     }
   }
 }
 function runHeap(e, t) {
   e._ = false;
-  for (e.C = 0; e.C <= e.h; e.C++) {
-    let n = e.l[e.C];
+  for (e.N = 0; e.N <= e.O; e.N++) {
+    let n = e.l[e.N];
     while (n !== undefined) {
       if (n.S & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.C];
+      n = e.l[e.N];
     }
   }
-  e.h = 0;
+  e.O = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
   let n = e.o;
-  for (let t = e.D; t; t = t.P) {
+  for (let t = e.C; t; t = t.D) {
     const e = t.V;
     const i = e.m || e;
     if (i.U && i.o >= n) n = i.o + 1;
   }
   if (e.o !== n) {
     e.o = n;
-    for (let n = e.O; n !== null; n = n.p) {
-      insertIntoHeapHeight(n.A, t);
+    for (let n = e.p; n !== null; n = n.I) {
+      insertIntoHeapHeight(n.h, t);
     }
   }
 }
 const transitions = new Set();
-let optimisticRun = false;
-const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, h: 0 };
-const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, h: 0 };
+const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, N: 0, O: 0 };
+const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, N: 0, O: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let optimisticReadActive = false;
+let projectionWriteActive = false;
+function setOptimisticReadActive(e) {
+  optimisticReadActive = e;
+}
+function setProjectionWriteActive(e) {
+  projectionWriteActive = e;
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.k) Promise.resolve().then(() => queueMicrotask(flush));
+  if (!globalQueue.k) queueMicrotask(flush);
 }
 class Queue {
   i = null;
+  W = [[], []];
   G = [[], []];
-  H = [];
+  M = [];
   created = clock;
   addChild(e) {
-    this.H.push(e);
+    this.M.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.H.indexOf(e);
+    const t = this.M.indexOf(e);
     if (t >= 0) {
-      this.H.splice(t, 1);
+      this.M.splice(t, 1);
       e.i = null;
     }
   }
@@ -161,40 +171,49 @@ class Queue {
     if (this.i) return this.i.notify(e, t, n);
     return false;
   }
-  run(e) {
-    if (this.G[e - 1].length) {
-      const t = this.G[e - 1];
-      this.G[e - 1] = [];
-      runQueue(t, e);
+  $(e, t, n) {
+    if (t[e - 1].length) {
+      const n = t[e - 1];
+      t[e - 1] = [];
+      runQueue(n, e);
     }
-    for (let t = 0; t < this.H.length; t++) {
-      this.H[t].run(e);
+    for (let t = 0; t < this.M.length; t++) {
+      this.M[t][n]?.(e);
     }
   }
+  run(e) {
+    this.$(e, this.W, "run");
+  }
+  runOptimistic(e) {
+    this.$(e, this.G, "runOptimistic");
+  }
   enqueue(e, t) {
-    if (e) this.G[e - 1].push(t);
+    if (e) {
+      const n = optimisticReadActive ? this.G : this.W;
+      n[e - 1].push(t);
+    }
     schedule();
   }
   stashQueues(e) {
-    e.G[0].push(...this.G[0]);
-    e.G[1].push(...this.G[1]);
-    this.G = [[], []];
-    for (let t = 0; t < this.H.length; t++) {
-      let n = this.H[t];
-      let i = e.H[t];
+    e.W[0].push(...this.W[0]);
+    e.W[1].push(...this.W[1]);
+    this.W = [[], []];
+    for (let t = 0; t < this.M.length; t++) {
+      let n = this.M[t];
+      let i = e.M[t];
       if (!i) {
-        i = { G: [[], []], H: [] };
-        e.H[t] = i;
+        i = { W: [[], []], M: [] };
+        e.M[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.G[0].push(...e.G[0]);
-    this.G[1].push(...e.G[1]);
-    for (let t = 0; t < e.H.length; t++) {
-      const n = e.H[t];
-      let i = this.H[t];
+    this.W[0].push(...e.W[0]);
+    this.W[1].push(...e.W[1]);
+    for (let t = 0; t < e.M.length; t++) {
+      const n = e.M[t];
+      let i = this.M[t];
       if (i) i.restoreQueues(n);
     }
   }
@@ -202,39 +221,50 @@ class Queue {
 class GlobalQueue extends Queue {
   k = false;
   L = [];
-  $ = [];
-  static F;
-  static W;
+  H = [];
+  F = new Set();
+  static j;
+  static K;
+  static Y = null;
   flush() {
     if (this.k) return;
     this.k = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.F);
+      runHeap(dirtyQueue, GlobalQueue.j);
       if (activeTransition) {
-        if (!transitionComplete(activeTransition)) {
+        const e = transitionComplete(activeTransition);
+        if (!e) {
           let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.F);
+          runHeap(zombieQueue, GlobalQueue.j);
           this.L = [];
+          this.H = [];
+          this.F = new Set();
+          this.runOptimistic(EFFECT_RENDER);
+          this.runOptimistic(EFFECT_USER);
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
-          runTransitionPending(activeTransition.pendingNodes, true);
+          runTransitionPending(activeTransition.pendingNodes);
           activeTransition = null;
-          runOptimistic(e);
+          finalizePureQueue(null, true);
           return;
         }
-        this.L.push(...activeTransition.pendingNodes);
-        this.$ !== activeTransition.optimisticNodes &&
-          this.$.push(...activeTransition.optimisticNodes);
+        this.L !== activeTransition.pendingNodes && this.L.push(...activeTransition.pendingNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
+        const t = activeTransition;
         activeTransition = null;
-        runTransitionPending(this.L, false);
-      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.F);
-      runOptimistic();
+        runTransitionPending(this.L);
+        finalizePureQueue(t);
+      } else {
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.j);
+        finalizePureQueue();
+      }
       clock++;
-      scheduled = false;
+      scheduled = dirtyQueue.O >= dirtyQueue.N;
+      this.runOptimistic(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
+      this.runOptimistic(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
       this.k = false;
@@ -243,8 +273,8 @@ class GlobalQueue extends Queue {
   notify(e, t, n) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(e.j.cause)) {
-          activeTransition.asyncNodes.push(e.j.cause);
+        if (activeTransition && e.B && !activeTransition.asyncNodes.includes(e.B.cause)) {
+          activeTransition.asyncNodes.push(e.B.cause);
           schedule();
         }
       }
@@ -253,80 +283,109 @@ class GlobalQueue extends Queue {
     return false;
   }
   initTransition(e) {
-    if (activeTransition && activeTransition.time === clock) return;
+    if (e) e = currentTransition(e);
+    if (e && e === activeTransition) return;
+    if (!e && activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = e?.K ?? {
+      activeTransition = e ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        optimisticStores: new Set(),
         actions: [],
-        queueStash: { G: [[], []], H: [] },
+        queueStash: { W: [[], []], M: [] },
         done: false
       };
+    } else if (e) {
+      activeTransition.done = e;
+      e.actions.push(...activeTransition.actions);
+      transitions.delete(activeTransition);
+      activeTransition = e;
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
     for (let e = 0; e < this.L.length; e++) {
       const t = this.L[e];
-      t.K = activeTransition;
+      t.X = activeTransition;
       activeTransition.pendingNodes.push(t);
     }
-    for (let e = 0; e < this.$.length; e++) {
-      const t = this.$[e];
-      t.K = activeTransition;
+    this.L = activeTransition.pendingNodes;
+    for (let e = 0; e < this.H.length; e++) {
+      const t = this.H[e];
+      t.X = activeTransition;
       activeTransition.optimisticNodes.push(t);
     }
-    this.L = activeTransition.pendingNodes;
-    this.$ = activeTransition.optimisticNodes;
-  }
-}
-function notifySubs(e) {
-  for (let t = e.O; t !== null; t = t.p) {
-    const e = t.A.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (e.C > t.A.o) e.C = t.A.o;
-    insertIntoHeap(t.A, e);
+    this.H = activeTransition.optimisticNodes;
+    for (const e of this.F) {
+      activeTransition.optimisticStores.add(e);
+    }
+    this.F = activeTransition.optimisticStores;
   }
 }
-function runOptimistic(e = null) {
-  let t = !e;
-  const n = globalQueue.$;
-  optimisticRun = true;
-  for (let t = 0; t < n.length; t++) {
-    const i = n[t];
-    if (!e && (!i.K || i.K.done) && i.M !== NOT_PENDING) {
-      i.Y = i.M;
-      i.M = NOT_PENDING;
+function insertSubs(e, t = false) {
+  for (let n = e.p; n !== null; n = n.I) {
+    if (t) n.h.S |= REACTIVE_OPTIMISTIC_DIRTY;
+    const e = n.h;
+    if (e.q === EFFECT_TRACKED) {
+      if (!e.Z) {
+        e.Z = true;
+        e.J.enqueue(EFFECT_USER, e.ee);
+      }
+      continue;
     }
-    i.K = e;
-    notifySubs(i);
-  }
-  globalQueue.$ = [];
-  if (dirtyQueue.h >= dirtyQueue.C) {
-    t = true;
-    runHeap(dirtyQueue, GlobalQueue.F);
+    const i = n.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (i.N > n.h.o) i.N = n.h.o;
+    insertIntoHeap(n.h, i);
   }
-  optimisticRun = false;
-  t && runPending(globalQueue.L);
 }
-function runPending(e) {
-  for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    if (n.M !== NOT_PENDING) {
-      n.Y = n.M;
-      n.M = NOT_PENDING;
-      if (n.B) n.X = true;
+function finalizePureQueue(e = null, t = false) {
+  let n = !t;
+  if (dirtyQueue.O >= dirtyQueue.N) {
+    n = true;
+    runHeap(dirtyQueue, GlobalQueue.j);
+  }
+  if (n) {
+    const t = globalQueue.L;
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e];
+      if (n.te !== NOT_PENDING) {
+        n.ne = n.te;
+        n.te = NOT_PENDING;
+        if (n.q && n.q !== EFFECT_TRACKED) n.Z = true;
+      }
+      if (n.U) GlobalQueue.K(n, false, true);
+    }
+    t.length = 0;
+    const n = e ? e.optimisticNodes : globalQueue.H;
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      const i = t.te;
+      if (i !== NOT_PENDING && t.ne !== i) {
+        t.ne = i;
+        insertSubs(t, true);
+      }
+      t.te = NOT_PENDING;
+      t.X = null;
+    }
+    n.length = 0;
+    const i = e ? e.optimisticStores : globalQueue.F;
+    if (GlobalQueue.Y && i.size) {
+      for (const e of i) {
+        GlobalQueue.Y(e);
+      }
+      i.clear();
+      schedule();
     }
-    if (n.U) GlobalQueue.W(n, false, true);
   }
-  e.length = 0;
 }
-function runTransitionPending(e, t) {
-  const n = e.slice();
-  for (let e = 0; e < n.length; e++) {
-    const i = n[e];
-    i.K = activeTransition;
-    if (i.q) i.q.Z(t);
+function trackOptimisticStore(e) {
+  globalQueue.F.add(e);
+  schedule();
+}
+function runTransitionPending(e) {
+  for (let t = 0; t < e.length; t++) {
+    e[t].X = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -343,7 +402,7 @@ function transitionComplete(e) {
   if (e.actions.length) return false;
   let t = true;
   for (let n = 0; n < e.asyncNodes.length; n++) {
-    if (e.asyncNodes[n].J & STATUS_PENDING) {
+    if (e.asyncNodes[n].ie & STATUS_PENDING) {
       t = false;
       break;
     }
@@ -351,168 +410,271 @@ function transitionComplete(e) {
   t && (e.done = true);
   return t;
 }
+function currentTransition(e) {
+  while (e.done && typeof e.done === "object") e = e.done;
+  return e;
+}
 function runInTransition(e, t) {
   const n = activeTransition;
   try {
-    activeTransition = e;
+    activeTransition = currentTransition(e);
     return t();
   } finally {
     activeTransition = n;
   }
 }
+function restoreTransition(e, t) {
+  globalQueue.initTransition(e);
+  const n = t();
+  flush();
+  return n;
+}
 function action(e) {
-  return (...t) => {
-    const n = e(...t);
-    globalQueue.initTransition();
-    let i = activeTransition;
-    i.actions.push(n);
-    const step = e => {
-      let t = n.next(e);
-      if (t instanceof Promise) return t.then(process);
-      process(t);
-    };
-    const process = e => {
-      if (e.done) {
-        i.actions.splice(i.actions.indexOf(n), 1);
-        activeTransition = i;
+  return (...t) =>
+    new Promise((n, i) => {
+      const r = e(...t);
+      globalQueue.initTransition();
+      let o = activeTransition;
+      o.actions.push(r);
+      const done = (e, t) => {
+        o = currentTransition(o);
+        const s = o.actions.indexOf(r);
+        if (s >= 0) o.actions.splice(s, 1);
+        activeTransition = o;
         schedule();
-        flush();
-        return;
-      }
-      const t = e.value;
-      if (t instanceof Promise) return t.then(step);
-      runInTransition(i, () => step(t));
-    };
-    runInTransition(i, () => step());
-  };
+        t ? i(t) : n(e);
+      };
+      const step = (e, t) => {
+        let n;
+        try {
+          n = t ? r.throw(e) : r.next(e);
+        } catch (e) {
+          return done(undefined, e);
+        }
+        if (n instanceof Promise)
+          return void n.then(run, e => restoreTransition(o, () => step(e, true)));
+        run(n);
+      };
+      const run = e => {
+        if (e.done) return done(e.value);
+        if (e.value instanceof Promise)
+          return void e.value.then(
+            e => restoreTransition(o, () => step(e)),
+            e => restoreTransition(o, () => step(e, true))
+          );
+        restoreTransition(o, () => step(e.value));
+      };
+      step();
+    });
 }
-GlobalQueue.F = recompute;
-GlobalQueue.W = disposeChildren;
+GlobalQueue.j = recompute;
+GlobalQueue.K = disposeChildren;
 let tracking = false;
 let stale = false;
-let pendingValueCheck = false;
-let pendingCheck = null;
 let refreshing = false;
+let pendingCheckActive = false;
+let foundPending = false;
+let pendingReadActive = false;
 let context = null;
 function recompute(e, t = false) {
-  const n = e.B && e.K != activeTransition;
+  const n = e.q;
   if (!t) {
-    if (e.K && activeTransition !== e.K && !n) globalQueue.initTransition(e);
+    if (e.X && (!n || activeTransition) && activeTransition !== e.X)
+      globalQueue.initTransition(e.X);
     deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.K) disposeChildren(e);
+    if (e.X) disposeChildren(e);
     else {
       markDisposal(e);
-      e.ee = e.te;
-      e.ne = e.ie;
-      e.te = null;
-      e.ie = null;
+      e.re = e.oe;
+      e.se = e.ue;
+      e.oe = null;
+      e.ue = null;
     }
   }
-  const i = context;
+  const i = !!(e.S & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = e.le && e.te !== NOT_PENDING;
+  const o = context;
   context = e;
-  e.re = null;
+  e.ce = null;
   e.S = REACTIVE_RECOMPUTING_DEPS;
-  e.se = clock;
-  let r = e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M;
-  let s = e.o;
-  let o = e.J;
-  let u = e.j;
+  e.ae = clock;
+  let s = e.te === NOT_PENDING ? e.ne : e.te;
+  let u = e.o;
   let l = tracking;
-  setStatusFlags(e, STATUS_NONE | (o & STATUS_UNINITIALIZED));
+  let c = optimisticReadActive;
   tracking = true;
+  if (i) setOptimisticReadActive(true);
   try {
-    r = handleAsync(e, e.U(r));
-    e.J &= ~STATUS_UNINITIALIZED;
+    s = handleAsync(e, e.U(s));
+    clearStatus(e);
   } catch (t) {
     if (t instanceof NotReadyError) {
       if (t.cause !== e) link(t.cause, e);
-      setStatusFlags(e, (o & ~STATUS_ERROR) | STATUS_PENDING, t);
-    } else setStatusFlags(e, STATUS_ERROR, t);
+      notifyStatus(e, STATUS_PENDING, t);
+    } else notifyStatus(e, STATUS_ERROR, t);
   } finally {
     tracking = l;
+    e.S = REACTIVE_NONE;
+    context = o;
   }
-  e.S = REACTIVE_NONE;
-  context = i;
-  if (!(e.J & STATUS_PENDING)) {
-    const t = e.re;
-    let n = t !== null ? t.P : e.D;
-    if (n !== null) {
+  if (!e.B) {
+    const o = e.ce;
+    let l = o !== null ? o.D : e.C;
+    if (l !== null) {
       do {
-        n = unlinkSubs(n);
-      } while (n !== null);
-      if (t !== null) t.P = null;
-      else e.D = null;
+        l = unlinkSubs(l);
+      } while (l !== null);
+      if (o !== null) o.D = null;
+      else e.C = null;
     }
-  }
-  const c = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) || n ? e.Y : e.M, r);
-  const a = e.J !== o || e.j !== u;
-  e.le?.(a, o);
-  if (c || a) {
+    const c = !e.fe || !e.fe(e.te === NOT_PENDING ? e.ne : e.te, s);
     if (c) {
-      if (t || e.oe || n) e.Y = r;
-      else e.M = r;
-      if (e.ce) setSignal(e.ce, r);
-    }
-    (!e.oe || optimisticRun) && notifySubs(e);
-  } else if (e.o != s) {
-    for (let t = e.O; t !== null; t = t.p) {
-      insertIntoHeapHeight(t.A, t.A.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      if (t || (n && activeTransition !== e.X) || i) e.ne = s;
+      else e.te = s;
+      insertSubs(e, i || r);
+    } else if (e.o != u) {
+      for (let t = e.p; t !== null; t = t.I) {
+        insertIntoHeapHeight(t.h, t.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
     }
   }
-  e.oe && !optimisticRun && globalQueue.$.push(e);
-  (!t || e.J & STATUS_PENDING) && !e.K && globalQueue.L.push(e);
-  e.K && n && runInTransition(e.K, () => recompute(e));
+  setOptimisticReadActive(c);
+  (!t || e.ie & STATUS_PENDING) && !e.X && globalQueue.L.push(e);
+  e.X && n && activeTransition !== e.X && runInTransition(e.X, () => recompute(e));
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
-  const r = i && t instanceof Promise;
-  const s = i && untrack(() => t[Symbol.asyncIterator]);
-  if (!r && !s) {
-    e.ae = null;
+  const r = i && untrack(() => t[Symbol.asyncIterator]);
+  const o = !r && i && untrack(() => typeof t.then === "function");
+  if (!o && !r) {
+    e.Ee = null;
     return t;
   }
-  e.ae = t;
-  if (r) {
-    t.then(i => {
-      if (e.ae !== t) return;
-      globalQueue.initTransition(e);
-      n?.(i) ?? setSignal(e, () => i);
-      flush();
-    }).catch(n => {
-      if (e.ae !== t) return;
-      globalQueue.initTransition(e);
-      setStatusFlags(e, STATUS_ERROR, n);
-      e.se = clock;
-      notifySubs(e);
+  e.Ee = t;
+  let s;
+  const handleError = n => {
+    if (e.Ee !== t) return;
+    globalQueue.initTransition(e.X);
+    if (n instanceof NotReadyError) {
+      if (n.cause !== e) link(n.cause, e);
+      notifyStatus(e, STATUS_PENDING, n);
+    } else notifyStatus(e, STATUS_ERROR, n);
+    e.ae = clock;
+  };
+  const asyncWrite = (i, r) => {
+    if (e.Ee !== t) return;
+    globalQueue.initTransition(e.X);
+    clearStatus(e);
+    if (n) n(i);
+    else if (e.le) {
+      const t = e.te !== NOT_PENDING;
+      if (e.U) e.te = i;
+      if (!t) {
+        e.ne = i;
+        insertSubs(e);
+      }
+      e.ae = clock;
       schedule();
-      flush();
-    });
+    } else setSignal(e, () => i);
+    flush();
+    r?.();
+  };
+  if (o) {
+    let n = false,
+      i = true;
+    t.then(
+      e => {
+        if (i) {
+          s = e;
+          n = true;
+        } else asyncWrite(e);
+      },
+      e => {
+        if (!i) handleError(e);
+      }
+    );
+    i = false;
+    if (!n) {
+      globalQueue.initTransition(e.X);
+      throw new NotReadyError(context);
+    }
+  }
+  if (r) {
+    const n = t[Symbol.asyncIterator]();
+    let i = false;
+    const iterate = () => {
+      let e,
+        t = false,
+        r = true;
+      n.next().then(
+        n => {
+          if (r) {
+            e = n;
+            t = true;
+          } else if (!n.done) asyncWrite(n.value, iterate);
+        },
+        e => {
+          if (!r) handleError(e);
+        }
+      );
+      r = false;
+      if (t && !e.done) {
+        s = e.value;
+        i = true;
+        return iterate();
+      }
+      return t && e.done;
+    };
+    const r = iterate();
+    if (!i && !r) {
+      globalQueue.initTransition(e.X);
+      throw new NotReadyError(context);
+    }
+  }
+  return s;
+}
+function clearStatus(e) {
+  e.ie = STATUS_NONE;
+  e.B = null;
+  updatePendingSignal(e);
+  if (e.Te) {
+    e.Te();
   } else {
-    (async () => {
-      try {
-        for await (let i of t) {
-          if (e.ae !== t) return;
-          globalQueue.initTransition(e);
-          n?.(i) ?? setSignal(e, () => i);
-          flush();
+    if (!e.X) {
+      for (let t = e.p; t !== null; t = t.I) {
+        if (t.h.ie & STATUS_PENDING) {
+          insertIntoHeap(t.h, t.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
         }
-      } catch (n) {
-        if (e.ae !== t) return;
-        globalQueue.initTransition(e);
-        setStatusFlags(e, STATUS_ERROR, n);
-        e.se = clock;
-        notifySubs(e);
-        schedule();
-        flush();
       }
-    })();
+    }
+    schedule();
+  }
+}
+function notifyStatus(e, t, n) {
+  e.ie = t | (e.ie & STATUS_UNINITIALIZED);
+  e.B = n;
+  updatePendingSignal(e);
+  if (e.Te) return e.Te();
+  for (let i = e.p; i !== null; i = i.I) {
+    i.h.ae = clock;
+    if (i.h.B !== n) {
+      !i.h.X && globalQueue.L.push(i.h);
+      notifyStatus(i.h, t, n);
+    }
+  }
+  for (let i = e.A; i !== null; i = i.P) {
+    for (let e = i.p; e !== null; e = e.I) {
+      e.h.ae = clock;
+      if (e.h.B !== n) {
+        !e.h.X && globalQueue.L.push(e.h);
+        notifyStatus(e.h, t, n);
+      }
+    }
   }
-  globalQueue.initTransition(e);
-  throw new NotReadyError(context);
 }
 function updateIfNecessary(e) {
   if (e.S & REACTIVE_CHECK) {
-    for (let t = e.D; t; t = t.P) {
+    for (let t = e.C; t; t = t.D) {
       const n = t.V;
       const i = n.m || n;
       if (i.U) {
@@ -530,68 +692,64 @@ function updateIfNecessary(e) {
 }
 function unlinkSubs(e) {
   const t = e.V;
-  const n = e.P;
-  const i = e.p;
-  const r = e.fe;
-  if (i !== null) i.fe = r;
-  else t.Ee = r;
-  if (r !== null) r.p = i;
+  const n = e.D;
+  const i = e.I;
+  const r = e.Re;
+  if (i !== null) i.Re = r;
+  else t.de = r;
+  if (r !== null) r.I = i;
   else {
-    t.O = i;
+    t.p = i;
     if (i === null) {
-      t.de?.();
-      t.U && !t.Te && unobserved(t);
+      t.Oe?.();
+      t.U && !t.Se && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
   deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let t = e.D;
+  let t = e.C;
   while (t !== null) {
     t = unlinkSubs(t);
   }
-  e.D = null;
+  e.C = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.re;
+  const n = t.ce;
   if (n !== null && n.V === e) return;
   let i = null;
   const r = t.S & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
-    i = n !== null ? n.P : t.D;
+    i = n !== null ? n.D : t.C;
     if (i !== null && i.V === e) {
-      t.re = i;
+      t.ce = i;
       return;
     }
   }
-  const s = e.Ee;
-  if (s !== null && s.A === t && (!r || isValidLink(s, t))) return;
-  const o = (t.re = e.Ee = { V: e, A: t, P: i, fe: s, p: null });
-  if (n !== null) n.P = o;
-  else t.D = o;
-  if (s !== null) s.p = o;
-  else e.O = o;
+  const o = e.de;
+  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
+  const s = (t.ce = e.de = { V: e, h: t, D: i, Re: o, I: null });
+  if (n !== null) n.D = s;
+  else t.C = s;
+  if (o !== null) o.I = s;
+  else e.p = s;
 }
 function isValidLink(e, t) {
-  const n = t.re;
+  const n = t.ce;
   if (n !== null) {
-    let i = t.D;
+    let i = t.C;
     do {
       if (i === e) return true;
       if (i === n) break;
-      i = i.P;
+      i = i.D;
     } while (i !== null);
   }
   return false;
 }
-function setStatusFlags(e, t, n = null) {
-  e.J = t;
-  e.j = n;
-}
 function markDisposal(e) {
-  let t = e.ie;
+  let t = e.ue;
   while (t) {
     t.S |= REACTIVE_ZOMBIE;
     if (t.S & REACTIVE_IN_HEAP) {
@@ -599,47 +757,47 @@ function markDisposal(e) {
       insertIntoHeap(t, zombieQueue);
     }
     markDisposal(t);
-    t = t.Re;
+    t = t._e;
   }
 }
 function dispose(e) {
-  let t = e.D || null;
+  let t = e.C || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.D = null;
-  e.re = null;
+  e.C = null;
+  e.ce = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
   if (e.S & REACTIVE_DISPOSED) return;
   if (t) e.S = REACTIVE_DISPOSED;
-  let i = n ? e.ne : e.ie;
+  let i = n ? e.se : e.ue;
   while (i) {
-    const e = i.Re;
-    if (i.D) {
+    const e = i._e;
+    if (i.C) {
       const e = i;
       deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.D;
+      let t = e.C;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.D = null;
-      e.re = null;
+      e.C = null;
+      e.ce = null;
     }
     disposeChildren(i, true);
     i = e;
   }
   if (n) {
-    e.ne = null;
+    e.se = null;
   } else {
-    e.ie = null;
-    e.Re = null;
+    e.ue = null;
+    e._e = null;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.ee : e.te;
+  let n = t ? e.re : e.oe;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -649,10 +807,10 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.ee = null) : (e.te = null);
+  t ? (e.re = null) : (e.oe = null);
 }
 function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.he++);
+  if (e.id != null) return formatId(e.id, e.pe++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(e, t) {
@@ -663,45 +821,44 @@ function formatId(e, t) {
 function computed(e, t, n) {
   const i = {
     id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    ue: n?.equals != null ? n.equals : isEqual,
-    Se: !!n?.pureWrite,
-    de: n?.unobserved,
-    te: null,
-    _e: context?._e ?? globalQueue,
-    Oe: context?.Oe ?? defaultContext,
-    he: 0,
+    fe: n?.equals != null ? n.equals : isEqual,
+    Ie: !!n?.pureWrite,
+    Oe: n?.unobserved,
+    oe: null,
+    J: context?.J ?? globalQueue,
+    he: context?.he ?? defaultContext,
+    pe: 0,
     U: e,
-    Y: t,
+    ne: t,
     o: 0,
-    N: null,
+    A: null,
     R: undefined,
     T: null,
-    D: null,
-    re: null,
-    O: null,
-    Ee: null,
+    C: null,
+    ce: null,
+    p: null,
+    de: null,
     i: context,
-    Re: null,
-    ie: null,
+    _e: null,
+    ue: null,
     S: REACTIVE_NONE,
-    J: STATUS_UNINITIALIZED,
-    se: clock,
-    M: NOT_PENDING,
-    ee: null,
-    ne: null,
-    ae: null,
-    K: null
+    ie: STATUS_UNINITIALIZED,
+    ae: clock,
+    te: NOT_PENDING,
+    re: null,
+    se: null,
+    Ee: null,
+    X: null
   };
-  if (n?.pe) Object.assign(i, n.pe);
   i.T = i;
   const r = context?.t ? context.u : context;
   if (context) {
-    const e = context.ie;
+    const e = context.ue;
     if (e === null) {
-      context.ie = i;
+      context.ue = i;
     } else {
-      i.Re = e;
-      context.ie = i;
+      i._e = e;
+      context.ue = i;
     }
   }
   if (r) i.o = r.o + 1;
@@ -710,22 +867,54 @@ function computed(e, t, n) {
 }
 function signal(e, t, n = null) {
   const i = {
-    id: t?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    ue: t?.equals != null ? t.equals : isEqual,
-    Se: !!t?.pureWrite,
-    de: t?.unobserved,
-    Y: e,
-    O: null,
-    Ee: null,
-    J: STATUS_NONE,
-    se: clock,
+    fe: t?.equals != null ? t.equals : isEqual,
+    Ie: !!t?.pureWrite,
+    Oe: t?.unobserved,
+    ne: e,
+    p: null,
+    de: null,
+    ae: clock,
     m: n,
-    I: n?.N || null,
-    M: NOT_PENDING
+    P: n?.A || null,
+    te: NOT_PENDING
   };
-  n && (n.N = i);
+  n && (n.A = i);
   return i;
 }
+function optimisticSignal(e, t) {
+  const n = signal(e, t);
+  n.le = true;
+  return n;
+}
+function optimisticComputed(e, t, n) {
+  const i = computed(e, t, n);
+  i.le = true;
+  return i;
+}
+function getPendingSignal(e) {
+  if (!e.Ae) {
+    e.Ae = optimisticSignal(false, { pureWrite: true });
+    if (computePendingState(e)) setSignal(e.Ae, true);
+  }
+  return e.Ae;
+}
+function computePendingState(e) {
+  if (e.te !== NOT_PENDING) return true;
+  const t = e;
+  return !!(t.ie & STATUS_PENDING && !(t.ie & STATUS_UNINITIALIZED));
+}
+function getPendingValueComputed(e) {
+  if (!e.ge) {
+    const t = pendingReadActive;
+    pendingReadActive = false;
+    e.ge = optimisticComputed(() => read(e));
+    pendingReadActive = t;
+  }
+  return e.ge;
+}
+function updatePendingSignal(e) {
+  if (e.Ae) setSignal(e.Ae, computePendingState(e));
+}
 function isEqual(e, t) {
   return e === t;
 }
@@ -739,16 +928,36 @@ function untrack(e) {
   }
 }
 function read(e) {
+  if (pendingCheckActive) {
+    const t = e.m || e;
+    const n = getPendingSignal(t);
+    const i = pendingCheckActive;
+    pendingCheckActive = false;
+    if (read(n)) {
+      foundPending = true;
+    }
+    pendingCheckActive = i;
+    return e.ne;
+  }
+  if (pendingReadActive) {
+    const t = getPendingValueComputed(e);
+    const n = pendingReadActive;
+    pendingReadActive = false;
+    const i = read(t);
+    pendingReadActive = n;
+    if (t.ie & STATUS_PENDING) return e.ne;
+    return i;
+  }
   let t = context;
   if (t?.t) t = t.u;
   if (refreshing && e.U) recompute(e);
-  if (t && tracking && !pendingCheck && !pendingValueCheck) {
+  if (t && tracking) {
     if (e.U && e.S & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
     const n = e.m || e;
     if (n.U) {
       const i = e.S & REACTIVE_ZOMBIE;
-      if (n.o >= (i ? zombieQueue.C : dirtyQueue.C)) {
+      if (n.o >= (i ? zombieQueue.N : dirtyQueue.N)) {
         markNode(t);
         markHeap(i ? zombieQueue : dirtyQueue);
         updateIfNecessary(n);
@@ -759,72 +968,60 @@ function read(e) {
       }
     }
   }
-  if (pendingValueCheck) {
-    if (!e.ce) {
-      e.ce = signal(e.Y);
-      e.ce.oe = true;
-    }
-    pendingValueCheck = false;
-    try {
-      return read(e.ce);
-    } finally {
-      pendingValueCheck = true;
-    }
-  }
   const n = e.m || e;
-  if (pendingCheck) {
-    if (!n.q) {
-      n.q = signal(false);
-      n.q.oe = true;
-      n.q.Z = e => setSignal(n.q, e);
-    }
-    const e = pendingCheck;
-    pendingCheck = null;
-    e.Y = read(n.q) || e.Y;
-    pendingCheck = e;
-  }
-  if (!pendingCheck && n.J & STATUS_PENDING) {
-    if ((t && !stale) || n.J & STATUS_UNINITIALIZED || e.m) throw n.j;
-    else if (t && stale) {
-      setStatusFlags(t, t.J | STATUS_PENDING, n.j);
-    }
-  }
-  if (e.J & STATUS_ERROR) {
-    if (e.se < clock) {
+  if (
+    t &&
+    !optimisticReadActive &&
+    n.ie & STATUS_PENDING &&
+    !(stale && n.X && activeTransition !== n.X)
+  )
+    throw n.B;
+  if (e.U && e.ie & STATUS_ERROR) {
+    if (e.ae < clock) {
       recompute(e, true);
       return read(e);
-    } else {
-      throw e.j;
-    }
+    } else throw e.B;
   }
   return !t ||
-    e.oe ||
-    e.M === NOT_PENDING ||
-    (stale && !pendingCheck && (t.oe || (e.K && activeTransition !== e.K)))
-    ? e.Y
-    : e.M;
+    optimisticReadActive ||
+    e.te === NOT_PENDING ||
+    (stale && e.X && activeTransition !== e.X)
+    ? e.ne
+    : e.te;
 }
 function setSignal(e, t) {
-  if (typeof t === "function") {
-    t = t(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M);
-  }
-  const n = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M, t);
-  if (!n && !e.J) return t;
+  if (e.X && activeTransition !== e.X) globalQueue.initTransition(e.X);
+  const n = e.le && !projectionWriteActive;
+  const i = n ? e.ne : e.te === NOT_PENDING ? e.ne : e.te;
+  if (typeof t === "function") t = t(i);
+  const r = !e.fe || !e.fe(i, t);
+  if (!r) return t;
   if (n) {
-    if (e.oe) e.Y = t;
-    else {
-      if (e.M === NOT_PENDING) globalQueue.L.push(e);
-      e.M = t;
+    const n = e.te === NOT_PENDING;
+    if (e.X && !n) {
+      globalQueue.initTransition(e.X);
     }
-    if (e.ce) setSignal(e.ce, t);
+    if (n) {
+      e.te = e.ne;
+      globalQueue.H.push(e);
+    }
+    e.ne = t;
+  } else {
+    if (e.te === NOT_PENDING) globalQueue.L.push(e);
+    e.te = t;
+  }
+  updatePendingSignal(e);
+  if (e.ge) {
+    setSignal(e.ge, t);
   }
-  setStatusFlags(e, STATUS_NONE);
-  e.se = clock;
-  e.oe && !optimisticRun ? globalQueue.$.push(e) : notifySubs(e);
+  e.ae = clock;
+  insertSubs(e, n);
   schedule();
   return t;
 }
+const PENDING_OWNER = {};
 function getObserver() {
+  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
   return tracking ? context : null;
 }
 function getOwner() {
@@ -832,42 +1029,37 @@ function getOwner() {
 }
 function onCleanup(e) {
   if (!context) return e;
-  const t = context;
-  if (!t.te) {
-    t.te = e;
-  } else if (Array.isArray(t.te)) {
-    t.te.push(e);
-  } else {
-    t.te = [t.te, e];
-  }
+  if (!context.oe) context.oe = e;
+  else if (Array.isArray(context.oe)) context.oe.push(e);
+  else context.oe = [context.oe, e];
   return e;
 }
 function createOwner(e) {
   const t = context;
   const n = {
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
     t: true,
     u: t?.t ? t.u : t,
-    ie: null,
-    Re: null,
-    te: null,
-    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
-    _e: t?._e ?? globalQueue,
-    Oe: t?.Oe || defaultContext,
-    he: 0,
-    ee: null,
-    ne: null,
+    ue: null,
+    _e: null,
+    oe: null,
+    J: t?.J ?? globalQueue,
+    he: t?.he || defaultContext,
+    pe: 0,
+    re: null,
+    se: null,
     i: t,
     dispose(e = true) {
       disposeChildren(n, e);
     }
   };
   if (t) {
-    const e = t.ie;
+    const e = t.ue;
     if (e === null) {
-      t.ie = n;
+      t.ue = n;
     } else {
-      n.Re = e;
-      t.ie = n;
+      n._e = e;
+      t.ue = n;
     }
   }
   return n;
@@ -878,11 +1070,14 @@ function createRoot(e, t) {
 }
 function runWithOwner(e, t) {
   const n = context;
+  const i = tracking;
   context = e;
+  tracking = false;
   try {
     return t();
   } finally {
     context = n;
+    tracking = i;
   }
 }
 function staleValues(e, t = true) {
@@ -895,25 +1090,25 @@ function staleValues(e, t = true) {
   }
 }
 function pending(e) {
-  const t = pendingValueCheck;
-  pendingValueCheck = true;
+  const t = pendingReadActive;
+  pendingReadActive = true;
   try {
-    return staleValues(e, false);
+    return e();
   } finally {
-    pendingValueCheck = t;
+    pendingReadActive = t;
   }
 }
 function isPending(e) {
-  const t = pendingCheck;
-  pendingCheck = { Y: false };
+  const t = pendingCheckActive;
+  const n = foundPending;
+  pendingCheckActive = true;
+  foundPending = false;
   try {
-    staleValues(e);
-    return pendingCheck.Y;
-  } catch (e) {
-    if (!(e instanceof NotReadyError)) return false;
-    throw e;
+    e();
+    return foundPending;
   } finally {
-    pendingCheck = t;
+    pendingCheckActive = t;
+    foundPending = n;
   }
 }
 function refresh(e) {
@@ -929,7 +1124,6 @@ function refresh(e) {
     refreshing = t;
     if (!t) {
       schedule();
-      flush();
     }
   }
 }
@@ -943,7 +1137,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.Oe[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.he[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -953,73 +1147,92 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.Oe = { ...n.Oe, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.he = { ...n.he, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.Oe[e.id]);
+  return !isUndefined(t?.he[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
 }
 function effect(e, t, n, i, r) {
-  let s = false;
-  const o = computed(e, i, {
+  let o = false;
+  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
     ...r,
-    pe: {
-      X: true,
-      Ae: i,
-      Ne: t,
-      ge: n,
-      Ie: undefined,
-      B: r?.render ? EFFECT_RENDER : EFFECT_USER,
-      le(e, t) {
-        if (s) {
-          const n = this.J && this.J === t && e;
-          this.X = !(this.J & STATUS_ERROR) && !(this.J & STATUS_PENDING & ~t) && !n;
-          if (this.X) this._e.enqueue(this.B, runEffect.bind(this));
-        }
-        if (this.J & STATUS_ERROR) {
-          let e = this.j;
-          this._e.notify(this, STATUS_PENDING, 0);
-          if (this.B === EFFECT_USER) {
-            try {
-              return this.ge
-                ? this.ge(e, () => {
-                    this.Ie?.();
-                    this.Ie = undefined;
-                  })
-                : console.error(e);
-            } catch (t) {
-              e = t;
-            }
-          }
-          if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-        } else if (this.B === EFFECT_RENDER) {
-          this._e.notify(this, STATUS_PENDING | STATUS_ERROR, this.J);
+    equals: () => {
+      s.Z = !s.B;
+      if (o) s.J.enqueue(s.q, runEffect.bind(s));
+      return false;
+    },
+    lazy: true
+  });
+  s.Pe = i;
+  s.Ne = t;
+  s.Ce = n;
+  s.ye = undefined;
+  s.q = r?.render ? EFFECT_RENDER : EFFECT_USER;
+  s.Te = () => {
+    if (s.ie & STATUS_ERROR) {
+      let e = s.B;
+      s.J.notify(s, STATUS_PENDING, 0);
+      if (s.q === EFFECT_USER) {
+        try {
+          return s.Ce
+            ? s.Ce(e, () => {
+                s.ye?.();
+                s.ye = undefined;
+              })
+            : console.error(e);
+        } catch (t) {
+          e = t;
         }
       }
-    }
-  });
-  s = true;
-  if (o.B === EFFECT_RENDER) o.U = t => staleValues(() => e(t));
-  !r?.defer &&
-    !(o.J & (STATUS_ERROR | STATUS_PENDING)) &&
-    (o.B === EFFECT_USER ? o._e.enqueue(o.B, runEffect.bind(o)) : runEffect.call(o));
-  onCleanup(() => o.Ie?.());
+      if (!s.J.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
+    } else if (s.q === EFFECT_RENDER) s.J.notify(s, STATUS_PENDING | STATUS_ERROR, s.ie);
+  };
+  recompute(s, true);
+  !r?.defer && (s.q === EFFECT_USER ? s.J.enqueue(s.q, runEffect.bind(s)) : runEffect.call(s));
+  o = true;
+  onCleanup(() => s.ye?.());
 }
 function runEffect() {
-  if (!this.X || this.S & REACTIVE_DISPOSED) return;
-  this.Ie?.();
-  this.Ie = undefined;
+  if (!this.Z || this.S & REACTIVE_DISPOSED) return;
+  this.ye?.();
+  this.ye = undefined;
   try {
-    this.Ie = this.Ne(this.Y, this.Ae);
+    this.ye = this.Ne(this.ne, this.Pe);
   } catch (e) {
-    if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+    if (!this.J.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.Ae = this.Y;
-    this.X = false;
+    this.Pe = this.ne;
+    this.Z = false;
   }
 }
+function trackedEffect(e, t) {
+  const run = () => {
+    if (!n.Z || n.S & REACTIVE_DISPOSED) return;
+    n.Z = false;
+    recompute(n);
+  };
+  const n = computed(
+    () => {
+      try {
+        n.ye?.();
+        n.ye = undefined;
+        n.ye = staleValues(e) || undefined;
+      } finally {
+      }
+    },
+    undefined,
+    { ...t, lazy: true, pureWrite: true }
+  );
+  n.ye = undefined;
+  n.Z = true;
+  n.q = EFFECT_TRACKED;
+  n.ee = run;
+  n.J.enqueue(EFFECT_USER, run);
+  onCleanup(() => n.ye?.());
+}
 function createSignal(e, t, n) {
   if (typeof e === "function") {
     const i = computed(e, t, n);
@@ -1033,12 +1246,14 @@ function createMemo(e, t, n) {
   return read.bind(null, i);
 }
 function createEffect(e, t, n, i) {
-  void effect(e, t.effect || t, t.error, n, i);
+  effect(e, t.effect || t, t.error, n, i);
 }
 function createRenderEffect(e, t, n, i) {
-  void effect(e, t, undefined, n, { render: true, ...i });
+  effect(e, t, undefined, n, { render: true, ...i });
+}
+function createTrackedEffect(e, t) {
+  trackedEffect(e, t);
 }
-function createTrackedEffect(e, t) {}
 function createReaction(e, t) {
   let n = undefined;
   onCleanup(() => n?.());
@@ -1075,39 +1290,16 @@ function resolve(e) {
   });
 }
 function createOptimistic(e, t, n) {
-  if (typeof e === "function") {
-    const i = computed(
-      t => {
-        const n = getOwner();
-        const i = e(t);
-        if (n.J & STATUS_UNINITIALIZED) return i;
-        n.M = i;
-        return t;
-      },
-      t,
-      n
-    );
-    i.oe = true;
-    return [read.bind(null, i), setSignal.bind(null, i)];
-  }
-  const i = signal(e, t);
-  i.oe = true;
-  return [
-    read.bind(null, i),
-    t => {
-      i.M = e;
-      return setSignal(i, t);
-    }
-  ];
+  const i = typeof e === "function" ? optimisticComputed(e, t, n) : optimisticSignal(e, t);
+  return [read.bind(null, i), setSignal.bind(null, i)];
 }
 function onSettled(e) {
-  let t;
-  const n = getOwner();
-  if (n) onCleanup(() => t?.());
-  globalQueue.enqueue(EFFECT_USER, () => {
-    t = e();
-    !n && t?.();
-  });
+  getOwner()
+    ? createTrackedEffect(() => untrack(e))
+    : globalQueue.enqueue(EFFECT_USER, () => {
+        const t = e();
+        t?.();
+      });
 }
 function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
@@ -1123,67 +1315,67 @@ function getAllKeys(e, t, n) {
 function applyState(e, t, n, i) {
   const r = t?.[$TARGET];
   if (!r) return;
-  const s = r[STORE_VALUE];
-  const o = r[STORE_OVERRIDE];
+  const o = r[STORE_VALUE];
+  const s = r[STORE_OVERRIDE];
   let u = r[STORE_NODE];
-  if (e === s && !o) return;
+  if (e === o && !s) return;
   (r[STORE_LOOKUP] || storeLookup).set(e, r[$PROXY]);
   r[STORE_VALUE] = e;
   r[STORE_OVERRIDE] = undefined;
-  if (Array.isArray(s)) {
+  if (Array.isArray(o)) {
     let t = false;
-    const l = getOverrideValue(s, o, u, "length");
+    const l = getOverrideValue(o, s, u, "length");
     if (e.length && l && e[0] && n(e[0]) != null) {
-      let c, a, f, E, d, T, R, h;
+      let c, a, f, E, T, R, d, O;
       for (
         f = 0, E = Math.min(l, e.length);
-        f < E && ((T = getOverrideValue(s, o, u, f)) === e[f] || (T && e[f] && n(T) === n(e[f])));
+        f < E && ((R = getOverrideValue(o, s, u, f)) === e[f] || (R && e[f] && n(R) === n(e[f])));
         f++
       ) {
-        applyState(e[f], wrap(T, r), n, i);
+        applyState(e[f], wrap(R, r), n, i);
       }
       const S = new Array(e.length),
         _ = new Map();
       for (
-        E = l - 1, d = e.length - 1;
+        E = l - 1, T = e.length - 1;
         E >= f &&
-        d >= f &&
-        ((T = getOverrideValue(s, o, u, E)) === e[d] || (T && e[d] && n(T) === n(e[d])));
-        E--, d--
+        T >= f &&
+        ((R = getOverrideValue(o, s, u, E)) === e[T] || (R && e[T] && n(R) === n(e[T])));
+        E--, T--
       ) {
-        S[d] = T;
+        S[T] = R;
       }
-      if (f > d || f > E) {
-        for (a = f; a <= d; a++) {
+      if (f > T || f > E) {
+        for (a = f; a <= T; a++) {
           t = true;
           r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
         }
         for (; a < e.length; a++) {
           t = true;
-          const s = wrap(S[a], r);
-          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], s);
-          applyState(e[a], s, n, i);
+          const o = wrap(S[a], r);
+          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], o);
+          applyState(e[a], o, n, i);
         }
         t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
         l !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
         return;
       }
-      R = new Array(d + 1);
-      for (a = d; a >= f; a--) {
-        T = e[a];
-        h = T ? n(T) : T;
-        c = _.get(h);
-        R[a] = c === undefined ? -1 : c;
-        _.set(h, a);
+      d = new Array(T + 1);
+      for (a = T; a >= f; a--) {
+        R = e[a];
+        O = R ? n(R) : R;
+        c = _.get(O);
+        d[a] = c === undefined ? -1 : c;
+        _.set(O, a);
       }
       for (c = f; c <= E; c++) {
-        T = getOverrideValue(s, o, u, c);
-        h = T ? n(T) : T;
-        a = _.get(h);
+        R = getOverrideValue(o, s, u, c);
+        O = R ? n(R) : R;
+        a = _.get(O);
         if (a !== undefined && a !== -1) {
-          S[a] = T;
-          a = R[a];
-          _.set(h, a);
+          S[a] = R;
+          a = d[a];
+          _.set(O, a);
         }
       }
       for (a = f; a < e.length; a++) {
@@ -1196,7 +1388,7 @@ function applyState(e, t, n, i) {
       if (f < e.length) t = true;
     } else if (e.length) {
       for (let t = 0, l = e.length; t < l; t++) {
-        const l = getOverrideValue(s, o, u, t);
+        const l = getOverrideValue(o, s, u, t);
         isWrappable(l)
           ? applyState(e[t], wrap(l, r), n, i)
           : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
@@ -1211,17 +1403,17 @@ function applyState(e, t, n, i) {
   }
   if (u) {
     const t = u[$TRACK];
-    const l = t || i ? getAllKeys(s, o, e) : Object.keys(u);
+    const l = t || i ? getAllKeys(o, s, e) : Object.keys(u);
     for (let c = 0, a = l.length; c < a; c++) {
       const a = l[c];
       const f = u[a];
-      const E = unwrap(getOverrideValue(s, o, u, a));
-      let d = unwrap(e[a]);
-      if (E === d) continue;
-      if (!E || !isWrappable(E) || (n(E) != null && n(E) !== n(d))) {
+      const E = unwrap(getOverrideValue(o, s, u, a));
+      let T = unwrap(e[a]);
+      if (E === T) continue;
+      if (!E || !isWrappable(E) || (n(E) != null && n(E) !== n(T))) {
         t && setSignal(t, void 0);
-        f && setSignal(f, isWrappable(d) ? wrap(d, r) : d);
-      } else applyState(d, wrap(E, r), n, i);
+        f && setSignal(f, isWrappable(T) ? wrap(T, r) : T);
+      } else applyState(T, wrap(E, r), n, i);
     }
   }
   if ((u = r[STORE_HAS])) {
@@ -1236,8 +1428,8 @@ function reconcile(e, t, n = false) {
   return i => {
     if (i == null) throw new Error("Cannot reconcile null or undefined state");
     const r = typeof t === "string" ? e => e[t] : t;
-    const s = r(i);
-    if (s !== undefined && r(e) !== r(i))
+    const o = r(i);
+    if (o !== undefined && r(e) !== r(i))
       throw new Error("Cannot reconcile states with different identity");
     applyState(e, i, r, n);
   };
@@ -1262,19 +1454,19 @@ function createProjectionInternal(e, t = {}, n) {
     r.set(e, t);
     return t;
   };
-  const s = wrapProjection(t);
+  const o = wrapProjection(t);
   i = computed(() => {
     const t = getOwner();
-    storeSetter(new Proxy(s, writeTraps), i => {
+    storeSetter(new Proxy(o, writeTraps), i => {
       const r = handleAsync(t, e(i), e => {
-        e !== s && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        e !== i && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id", n?.all));
         setSignal(t, undefined);
       });
-      r !== s && r !== undefined && reconcile(r, n?.key || "id", n?.all)(s);
+      r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(o);
     });
   });
-  i.Te = true;
-  return { store: s, node: i };
+  i.Se = true;
+  return { store: o, node: i };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
@@ -1283,28 +1475,34 @@ const writeTraps = {
   get(e, t) {
     let n;
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       n = e[t];
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return typeof n === "object" && n !== null ? new Proxy(n, writeTraps) : n;
   },
   set(e, t, n) {
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       e[t] = n;
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return true;
   },
   deleteProperty(e, t) {
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       delete e[t];
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return true;
   }
@@ -1317,11 +1515,13 @@ const $TRACK = Symbol(0),
 const PARENTS = new WeakMap();
 const STORE_VALUE = "v",
   STORE_OVERRIDE = "o",
+  STORE_OPTIMISTIC_OVERRIDE = "x",
   STORE_NODE = "n",
   STORE_HAS = "h",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
-  STORE_FIREWALL = "f";
+  STORE_FIREWALL = "f",
+  STORE_OPTIMISTIC = "p";
 function createStoreProxy(e, t = storeTraps, n) {
   let i;
   if (Array.isArray(e)) {
@@ -1353,9 +1553,9 @@ function getNodes(e, t) {
   if (!n) e[t] = n = Object.create(null);
   return n;
 }
-function getNode(e, t, n, i, r = isEqual) {
+function getNode(e, t, n, i, r = isEqual, o) {
   if (e[t]) return e[t];
-  return (e[t] = signal(
+  const s = signal(
     n,
     {
       equals: r,
@@ -1364,17 +1564,22 @@ function getNode(e, t, n, i, r = isEqual) {
       }
     },
     i
-  ));
+  );
+  if (o) s.le = true;
+  return (e[t] = s);
 }
 function trackSelf(e, t = $TRACK) {
-  getObserver() && read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false));
+  getObserver() &&
+    read(
+      getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false, e[STORE_OPTIMISTIC])
+    );
 }
 function getKeys(e, t, n = true) {
   const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
   if (!t) return i;
   const r = new Set(i);
-  const s = Reflect.ownKeys(t);
-  for (const e of s) {
+  const o = Reflect.ownKeys(t);
+  for (const e of o) {
     if (t[e] !== $DELETED) r.add(e);
     else r.delete(e);
   }
@@ -1400,104 +1605,170 @@ const storeTraps = {
     }
     const i = getNodes(e, STORE_NODE);
     const r = i[t];
-    const s = e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE];
-    const o = !!e[STORE_VALUE][$TARGET];
-    const u = s ? e[STORE_OVERRIDE] : e[STORE_VALUE];
+    const o = e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE];
+    const s = o || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]);
+    const u = !!e[STORE_VALUE][$TARGET];
+    const l = o
+      ? e[STORE_OPTIMISTIC_OVERRIDE]
+      : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+        ? e[STORE_OVERRIDE]
+        : e[STORE_VALUE];
     if (!r) {
-      const e = Object.getOwnPropertyDescriptor(u, t);
+      const e = Object.getOwnPropertyDescriptor(l, t);
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = r && (s || !o) ? (r.M !== NOT_PENDING ? r.M : r.Y) : u[t];
+      let n = r && (s || !u) ? (r.te !== NOT_PENDING ? (r.le ? r.ne : r.te) : r.ne) : l[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
       Writing?.add(i);
       return i;
     }
-    let l = r ? (s || !o ? read(i[t]) : (read(i[t]), u[t])) : u[t];
-    l === $DELETED && (l = undefined);
+    let c = r ? (s || !u ? read(i[t]) : (read(i[t]), l[t])) : l[t];
+    c === $DELETED && (c = undefined);
     if (!r) {
-      if (!s && typeof l === "function" && !u.hasOwnProperty(t)) {
+      if (!s && typeof c === "function" && !l.hasOwnProperty(t)) {
         let t;
         return !Array.isArray(e[STORE_VALUE]) &&
           (t = Object.getPrototypeOf(e[STORE_VALUE])) &&
           t !== Object.prototype
-          ? l.bind(u)
-          : l;
+          ? c.bind(l)
+          : c;
       } else if (getObserver()) {
-        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]));
+        return read(
+          getNode(
+            i,
+            t,
+            isWrappable(c) ? wrap(c, e) : c,
+            e[STORE_FIREWALL],
+            isEqual,
+            e[STORE_OPTIMISTIC]
+          )
+        );
       }
     }
-    return isWrappable(l) ? wrap(l, e) : l;
+    return isWrappable(c) ? wrap(c, e) : c;
   },
   has(e, t) {
     if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
     const n =
-      e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-        ? e[STORE_OVERRIDE][t] !== $DELETED
-        : t in e[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]));
+      e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
+        ? e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED
+        : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+          ? e[STORE_OVERRIDE][t] !== $DELETED
+          : t in e[STORE_VALUE];
+    getObserver() &&
+      read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC]));
     return n;
   },
   set(e, t, n) {
     const i = e[$PROXY];
     if (writeOnly(i)) {
+      if (e[STORE_OPTIMISTIC]) {
+        const t = e[STORE_FIREWALL];
+        if (t?.X) {
+          globalQueue.initTransition(t.X);
+        }
+      }
       untrack(() => {
         const r = e[STORE_VALUE];
-        const s = r[t];
-        const o = e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : s;
-        const u = n?.[$TARGET]?.[STORE_VALUE] ?? n;
-        if (o === u) return true;
-        const l = e[STORE_OVERRIDE]?.length || r.length;
-        if (u !== undefined && u === s) delete e[STORE_OVERRIDE][t];
-        else (e[STORE_OVERRIDE] || (e[STORE_OVERRIDE] = Object.create(null)))[t] = u;
-        const c = isWrappable(u);
-        if (isWrappable(o)) {
-          const e = PARENTS.get(o);
-          e && (e instanceof Set ? e.delete(i) : PARENTS.delete(o));
+        const o = r[t];
+        const s = e[STORE_OPTIMISTIC] && !projectionWriteActive;
+        const u = s ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+        if (s) trackOptimisticStore(i);
+        const l =
+          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
+            ? e[STORE_OPTIMISTIC_OVERRIDE][t]
+            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+              ? e[STORE_OVERRIDE][t]
+              : o;
+        const c = n?.[$TARGET]?.[STORE_VALUE] ?? n;
+        if (l === c) return true;
+        const a = e[STORE_OPTIMISTIC_OVERRIDE]?.length || e[STORE_OVERRIDE]?.length || r.length;
+        if (c !== undefined && c === o) delete e[u][t];
+        else (e[u] || (e[u] = Object.create(null)))[t] = c;
+        const f = isWrappable(c);
+        if (isWrappable(l)) {
+          const e = PARENTS.get(l);
+          e && (e instanceof Set ? e.delete(i) : PARENTS.delete(l));
         }
-        if (recursivelyNotify(i, storeLookup) && c) recursivelyAddParent(u, i);
+        if (recursivelyNotify(i, storeLookup) && f) recursivelyAddParent(c, i);
         e[STORE_HAS]?.[t] && setSignal(e[STORE_HAS][t], true);
-        const a = getNodes(e, STORE_NODE);
-        a[t] && setSignal(a[t], () => (c ? wrap(u, e) : u));
+        const E = getNodes(e, STORE_NODE);
+        E[t] && setSignal(E[t], () => (f ? wrap(c, e) : c));
         if (Array.isArray(r)) {
-          const e = parseInt(t) + 1;
-          if (e > l) a.length && setSignal(a.length, e);
+          if (t === "length") {
+            E.length && setSignal(E.length, c);
+          } else {
+            const e = parseInt(t) + 1;
+            if (e > a) E.length && setSignal(E.length, e);
+          }
         }
-        a[$TRACK] && setSignal(a[$TRACK], undefined);
+        E[$TRACK] && setSignal(E[$TRACK], undefined);
       });
     }
     return true;
   },
   deleteProperty(e, t) {
-    if (writeOnly(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
+    const n = e[STORE_OPTIMISTIC_OVERRIDE]?.[t] === $DELETED;
+    const i = e[STORE_OVERRIDE]?.[t] === $DELETED;
+    if (writeOnly(e[$PROXY]) && !n && !i) {
       untrack(() => {
-        const n =
-          e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : e[STORE_VALUE][t];
-        if (t in e[STORE_VALUE]) {
-          (e[STORE_OVERRIDE] || (e[STORE_OVERRIDE] = Object.create(null)))[t] = $DELETED;
-        } else if (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]) {
-          delete e[STORE_OVERRIDE][t];
+        const n = e[STORE_OPTIMISTIC] && !projectionWriteActive;
+        const i = n ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+        if (n) trackOptimisticStore(e[$PROXY]);
+        const r =
+          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
+            ? e[STORE_OPTIMISTIC_OVERRIDE][t]
+            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+              ? e[STORE_OVERRIDE][t]
+              : e[STORE_VALUE][t];
+        if (t in e[STORE_VALUE] || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE])) {
+          (e[i] || (e[i] = Object.create(null)))[t] = $DELETED;
+        } else if (e[i] && t in e[i]) {
+          delete e[i][t];
         } else return true;
-        if (isWrappable(n)) {
-          const t = PARENTS.get(n);
-          t && (t instanceof Set ? t.delete(e) : PARENTS.delete(n));
+        if (isWrappable(r)) {
+          const t = PARENTS.get(r);
+          t && (t instanceof Set ? t.delete(e) : PARENTS.delete(r));
         }
         if (e[STORE_HAS]?.[t]) setSignal(e[STORE_HAS][t], false);
-        const i = getNodes(e, STORE_NODE);
-        i[t] && setSignal(i[t], undefined);
-        i[$TRACK] && setSignal(i[$TRACK], undefined);
+        const o = getNodes(e, STORE_NODE);
+        o[t] && setSignal(o[t], undefined);
+        o[$TRACK] && setSignal(o[$TRACK], undefined);
       });
     }
     return true;
   },
   ownKeys(e) {
     trackSelf(e);
-    return getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
+    let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
+    if (e[STORE_OPTIMISTIC_OVERRIDE]) {
+      const n = new Set(t);
+      for (const t of Reflect.ownKeys(e[STORE_OPTIMISTIC_OVERRIDE])) {
+        if (e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED) n.add(t);
+        else n.delete(t);
+      }
+      t = Array.from(n);
+    }
+    return t;
   },
   getOwnPropertyDescriptor(e, t) {
     if (t === $PROXY) return { value: e[$PROXY], writable: true, configurable: true };
+    if (e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]) {
+      if (e[STORE_OPTIMISTIC_OVERRIDE][t] === $DELETED) return undefined;
+      const n = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
+      if (n) {
+        return { ...n, value: e[STORE_OPTIMISTIC_OVERRIDE][t] };
+      }
+      return {
+        value: e[STORE_OPTIMISTIC_OVERRIDE][t],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      };
+    }
     return getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
   },
   getPrototypeOf(e) {
@@ -1576,8 +1847,8 @@ function recursivelyAddParent(e, t) {
     const t = getKeys(e, n);
     for (let i = 0; i < t.length; i++) {
       const r = t[i];
-      const s = n && r in n ? n[r] : e[r];
-      isWrappable(s) && recursivelyAddParent(s, e);
+      const o = n && r in n ? n[r] : e[r];
+      isWrappable(o) && recursivelyAddParent(o, e);
     }
   }
 }
@@ -1586,19 +1857,88 @@ function deep(e) {
   return e[$DEEP];
 }
 function createOptimisticStore(e, t, n) {
-  return [];
+  GlobalQueue.Y ||= clearOptimisticStore;
+  const i = typeof e === "function";
+  const r = (i ? t : e) ?? {};
+  const o = i ? e : undefined;
+  const { store: s } = createOptimisticProjectionInternal(o, r, n);
+  return [s, e => storeSetter(s, e)];
+}
+function clearOptimisticStore(e) {
+  const t = e[$TARGET];
+  if (!t || !t[STORE_OPTIMISTIC_OVERRIDE]) return;
+  const n = t[STORE_OPTIMISTIC_OVERRIDE];
+  const i = t[STORE_NODE];
+  if (i) {
+    for (const e of Reflect.ownKeys(n)) {
+      if (i[e]) {
+        const n =
+          t[STORE_OVERRIDE] && e in t[STORE_OVERRIDE] ? t[STORE_OVERRIDE][e] : t[STORE_VALUE][e];
+        const r = n === $DELETED ? undefined : n;
+        setSignal(i[e], isWrappable(r) ? wrap(r, t) : r);
+      }
+    }
+    i[$TRACK] && setSignal(i[$TRACK], undefined);
+  }
+  delete t[STORE_OPTIMISTIC_OVERRIDE];
+}
+function createOptimisticProjectionInternal(e, t = {}, n) {
+  let i;
+  const r = new WeakMap();
+  const wrapper = e => {
+    e[STORE_WRAP] = wrapProjection;
+    e[STORE_LOOKUP] = r;
+    e[STORE_OPTIMISTIC] = true;
+    Object.defineProperty(e, STORE_FIREWALL, {
+      get() {
+        return i;
+      },
+      configurable: true
+    });
+  };
+  const wrapProjection = e => {
+    if (r.has(e)) return r.get(e);
+    if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
+    const t = createStoreProxy(e, storeTraps, wrapper);
+    r.set(e, t);
+    return t;
+  };
+  const o = wrapProjection(t);
+  if (e) {
+    i = computed(() => {
+      const t = getOwner();
+      setProjectionWriteActive(true);
+      try {
+        storeSetter(new Proxy(o, writeTraps), i => {
+          const r = handleAsync(t, e(i), e => {
+            setProjectionWriteActive(true);
+            try {
+              e !== i && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id", n?.all));
+            } finally {
+              setProjectionWriteActive(false);
+            }
+          });
+          r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(o);
+        });
+      } finally {
+        setProjectionWriteActive(false);
+      }
+    });
+    i.Se = true;
+  }
+  return { store: o, node: i };
 }
 function snapshot(e, t, n) {
-  let i, r, s, o, u, l;
+  let i, r, o, s, u, l;
   if (!isWrappable(e)) return e;
   if (t && t.has(e)) return t.get(e);
   if (!t) t = new Map();
   if ((i = e[$TARGET] || n?.get(e)?.[$TARGET])) {
-    s = i[STORE_OVERRIDE];
+    o = i[STORE_OVERRIDE];
     r = Array.isArray(i[STORE_VALUE]);
     t.set(
       e,
-      s ? (o = r ? [] : Object.create(Object.getPrototypeOf(i[STORE_VALUE]))) : i[STORE_VALUE]
+      o ? (s = r ? [] : Object.create(Object.getPrototypeOf(i[STORE_VALUE]))) : i[STORE_VALUE]
     );
     e = i[STORE_VALUE];
     n = storeLookup;
@@ -1607,32 +1947,32 @@ function snapshot(e, t, n) {
     t.set(e, e);
   }
   if (r) {
-    const i = s?.length || e.length;
+    const i = o?.length || e.length;
     for (let r = 0; r < i; r++) {
-      l = s && r in s ? s[r] : e[r];
+      l = o && r in o ? o[r] : e[r];
       if (l === $DELETED) continue;
-      if ((u = snapshot(l, t, n)) !== l || o) {
-        if (!o) t.set(e, (o = [...e]));
-        o[r] = u;
+      if ((u = snapshot(l, t, n)) !== l || s) {
+        if (!s) t.set(e, (s = [...e]));
+        s[r] = u;
       }
     }
   } else {
-    const i = getKeys(e, s);
+    const i = getKeys(e, o);
     for (let r = 0, c = i.length; r < c; r++) {
       let c = i[r];
-      const a = getPropertyDescriptor(e, s, c);
+      const a = getPropertyDescriptor(e, o, c);
       if (a.get) continue;
-      l = s && c in s ? s[c] : e[c];
-      if ((u = snapshot(l, t, n)) !== e[c] || o) {
-        if (!o) {
-          o = Object.create(Object.getPrototypeOf(e));
-          Object.assign(o, e);
+      l = o && c in o ? o[c] : e[c];
+      if ((u = snapshot(l, t, n)) !== e[c] || s) {
+        if (!s) {
+          s = Object.create(Object.getPrototypeOf(e));
+          Object.assign(s, e);
         }
-        o[c] = u;
+        s[c] = u;
       }
     }
   }
-  return o || e;
+  return s || e;
 }
 function trueFn() {
   return true;
@@ -1674,8 +2014,8 @@ function merge(...e) {
   for (let i = 0; i < e.length; i++) {
     const r = e[i];
     t = t || (!!r && $PROXY in r);
-    const s = !!r && r[$SOURCES];
-    if (s) n.push(...s);
+    const o = !!r && r[$SOURCES];
+    if (o) n.push(...o);
     else n.push(typeof r === "function" ? ((t = true), createMemo(r)) : r);
   }
   if (SUPPORTS_PROXY && t) {
@@ -1705,35 +2045,35 @@ function merge(...e) {
   }
   const i = Object.create(null);
   let r = false;
-  let s = n.length - 1;
-  for (let e = s; e >= 0; e--) {
+  let o = n.length - 1;
+  for (let e = o; e >= 0; e--) {
     const t = n[e];
     if (!t) {
-      e === s && s--;
+      e === o && o--;
       continue;
     }
-    const o = Object.getOwnPropertyNames(t);
-    for (let n = o.length - 1; n >= 0; n--) {
-      const u = o[n];
+    const s = Object.getOwnPropertyNames(t);
+    for (let n = s.length - 1; n >= 0; n--) {
+      const u = s[n];
       if (u === "__proto__" || u === "constructor") continue;
       if (!i[u]) {
-        r = r || e !== s;
+        r = r || e !== o;
         const n = Object.getOwnPropertyDescriptor(t, u);
         i[u] = n.get ? { enumerable: true, configurable: true, get: n.get.bind(t) } : n;
       }
     }
   }
-  if (!r) return n[s];
-  const o = {};
+  if (!r) return n[o];
+  const s = {};
   const u = Object.keys(i);
   for (let e = u.length - 1; e >= 0; e--) {
     const t = u[e],
       n = i[t];
-    if (n.get) Object.defineProperty(o, t, n);
-    else o[t] = n.value;
+    if (n.get) Object.defineProperty(s, t, n);
+    else s[t] = n.value;
   }
-  o[$SOURCES] = n;
-  return o;
+  s[$SOURCES] = n;
+  return s;
 }
 function omit(e, ...t) {
   const n = new Set(t);
@@ -1768,247 +2108,241 @@ function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      ye: createOwner(),
-      Ce: 0,
-      De: e,
-      Pe: [],
-      we: t,
-      be: [],
-      Ve: [],
-      me: i,
-      Ue: i || n?.keyed === false ? [] : undefined,
-      ke: t.length > 1 ? [] : undefined,
-      ve: n?.fallback
+      De: createOwner(),
+      we: 0,
+      be: e,
+      ve: [],
+      Ve: t,
+      me: [],
+      Ue: [],
+      ke: i,
+      We: i || n?.keyed === false ? [] : undefined,
+      Qe: t.length > 1 ? [] : undefined,
+      xe: n?.fallback
     })
   );
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.De() || [],
+  const e = this.be() || [],
     t = e.length;
   e[$TRACK];
-  runWithOwner(this.ye, () => {
+  runWithOwner(this.De, () => {
     let n,
       i,
-      r = this.Ue
+      r = this.We
         ? () => {
-            this.Ue[i] = signal(e[i], pureOptions);
-            this.ke && (this.ke[i] = signal(i, pureOptions));
-            return this.we(
-              read.bind(null, this.Ue[i]),
-              this.ke ? read.bind(null, this.ke[i]) : undefined
+            this.We[i] = signal(e[i], pureOptions);
+            this.Qe && (this.Qe[i] = signal(i, pureOptions));
+            return this.Ve(
+              read.bind(null, this.We[i]),
+              this.Qe ? read.bind(null, this.Qe[i]) : undefined
             );
           }
-        : this.ke
+        : this.Qe
           ? () => {
               const t = e[i];
-              this.ke[i] = signal(i, pureOptions);
-              return this.we(() => t, read.bind(null, this.ke[i]));
+              this.Qe[i] = signal(i, pureOptions);
+              return this.Ve(() => t, read.bind(null, this.Qe[i]));
             }
           : () => {
               const t = e[i];
-              return this.we(() => t);
+              return this.Ve(() => t);
             };
     if (t === 0) {
-      if (this.Ce !== 0) {
-        this.ye.dispose(false);
-        this.Ve = [];
-        this.Pe = [];
-        this.be = [];
-        this.Ce = 0;
-        this.Ue && (this.Ue = []);
-        this.ke && (this.ke = []);
+      if (this.we !== 0) {
+        this.De.dispose(false);
+        this.Ue = [];
+        this.ve = [];
+        this.me = [];
+        this.we = 0;
+        this.We && (this.We = []);
+        this.Qe && (this.Qe = []);
       }
-      if (this.ve && !this.be[0]) {
-        this.be[0] = runWithOwner((this.Ve[0] = createOwner()), this.ve);
+      if (this.xe && !this.me[0]) {
+        this.me[0] = runWithOwner((this.Ue[0] = createOwner()), this.xe);
       }
-    } else if (this.Ce === 0) {
-      if (this.Ve[0]) this.Ve[0].dispose();
-      this.be = new Array(t);
+    } else if (this.we === 0) {
+      if (this.Ue[0]) this.Ue[0].dispose();
+      this.me = new Array(t);
       for (i = 0; i < t; i++) {
-        this.Pe[i] = e[i];
-        this.be[i] = runWithOwner((this.Ve[i] = createOwner()), r);
+        this.ve[i] = e[i];
+        this.me[i] = runWithOwner((this.Ue[i] = createOwner()), r);
       }
-      this.Ce = t;
+      this.we = t;
     } else {
-      let s,
-        o,
+      let o,
+        s,
         u,
         l,
         c,
         a,
         f,
         E = new Array(t),
-        d = new Array(t),
-        T = this.Ue ? new Array(t) : undefined,
-        R = this.ke ? new Array(t) : undefined;
+        T = new Array(t),
+        R = this.We ? new Array(t) : undefined,
+        d = this.Qe ? new Array(t) : undefined;
       for (
-        s = 0, o = Math.min(this.Ce, t);
-        s < o && (this.Pe[s] === e[s] || (this.Ue && compare(this.me, this.Pe[s], e[s])));
-        s++
+        o = 0, s = Math.min(this.we, t);
+        o < s && (this.ve[o] === e[o] || (this.We && compare(this.ke, this.ve[o], e[o])));
+        o++
       ) {
-        if (this.Ue) setSignal(this.Ue[s], e[s]);
+        if (this.We) setSignal(this.We[o], e[o]);
       }
       for (
-        o = this.Ce - 1, u = t - 1;
-        o >= s &&
-        u >= s &&
-        (this.Pe[o] === e[u] || (this.Ue && compare(this.me, this.Pe[o], e[u])));
-        o--, u--
+        s = this.we - 1, u = t - 1;
+        s >= o &&
+        u >= o &&
+        (this.ve[s] === e[u] || (this.We && compare(this.ke, this.ve[s], e[u])));
+        s--, u--
       ) {
-        E[u] = this.be[o];
-        d[u] = this.Ve[o];
-        T && (T[u] = this.Ue[o]);
-        R && (R[u] = this.ke[o]);
+        E[u] = this.me[s];
+        T[u] = this.Ue[s];
+        R && (R[u] = this.We[s]);
+        d && (d[u] = this.Qe[s]);
       }
       a = new Map();
       f = new Array(u + 1);
-      for (i = u; i >= s; i--) {
+      for (i = u; i >= o; i--) {
         l = e[i];
-        c = this.me ? this.me(l) : l;
+        c = this.ke ? this.ke(l) : l;
         n = a.get(c);
         f[i] = n === undefined ? -1 : n;
         a.set(c, i);
       }
-      for (n = s; n <= o; n++) {
-        l = this.Pe[n];
-        c = this.me ? this.me(l) : l;
+      for (n = o; n <= s; n++) {
+        l = this.ve[n];
+        c = this.ke ? this.ke(l) : l;
         i = a.get(c);
         if (i !== undefined && i !== -1) {
-          E[i] = this.be[n];
-          d[i] = this.Ve[n];
-          T && (T[i] = this.Ue[n]);
-          R && (R[i] = this.ke[n]);
+          E[i] = this.me[n];
+          T[i] = this.Ue[n];
+          R && (R[i] = this.We[n]);
+          d && (d[i] = this.Qe[n]);
           i = f[i];
           a.set(c, i);
-        } else this.Ve[n].dispose();
+        } else this.Ue[n].dispose();
       }
-      for (i = s; i < t; i++) {
+      for (i = o; i < t; i++) {
         if (i in E) {
-          this.be[i] = E[i];
-          this.Ve[i] = d[i];
-          if (T) {
-            this.Ue[i] = T[i];
-            setSignal(this.Ue[i], e[i]);
-          }
+          this.me[i] = E[i];
+          this.Ue[i] = T[i];
           if (R) {
-            this.ke[i] = R[i];
-            setSignal(this.ke[i], i);
+            this.We[i] = R[i];
+            setSignal(this.We[i], e[i]);
+          }
+          if (d) {
+            this.Qe[i] = d[i];
+            setSignal(this.Qe[i], i);
           }
         } else {
-          this.be[i] = runWithOwner((this.Ve[i] = createOwner()), r);
+          this.me[i] = runWithOwner((this.Ue[i] = createOwner()), r);
         }
       }
-      this.be = this.be.slice(0, (this.Ce = t));
-      this.Pe = e.slice(0);
+      this.me = this.me.slice(0, (this.we = t));
+      this.ve = e.slice(0);
     }
   });
-  return this.be;
+  return this.me;
 }
 function repeat(e, t, n) {
   return updateRepeat.bind({
-    ye: createOwner(),
-    Ce: 0,
-    xe: 0,
-    Ge: e,
-    we: t,
-    Ve: [],
-    be: [],
-    He: n?.from,
-    ve: n?.fallback
+    De: createOwner(),
+    we: 0,
+    Ge: 0,
+    Me: e,
+    Ve: t,
+    Ue: [],
+    me: [],
+    $e: n?.from,
+    xe: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.Ge();
-  const t = this.He?.() || 0;
-  runWithOwner(this.ye, () => {
+  const e = this.Me();
+  const t = this.$e?.() || 0;
+  runWithOwner(this.De, () => {
     if (e === 0) {
-      if (this.Ce !== 0) {
-        this.ye.dispose(false);
-        this.Ve = [];
-        this.be = [];
-        this.Ce = 0;
+      if (this.we !== 0) {
+        this.De.dispose(false);
+        this.Ue = [];
+        this.me = [];
+        this.we = 0;
       }
-      if (this.ve && !this.be[0]) {
-        this.be[0] = runWithOwner((this.Ve[0] = createOwner()), this.ve);
+      if (this.xe && !this.me[0]) {
+        this.me[0] = runWithOwner((this.Ue[0] = createOwner()), this.xe);
       }
       return;
     }
     const n = t + e;
-    const i = this.xe + this.Ce;
-    if (this.Ce === 0 && this.Ve[0]) this.Ve[0].dispose();
-    for (let e = n; e < i; e++) this.Ve[e - this.xe].dispose();
-    if (this.xe < t) {
-      let e = this.xe;
-      while (e < t && e < this.Ce) this.Ve[e++].dispose();
-      this.Ve.splice(0, t - this.xe);
-      this.be.splice(0, t - this.xe);
-    } else if (this.xe > t) {
-      let n = i - this.xe - 1;
-      let r = this.xe - t;
-      this.Ve.length = this.be.length = e;
+    const i = this.Ge + this.we;
+    if (this.we === 0 && this.Ue[0]) this.Ue[0].dispose();
+    for (let e = n; e < i; e++) this.Ue[e - this.Ge].dispose();
+    if (this.Ge < t) {
+      let e = this.Ge;
+      while (e < t && e < this.we) this.Ue[e++].dispose();
+      this.Ue.splice(0, t - this.Ge);
+      this.me.splice(0, t - this.Ge);
+    } else if (this.Ge > t) {
+      let n = i - this.Ge - 1;
+      let r = this.Ge - t;
+      this.Ue.length = this.me.length = e;
       while (n >= r) {
-        this.Ve[n] = this.Ve[n - r];
-        this.be[n] = this.be[n - r];
+        this.Ue[n] = this.Ue[n - r];
+        this.me[n] = this.me[n - r];
         n--;
       }
       for (let e = 0; e < r; e++) {
-        this.be[e] = runWithOwner((this.Ve[e] = createOwner()), () => this.we(e + t));
+        this.me[e] = runWithOwner((this.Ue[e] = createOwner()), () => this.Ve(e + t));
       }
     }
     for (let e = i; e < n; e++) {
-      this.be[e - t] = runWithOwner((this.Ve[e - t] = createOwner()), () => this.we(e));
+      this.me[e - t] = runWithOwner((this.Ue[e - t] = createOwner()), () => this.Ve(e));
     }
-    this.be = this.be.slice(0, e);
-    this.xe = t;
-    this.Ce = e;
+    this.me = this.me.slice(0, e);
+    this.Ge = t;
+    this.we = e;
   });
-  return this.be;
+  return this.me;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
-  const n = computed(e, undefined, {
-    pe: {
-      le() {
-        let e = this.J;
-        this.J &= ~this.Qe;
-        if (this.Qe & STATUS_PENDING && !(this.J & STATUS_UNINITIALIZED)) {
-          e &= ~STATUS_PENDING;
-        }
-        this._e.notify(this, this.Qe, e);
-      },
-      Qe: t
-    }
-  });
-  n.Qe = t;
-  n.Te = true;
+  const n = computed(e, undefined, { lazy: true });
+  n.Te = () => {
+    const e = n.ie;
+    n.ie &= ~n.Le;
+    n.J.notify(n, n.Le, e);
+  };
+  n.Le = t;
+  n.Se = true;
+  recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e._e;
-  r.addChild((e._e = n));
-  onCleanup(() => r.removeChild(e._e));
+  const r = e.J;
+  r.addChild((e.J = n));
+  onCleanup(() => r.removeChild(e.J));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
   });
 }
 class ConditionalQueue extends Queue {
-  Le;
-  $e = new Set();
+  He;
+  Fe = new Set();
   L = new Set();
   constructor(e) {
     super();
-    this.Le = e;
+    this.He = e;
   }
   run(e) {
-    if (!e || read(this.Le)) return;
+    if (!e || read(this.He)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (read(this.Le)) {
+    if (read(this.He)) {
       if (t & STATUS_PENDING) {
         if (n & STATUS_PENDING) {
           this.L.add(e);
@@ -2017,37 +2351,37 @@ class ConditionalQueue extends Queue {
       }
       if (t & STATUS_ERROR) {
         if (n & STATUS_ERROR) {
-          this.$e.add(e);
+          this.Fe.add(e);
           t &= ~STATUS_ERROR;
-        } else if (this.$e.delete(e)) t &= ~STATUS_ERROR;
+        } else if (this.Fe.delete(e)) t &= ~STATUS_ERROR;
       }
     }
     return t ? super.notify(e, t, n) : true;
   }
 }
 class CollectionQueue extends Queue {
-  Fe;
-  Ve = new Set();
-  Le = signal(false, { pureWrite: true });
-  We = false;
+  je;
+  Ue = new Set();
+  He = signal(false, { pureWrite: true });
+  Ke = false;
   constructor(e) {
     super();
-    this.Fe = e;
+    this.je = e;
   }
   run(e) {
-    if (!e || read(this.Le)) return;
+    if (!e || read(this.He)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (!(t & this.Fe) || (this.Fe & STATUS_PENDING && this.We)) return super.notify(e, t, n);
-    if (n & this.Fe) {
-      this.Ve.add(e);
-      if (this.Ve.size === 1) setSignal(this.Le, true);
-    } else if (this.Ve.size > 0) {
-      this.Ve.delete(e);
-      if (this.Ve.size === 0) setSignal(this.Le, false);
-    }
-    t &= ~this.Fe;
+    if (!(t & this.je) || (this.je & STATUS_PENDING && this.Ke)) return super.notify(e, t, n);
+    if (n & this.je) {
+      this.Ue.add(e);
+      if (this.Ue.size === 1) setSignal(this.He, true);
+    } else if (this.Ue.size > 0) {
+      this.Ue.delete(e);
+      if (this.Ue.size === 0) setSignal(this.He, false);
+    }
+    t &= ~this.je;
     return t ? super.notify(e, t, n) : true;
   }
 }
@@ -2061,53 +2395,55 @@ function createBoundary(e, t) {
   const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
   const r = createBoundChildren(n, e, i, 0);
   computed(() => {
-    const e = read(i.Le);
-    r.Qe = e ? STATUS_ERROR | STATUS_PENDING : 0;
+    const e = read(i.He);
+    r.Le = e ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!e) {
       i.L.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
-      i.$e.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
+      i.Fe.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
       i.L.clear();
-      i.$e.clear();
+      i.Fe.clear();
     }
   });
-  return () => (read(i.Le) ? undefined : read(r));
+  return () => (read(i.He) ? undefined : read(r));
 }
 function createCollectionBoundary(e, t, n) {
   const i = createOwner();
   const r = new CollectionQueue(e);
-  const s = createBoundChildren(i, t, r, e);
-  const o = computed(() => {
-    if (!read(r.Le)) {
-      const e = read(s);
-      if (!untrack(() => read(r.Le))) r.We = true;
-      return e;
+  const o = createBoundChildren(i, t, r, e);
+  const s = computed(() => {
+    if (!read(r.He)) {
+      const e = read(o);
+      if (!untrack(() => read(r.He))) {
+        r.Ke = true;
+        return e;
+      }
     }
     return n(r);
   });
-  return read.bind(null, o);
+  return read.bind(null, s);
 }
 function createLoadBoundary(e, t) {
   return createCollectionBoundary(STATUS_PENDING, e, () => t());
 }
 function collectErrorSources(e, t) {
   let n = true;
-  let i = e.D;
+  let i = e.C;
   while (i !== null) {
     const e = i.V;
-    if (e.D && e.J & STATUS_ERROR) {
+    if (e.C && e.ie & STATUS_ERROR) {
       n = false;
       collectErrorSources(e, t);
     }
-    i = i.P;
+    i = i.D;
   }
   n && t.push(e);
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.Ve.values().next().value;
-    return t(n.j, () => {
+    let n = e.Ue.values().next().value;
+    return t(n.B, () => {
       const t = [];
-      for (const n of e.Ve) collectErrorSources(n, t);
+      for (const n of e.Ue) collectErrorSources(n, t);
       for (const e of t) recompute(e);
       schedule();
     });
@@ -2137,9 +2473,9 @@ function flatten(e, t) {
 function flattenArray(e, t = [], n) {
   let i = null;
   let r = false;
-  for (let s = 0; s < e.length; s++) {
+  for (let o = 0; o < e.length; o++) {
     try {
-      let i = e[s];
+      let i = e[o];
       if (typeof i === "function" && !i.length) {
         if (n?.doNotUnwrap) {
           t.push(i);