@solidjs/signals 0.9.4 → 0.9.6

package/dist/node.cjs

@@ -24,16 +24,18 @@ const i = 1 << 3;
 const s = 1 << 4;
 const o = 1 << 5;
 const u = 1 << 6;
-const l = 0;
-const f = 1 << 0;
-const c = 1 << 1;
-const a = 1 << 2;
-const d = 1;
+const l = 1 << 7;
+const f = 0;
+const c = 1 << 0;
+const a = 1 << 1;
+const d = 1 << 2;
+const p = 1;
 const h = 2;
-const p = {};
-const y = typeof Proxy === "function";
+const y = 3;
 const g = {};
-const w = Symbol("refresh");
+const w = typeof Proxy === "function";
+const S = {};
+const m = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
   const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
   if (n >= e.o) e.o = n + 1;
@@ -41,120 +43,128 @@ function actualInsertIntoHeap(e, t) {
   const i = t.l[r];
   if (i === undefined) t.l[r] = e;
   else {
-    const t = i.h;
-    t.p = e;
-    e.h = t;
-    i.h = e;
+    const t = i.p;
+    t.h = e;
+    e.p = t;
+    i.p = e;
   }
-  if (r > t._) t._ = r;
+  if (r > t.S) t.S = r;
 }
 function insertIntoHeap(e, o) {
-  let u = e.S;
+  let u = e.m;
   if (u & (i | r)) return;
   if (u & t) {
-    e.S = (u & -4) | n | i;
-  } else e.S = u | i;
+    e.m = (u & -4) | n | i;
+  } else e.m = u | i;
   if (!(u & s)) actualInsertIntoHeap(e, o);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e.S;
+  let n = e.m;
   if (n & (i | r | s)) return;
-  e.S = n | s;
+  e.m = n | s;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e.S;
+  const n = e.m;
   if (!(n & (i | s))) return;
-  e.S = n & -25;
+  e.m = n & -25;
   const r = e.o;
-  if (e.h === e) t.l[r] = undefined;
+  if (e.p === e) t.l[r] = undefined;
   else {
-    const n = e.p;
+    const n = e.h;
     const i = t.l[r];
     const s = n ?? i;
     if (e === i) t.l[r] = n;
-    else e.h.p = n;
-    s.h = e.h;
+    else e.p.h = n;
+    s.p = e.p;
   }
-  e.h = e;
-  e.p = undefined;
+  e.p = e;
+  e.h = undefined;
 }
 function markHeap(e) {
-  if (e.m) return;
-  e.m = true;
-  for (let t = 0; t <= e._; t++) {
-    for (let n = e.l[t]; n !== undefined; n = n.p) {
-      if (n.S & i) markNode(n);
+  if (e._) return;
+  e._ = true;
+  for (let t = 0; t <= e.S; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.h) {
+      if (n.m & i) markNode(n);
     }
   }
 }
 function markNode(e, r = n) {
-  const i = e.S;
+  const i = e.m;
   if ((i & (t | n)) >= r) return;
-  e.S = (i & -4) | r;
-  for (let n = e.O; n !== null; n = n.C) {
-    markNode(n.N, t);
+  e.m = (i & -4) | r;
+  for (let n = e.O; n !== null; n = n.P) {
+    markNode(n.C, t);
   }
   if (e.k !== null) {
-    for (let n = e.k; n !== null; n = n.j) {
-      for (let e = n.O; e !== null; e = e.C) {
-        markNode(e.N, t);
+    for (let n = e.k; n !== null; n = n.A) {
+      for (let e = n.O; e !== null; e = e.P) {
+        markNode(e.C, t);
       }
     }
   }
 }
 function runHeap(e, t) {
-  e.m = false;
-  for (e.P = 0; e.P <= e._; e.P++) {
-    let n = e.l[e.P];
+  e._ = false;
+  for (e.W = 0; e.W <= e.S; e.W++) {
+    let n = e.l[e.W];
     while (n !== undefined) {
-      if (n.S & i) t(n);
+      if (n.m & i) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.P];
+      n = e.l[e.W];
     }
   }
-  e._ = 0;
+  e.S = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
   let n = e.o;
-  for (let t = e.W; t; t = t.A) {
-    const e = t.I;
-    const r = e.F || e;
-    if (r.H && r.o >= n) n = r.o + 1;
+  for (let t = e.j; t; t = t.N) {
+    const e = t.H;
+    const r = e.I || e;
+    if (r.R && r.o >= n) n = r.o + 1;
   }
   if (e.o !== n) {
     e.o = n;
-    for (let n = e.O; n !== null; n = n.C) {
-      insertIntoHeapHeight(n.N, t);
+    for (let n = e.O; n !== null; n = n.P) {
+      insertIntoHeapHeight(n.C, t);
     }
   }
 }
-const _ = new Set();
-let S = false;
-const b = { l: new Array(2e3).fill(undefined), m: false, P: 0, _: 0 };
-const m = { l: new Array(2e3).fill(undefined), m: false, P: 0, _: 0 };
-let O = 0;
-let x = null;
-let v = false;
+const b = new Set();
+const _ = { l: new Array(2e3).fill(undefined), _: false, W: 0, S: 0 };
+const O = { l: new Array(2e3).fill(undefined), _: false, W: 0, S: 0 };
+let x = 0;
+let v = null;
+let P = false;
+let C = false;
+let k = false;
+function setOptimisticReadActive(e) {
+  C = e;
+}
+function setProjectionWriteActive(e) {
+  k = e;
+}
 function schedule() {
-  if (v) return;
-  v = true;
-  if (!C.R) Promise.resolve().then(() => queueMicrotask(flush));
+  if (P) return;
+  P = true;
+  if (!A.T) queueMicrotask(flush);
 }
 class Queue {
   i = null;
-  V = [[], []];
-  q = [];
-  created = O;
+  q = [[], []];
+  F = [[], []];
+  V = [];
+  created = x;
   addChild(e) {
-    this.q.push(e);
+    this.V.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.q.indexOf(e);
+    const t = this.V.indexOf(e);
     if (t >= 0) {
-      this.q.splice(t, 1);
+      this.V.splice(t, 1);
       e.i = null;
     }
   }
@@ -162,89 +172,110 @@ class Queue {
     if (this.i) return this.i.notify(e, t, n);
     return false;
   }
-  run(e) {
-    if (this.V[e - 1].length) {
-      const t = this.V[e - 1];
-      this.V[e - 1] = [];
-      runQueue(t, e);
+  M(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.q.length; t++) {
-      this.q[t].run(e);
+    for (let t = 0; t < this.V.length; t++) {
+      this.V[t][n]?.(e);
     }
   }
+  run(e) {
+    this.M(e, this.q, "run");
+  }
+  runOptimistic(e) {
+    this.M(e, this.F, "runOptimistic");
+  }
   enqueue(e, t) {
-    if (e) this.V[e - 1].push(t);
+    if (e) {
+      const n = C ? this.F : this.q;
+      n[e - 1].push(t);
+    }
     schedule();
   }
   stashQueues(e) {
-    e.V[0].push(...this.V[0]);
-    e.V[1].push(...this.V[1]);
-    this.V = [[], []];
-    for (let t = 0; t < this.q.length; t++) {
-      let n = this.q[t];
-      let r = e.q[t];
+    e.q[0].push(...this.q[0]);
+    e.q[1].push(...this.q[1]);
+    this.q = [[], []];
+    for (let t = 0; t < this.V.length; t++) {
+      let n = this.V[t];
+      let r = e.V[t];
       if (!r) {
-        r = { V: [[], []], q: [] };
-        e.q[t] = r;
+        r = { q: [[], []], V: [] };
+        e.V[t] = r;
       }
       n.stashQueues(r);
     }
   }
   restoreQueues(e) {
-    this.V[0].push(...e.V[0]);
-    this.V[1].push(...e.V[1]);
-    for (let t = 0; t < e.q.length; t++) {
-      const n = e.q[t];
-      let r = this.q[t];
+    this.q[0].push(...e.q[0]);
+    this.q[1].push(...e.q[1]);
+    for (let t = 0; t < e.V.length; t++) {
+      const n = e.V[t];
+      let r = this.V[t];
       if (r) r.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  R = false;
-  M = [];
-  T = [];
-  static D;
-  static B;
+  T = false;
+  D = [];
+  B = [];
+  G = new Set();
+  static K;
+  static U;
+  static L = null;
   flush() {
-    if (this.R) return;
-    this.R = true;
+    if (this.T) return;
+    this.T = true;
     try {
-      runHeap(b, GlobalQueue.D);
-      if (x) {
-        if (!transitionComplete(x)) {
-          let e = x;
-          runHeap(m, GlobalQueue.D);
-          this.M = [];
-          this.stashQueues(x.queueStash);
-          O++;
-          v = false;
-          runTransitionPending(x.pendingNodes, true);
-          x = null;
-          runOptimistic(e);
+      runHeap(_, GlobalQueue.K);
+      if (v) {
+        const e = transitionComplete(v);
+        if (!e) {
+          let e = v;
+          runHeap(O, GlobalQueue.K);
+          this.D = [];
+          this.B = [];
+          this.G = new Set();
+          this.runOptimistic(p);
+          this.runOptimistic(h);
+          this.stashQueues(v.queueStash);
+          x++;
+          P = false;
+          runTransitionPending(v.pendingNodes);
+          v = null;
+          finalizePureQueue(null, true);
           return;
         }
-        this.M.push(...x.pendingNodes);
-        this.T !== x.optimisticNodes && this.T.push(...x.optimisticNodes);
-        this.restoreQueues(x.queueStash);
-        _.delete(x);
-        x = null;
-        runTransitionPending(this.M, false);
-      } else if (_.size) runHeap(m, GlobalQueue.D);
-      runOptimistic();
-      O++;
-      v = false;
-      this.run(d);
+        this.D !== v.pendingNodes && this.D.push(...v.pendingNodes);
+        this.restoreQueues(v.queueStash);
+        b.delete(v);
+        const t = v;
+        v = null;
+        runTransitionPending(this.D);
+        finalizePureQueue(t);
+      } else {
+        if (b.size) runHeap(O, GlobalQueue.K);
+        finalizePureQueue();
+      }
+      x++;
+      P = _.S >= _.W;
+      this.runOptimistic(p);
+      this.run(p);
+      this.runOptimistic(h);
       this.run(h);
     } finally {
-      this.R = false;
+      this.T = false;
     }
   }
   notify(e, t, n) {
-    if (t & f) {
-      if (n & f) {
-        if (x && !x.asyncNodes.includes(e.K.cause)) {
-          x.asyncNodes.push(e.K.cause);
+    if (t & c) {
+      if (n & c) {
+        if (v && e.J && !v.asyncNodes.includes(e.J.cause)) {
+          v.asyncNodes.push(e.J.cause);
           schedule();
         }
       }
@@ -253,86 +284,115 @@ class GlobalQueue extends Queue {
     return false;
   }
   initTransition(e) {
-    if (x && x.time === O) return;
-    if (!x) {
-      x = e?.G ?? {
-        time: O,
+    if (e) e = currentTransition(e);
+    if (e && e === v) return;
+    if (!e && v && v.time === x) return;
+    if (!v) {
+      v = e ?? {
+        time: x,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        optimisticStores: new Set(),
         actions: [],
-        queueStash: { V: [[], []], q: [] },
+        queueStash: { q: [[], []], V: [] },
         done: false
       };
+    } else if (e) {
+      v.done = e;
+      e.actions.push(...v.actions);
+      b.delete(v);
+      v = e;
+    }
+    b.add(v);
+    v.time = x;
+    for (let e = 0; e < this.D.length; e++) {
+      const t = this.D[e];
+      t.X = v;
+      v.pendingNodes.push(t);
+    }
+    this.D = v.pendingNodes;
+    for (let e = 0; e < this.B.length; e++) {
+      const t = this.B[e];
+      t.X = v;
+      v.optimisticNodes.push(t);
+    }
+    this.B = v.optimisticNodes;
+    for (const e of this.G) {
+      v.optimisticStores.add(e);
+    }
+    this.G = v.optimisticStores;
+  }
+}
+function insertSubs(e, t = false) {
+  for (let n = e.O; n !== null; n = n.P) {
+    if (t) n.C.m |= l;
+    const e = n.C;
+    if (e.Y === y) {
+      if (!e.Z) {
+        e.Z = true;
+        e.$.enqueue(h, e.ee);
+      }
+      continue;
     }
-    _.add(x);
-    x.time = O;
-    for (let e = 0; e < this.M.length; e++) {
-      const t = this.M[e];
-      t.G = x;
-      x.pendingNodes.push(t);
-    }
-    for (let e = 0; e < this.T.length; e++) {
-      const t = this.T[e];
-      t.G = x;
-      x.optimisticNodes.push(t);
-    }
-    this.M = x.pendingNodes;
-    this.T = x.optimisticNodes;
+    const r = n.C.m & o ? O : _;
+    if (r.W > n.C.o) r.W = n.C.o;
+    insertIntoHeap(n.C, r);
   }
 }
-function notifySubs(e) {
-  for (let t = e.O; t !== null; t = t.C) {
-    const e = t.N.S & o ? m : b;
-    if (e.P > t.N.o) e.P = t.N.o;
-    insertIntoHeap(t.N, e);
+function finalizePureQueue(e = null, t = false) {
+  let n = !t;
+  if (_.S >= _.W) {
+    n = true;
+    runHeap(_, GlobalQueue.K);
   }
-}
-function runOptimistic(e = null) {
-  let t = !e;
-  const n = C.T;
-  S = true;
-  for (let t = 0; t < n.length; t++) {
-    const r = n[t];
-    if (!e && (!r.G || r.G.done) && r.U !== p) {
-      r.L = r.U;
-      r.U = p;
+  if (n) {
+    const t = A.D;
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e];
+      if (n.te !== g) {
+        n.ne = n.te;
+        n.te = g;
+        if (n.Y && n.Y !== y) n.Z = true;
+      }
+      if (n.R) GlobalQueue.U(n, false, true);
     }
-    r.G = e;
-    notifySubs(r);
-  }
-  C.T = [];
-  if (b._ >= b.P) {
-    t = true;
-    runHeap(b, GlobalQueue.D);
-  }
-  S = false;
-  t && runPending(C.M);
-}
-function runPending(e) {
-  for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    if (n.U !== p) {
-      n.L = n.U;
-      n.U = p;
-      if (n.J) n.X = true;
+    t.length = 0;
+    const n = e ? e.optimisticNodes : A.B;
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      const r = t.te;
+      if (r !== g && t.ne !== r) {
+        t.ne = r;
+        insertSubs(t, true);
+      }
+      t.te = g;
+      t.X = null;
+    }
+    n.length = 0;
+    const r = e ? e.optimisticStores : A.G;
+    if (GlobalQueue.L && r.size) {
+      for (const e of r) {
+        GlobalQueue.L(e);
+      }
+      r.clear();
+      schedule();
     }
-    if (n.H) GlobalQueue.B(n, false, true);
   }
-  e.length = 0;
 }
-function runTransitionPending(e, t) {
-  const n = e.slice();
-  for (let e = 0; e < n.length; e++) {
-    const r = n[e];
-    r.G = x;
-    if (r.Y) r.Y.Z(t);
+function trackOptimisticStore(e) {
+  A.G.add(e);
+  schedule();
+}
+function runTransitionPending(e) {
+  for (let t = 0; t < e.length; t++) {
+    e[t].X = v;
   }
 }
-const C = new GlobalQueue();
+const A = new GlobalQueue();
 function flush() {
-  while (v) {
-    C.flush();
+  while (P) {
+    A.flush();
   }
 }
 function runQueue(e, t) {
@@ -343,7 +403,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].$ & f) {
+    if (e.asyncNodes[n].re & c) {
       t = false;
       break;
     }
@@ -351,295 +411,393 @@ 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 = x;
+  const n = v;
   try {
-    x = e;
+    v = currentTransition(e);
     return t();
   } finally {
-    x = n;
+    v = n;
   }
 }
+function restoreTransition(e, t) {
+  A.initTransition(e);
+  const n = t();
+  flush();
+  return n;
+}
 function action(e) {
-  return (...t) => {
-    const n = e(...t);
-    C.initTransition();
-    let r = x;
-    r.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) {
-        r.actions.splice(r.actions.indexOf(n), 1);
-        x = r;
+  return (...t) =>
+    new Promise((n, r) => {
+      const i = e(...t);
+      A.initTransition();
+      let s = v;
+      s.actions.push(i);
+      const done = (e, t) => {
+        s = currentTransition(s);
+        const o = s.actions.indexOf(i);
+        if (o >= 0) s.actions.splice(o, 1);
+        v = s;
         schedule();
-        flush();
-        return;
-      }
-      const t = e.value;
-      if (t instanceof Promise) return t.then(step);
-      runInTransition(r, () => step(t));
-    };
-    runInTransition(r, () => step());
-  };
+        t ? r(t) : n(e);
+      };
+      const step = (e, t) => {
+        let n;
+        try {
+          n = t ? i.throw(e) : i.next(e);
+        } catch (e) {
+          return done(undefined, e);
+        }
+        if (n instanceof Promise)
+          return void n.then(run, e => restoreTransition(s, () => 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(s, () => step(e)),
+            e => restoreTransition(s, () => step(e, true))
+          );
+        restoreTransition(s, () => step(e.value));
+      };
+      step();
+    });
 }
-GlobalQueue.D = recompute;
-GlobalQueue.B = disposeChildren;
-let N = false;
-let k = false;
-let j = false;
-let P = null;
+GlobalQueue.K = recompute;
+GlobalQueue.U = disposeChildren;
 let W = false;
-let A = null;
+let j = false;
+let N = false;
+let E = false;
+let H = false;
+let I = false;
+let Q = null;
 function recompute(t, n = false) {
-  const i = t.J && t.G != x;
+  const i = t.Y;
   if (!n) {
-    if (t.G && x !== t.G && !i) C.initTransition(t);
-    deleteFromHeap(t, t.S & o ? m : b);
-    if (t.G) disposeChildren(t);
+    if (t.X && (!i || v) && v !== t.X) A.initTransition(t.X);
+    deleteFromHeap(t, t.m & o ? O : _);
+    if (t.X) disposeChildren(t);
     else {
       markDisposal(t);
-      t.ee = t.te;
-      t.ne = t.re;
-      t.te = null;
-      t.re = null;
-    }
-  }
-  const s = A;
-  A = t;
-  t.ie = null;
-  t.S = r;
-  t.se = O;
-  let u = t.U === p || (t.oe && t.G) ? t.L : t.U;
-  let d = t.o;
-  let h = t.$;
-  let y = t.K;
-  let g = N;
-  setStatusFlags(t, l | (h & a));
-  N = true;
+      t.ie = t.se;
+      t.oe = t.ue;
+      t.se = null;
+      t.ue = null;
+    }
+  }
+  const s = !!(t.m & l);
+  const u = t.le && t.te !== g;
+  const f = Q;
+  Q = t;
+  t.fe = null;
+  t.m = r;
+  t.ce = x;
+  let d = t.te === g ? t.ne : t.te;
+  let p = t.o;
+  let h = W;
+  let y = C;
+  W = true;
+  if (s) setOptimisticReadActive(true);
   try {
-    u = handleAsync(t, t.H(u));
-    t.$ &= ~a;
+    d = handleAsync(t, t.R(d));
+    clearStatus(t);
   } catch (e) {
     if (e instanceof NotReadyError) {
       if (e.cause !== t) link(e.cause, t);
-      setStatusFlags(t, (h & ~c) | f, e);
-    } else setStatusFlags(t, c, e);
+      notifyStatus(t, c, e);
+    } else notifyStatus(t, a, e);
   } finally {
-    N = g;
-  }
-  t.S = e;
-  A = s;
-  if (!(t.$ & f)) {
-    const e = t.ie;
-    let n = e !== null ? e.A : t.W;
-    if (n !== null) {
+    W = h;
+    t.m = e;
+    Q = f;
+  }
+  if (!t.J) {
+    const e = t.fe;
+    let r = e !== null ? e.N : t.j;
+    if (r !== null) {
       do {
-        n = unlinkSubs(n);
-      } while (n !== null);
-      if (e !== null) e.A = null;
-      else t.W = null;
-    }
-  }
-  const w = !t.ue || !t.ue(t.U === p || (t.oe && t.G) || i ? t.L : t.U, u);
-  const _ = t.$ !== h || t.K !== y;
-  t.le?.(_, h);
-  if (w || _) {
-    if (w) {
-      if (n || t.oe || i) t.L = u;
-      else t.U = u;
-      if (t.fe) setSignal(t.fe, u);
-    }
-    (!t.oe || S) && notifySubs(t);
-  } else if (t.o != d) {
-    for (let e = t.O; e !== null; e = e.C) {
-      insertIntoHeapHeight(e.N, e.N.S & o ? m : b);
+        r = unlinkSubs(r);
+      } while (r !== null);
+      if (e !== null) e.N = null;
+      else t.j = null;
+    }
+    const l = !t.ae || !t.ae(t.te === g ? t.ne : t.te, d);
+    if (l) {
+      if (n || (i && v !== t.X) || s) t.ne = d;
+      else t.te = d;
+      insertSubs(t, s || u);
+    } else if (t.o != p) {
+      for (let e = t.O; e !== null; e = e.P) {
+        insertIntoHeapHeight(e.C, e.C.m & o ? O : _);
+      }
     }
   }
-  t.oe && !S && C.T.push(t);
-  (!n || t.$ & f) && !t.G && C.M.push(t);
-  t.G && i && runInTransition(t.G, () => recompute(t));
+  setOptimisticReadActive(y);
+  (!n || t.re & c) && !t.X && A.D.push(t);
+  t.X && i && v !== t.X && runInTransition(t.X, () => recompute(t));
 }
 function handleAsync(e, t, n) {
   const r = typeof t === "object" && t !== null;
-  const i = r && t instanceof Promise;
-  const s = r && untrack(() => t[Symbol.asyncIterator]);
-  if (!i && !s) {
-    e.ce = null;
+  const i = r && untrack(() => t[Symbol.asyncIterator]);
+  const s = !i && r && untrack(() => typeof t.then === "function");
+  if (!s && !i) {
+    e.de = null;
     return t;
   }
-  e.ce = t;
-  if (i) {
-    t.then(r => {
-      if (e.ce !== t) return;
-      C.initTransition(e);
-      n?.(r) ?? setSignal(e, () => r);
-      flush();
-    }).catch(n => {
-      if (e.ce !== t) return;
-      C.initTransition(e);
-      setStatusFlags(e, c, n);
-      e.se = O;
-      notifySubs(e);
+  e.de = t;
+  let o;
+  const handleError = n => {
+    if (e.de !== t) return;
+    A.initTransition(e.X);
+    if (n instanceof NotReadyError) {
+      if (n.cause !== e) link(n.cause, e);
+      notifyStatus(e, c, n);
+    } else notifyStatus(e, a, n);
+    e.ce = x;
+  };
+  const asyncWrite = (r, i) => {
+    if (e.de !== t) return;
+    A.initTransition(e.X);
+    clearStatus(e);
+    if (n) n(r);
+    else if (e.le) {
+      const t = e.te !== g;
+      if (e.R) e.te = r;
+      if (!t) {
+        e.ne = r;
+        insertSubs(e);
+      }
+      e.ce = x;
       schedule();
-      flush();
-    });
+    } else setSignal(e, () => r);
+    flush();
+    i?.();
+  };
+  if (s) {
+    let n = false,
+      r = true;
+    t.then(
+      e => {
+        if (r) {
+          o = e;
+          n = true;
+        } else asyncWrite(e);
+      },
+      e => {
+        if (!r) handleError(e);
+      }
+    );
+    r = false;
+    if (!n) {
+      A.initTransition(e.X);
+      throw new NotReadyError(Q);
+    }
+  }
+  if (i) {
+    const n = t[Symbol.asyncIterator]();
+    let r = false;
+    const iterate = () => {
+      let e,
+        t = false,
+        i = true;
+      n.next().then(
+        n => {
+          if (i) {
+            e = n;
+            t = true;
+          } else if (!n.done) asyncWrite(n.value, iterate);
+        },
+        e => {
+          if (!i) handleError(e);
+        }
+      );
+      i = false;
+      if (t && !e.done) {
+        o = e.value;
+        r = true;
+        return iterate();
+      }
+      return t && e.done;
+    };
+    const i = iterate();
+    if (!r && !i) {
+      A.initTransition(e.X);
+      throw new NotReadyError(Q);
+    }
+  }
+  return o;
+}
+function clearStatus(e) {
+  e.re = f;
+  e.J = null;
+  updatePendingSignal(e);
+  if (e.pe) {
+    e.pe();
   } else {
-    (async () => {
-      try {
-        for await (let r of t) {
-          if (e.ce !== t) return;
-          C.initTransition(e);
-          n?.(r) ?? setSignal(e, () => r);
-          flush();
+    if (!e.X) {
+      for (let t = e.O; t !== null; t = t.P) {
+        if (t.C.re & c) {
+          insertIntoHeap(t.C, t.C.m & o ? O : _);
         }
-      } catch (n) {
-        if (e.ce !== t) return;
-        C.initTransition(e);
-        setStatusFlags(e, c, n);
-        e.se = O;
-        notifySubs(e);
-        schedule();
-        flush();
       }
-    })();
+    }
+    schedule();
+  }
+}
+function notifyStatus(e, t, n) {
+  e.re = t | (e.re & d);
+  e.J = n;
+  updatePendingSignal(e);
+  if (e.pe) return e.pe();
+  for (let r = e.O; r !== null; r = r.P) {
+    r.C.ce = x;
+    if (r.C.J !== n) {
+      !r.C.X && A.D.push(r.C);
+      notifyStatus(r.C, t, n);
+    }
+  }
+  for (let r = e.k; r !== null; r = r.A) {
+    for (let e = r.O; e !== null; e = e.P) {
+      e.C.ce = x;
+      if (e.C.J !== n) {
+        !e.C.X && A.D.push(e.C);
+        notifyStatus(e.C, t, n);
+      }
+    }
   }
-  C.initTransition(e);
-  throw new NotReadyError(A);
 }
 function updateIfNecessary(r) {
-  if (r.S & t) {
-    for (let e = r.W; e; e = e.A) {
-      const t = e.I;
-      const i = t.F || t;
-      if (i.H) {
+  if (r.m & t) {
+    for (let e = r.j; e; e = e.N) {
+      const t = e.H;
+      const i = t.I || t;
+      if (i.R) {
         updateIfNecessary(i);
       }
-      if (r.S & n) {
+      if (r.m & n) {
         break;
       }
     }
   }
-  if (r.S & n) {
+  if (r.m & n) {
     recompute(r);
   }
-  r.S = e;
+  r.m = e;
 }
 function unlinkSubs(e) {
-  const t = e.I;
-  const n = e.A;
-  const r = e.C;
-  const i = e.ae;
-  if (r !== null) r.ae = i;
-  else t.de = i;
-  if (i !== null) i.C = r;
+  const t = e.H;
+  const n = e.N;
+  const r = e.P;
+  const i = e.he;
+  if (r !== null) r.he = i;
+  else t.ye = i;
+  if (i !== null) i.P = r;
   else {
     t.O = r;
     if (r === null) {
-      t.he?.();
-      t.H && !t.pe && unobserved(t);
+      t.ge?.();
+      t.R && !t.we && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
-  deleteFromHeap(e, e.S & o ? m : b);
-  let t = e.W;
+  deleteFromHeap(e, e.m & o ? O : _);
+  let t = e.j;
   while (t !== null) {
     t = unlinkSubs(t);
   }
-  e.W = null;
+  e.j = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.ie;
-  if (n !== null && n.I === e) return;
+  const n = t.fe;
+  if (n !== null && n.H === e) return;
   let i = null;
-  const s = t.S & r;
+  const s = t.m & r;
   if (s) {
-    i = n !== null ? n.A : t.W;
-    if (i !== null && i.I === e) {
-      t.ie = i;
+    i = n !== null ? n.N : t.j;
+    if (i !== null && i.H === e) {
+      t.fe = i;
       return;
     }
   }
-  const o = e.de;
-  if (o !== null && o.N === t && (!s || isValidLink(o, t))) return;
-  const u = (t.ie = e.de = { I: e, N: t, A: i, ae: o, C: null });
-  if (n !== null) n.A = u;
-  else t.W = u;
-  if (o !== null) o.C = u;
+  const o = e.ye;
+  if (o !== null && o.C === t && (!s || isValidLink(o, t))) return;
+  const u = (t.fe = e.ye = { H: e, C: t, N: i, he: o, P: null });
+  if (n !== null) n.N = u;
+  else t.j = u;
+  if (o !== null) o.P = u;
   else e.O = u;
 }
 function isValidLink(e, t) {
-  const n = t.ie;
+  const n = t.fe;
   if (n !== null) {
-    let r = t.W;
+    let r = t.j;
     do {
       if (r === e) return true;
       if (r === n) break;
-      r = r.A;
+      r = r.N;
     } while (r !== null);
   }
   return false;
 }
-function setStatusFlags(e, t, n = null) {
-  e.$ = t;
-  e.K = n;
-}
 function markDisposal(e) {
-  let t = e.re;
+  let t = e.ue;
   while (t) {
-    t.S |= o;
-    if (t.S & i) {
-      deleteFromHeap(t, b);
-      insertIntoHeap(t, m);
+    t.m |= o;
+    if (t.m & i) {
+      deleteFromHeap(t, _);
+      insertIntoHeap(t, O);
     }
     markDisposal(t);
-    t = t.ye;
+    t = t.Se;
   }
 }
 function dispose(e) {
-  let t = e.W || null;
+  let t = e.j || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.W = null;
-  e.ie = null;
+  e.j = null;
+  e.fe = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e.S & u) return;
-  if (t) e.S = u;
-  let r = n ? e.ne : e.re;
+  if (e.m & u) return;
+  if (t) e.m = u;
+  let r = n ? e.oe : e.ue;
   while (r) {
-    const e = r.ye;
-    if (r.W) {
+    const e = r.Se;
+    if (r.j) {
       const e = r;
-      deleteFromHeap(e, e.S & o ? m : b);
-      let t = e.W;
+      deleteFromHeap(e, e.m & o ? O : _);
+      let t = e.j;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.W = null;
-      e.ie = null;
+      e.j = null;
+      e.fe = null;
     }
     disposeChildren(r, true);
     r = e;
   }
   if (n) {
-    e.ne = null;
+    e.oe = null;
   } else {
-    e.re = null;
-    e.ye = null;
+    e.ue = null;
+    e.Se = null;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.ee : e.te;
+  let n = t ? e.ie : e.se;
   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.ie = null) : (e.se = null);
 }
 function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.ge++);
+  if (e.id != null) return formatId(e.id, e.me++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(e, t) {
@@ -662,46 +820,45 @@ function formatId(e, t) {
 }
 function computed(t, n, r) {
   const i = {
-    id: r?.id ?? (A?.id != null ? getNextChildId(A) : undefined),
-    ue: r?.equals != null ? r.equals : isEqual,
-    we: !!r?.pureWrite,
-    he: r?.unobserved,
-    te: null,
-    _e: A?._e ?? C,
-    Se: A?.Se ?? g,
-    ge: 0,
-    H: t,
-    L: n,
+    id: r?.id ?? (Q?.id != null ? getNextChildId(Q) : undefined),
+    ae: r?.equals != null ? r.equals : isEqual,
+    be: !!r?.pureWrite,
+    ge: r?.unobserved,
+    se: null,
+    $: Q?.$ ?? A,
+    _e: Q?._e ?? S,
+    me: 0,
+    R: t,
+    ne: n,
     o: 0,
     k: null,
-    p: undefined,
-    h: null,
-    W: null,
-    ie: null,
+    h: undefined,
+    p: null,
+    j: null,
+    fe: null,
     O: null,
-    de: null,
-    i: A,
     ye: null,
-    re: null,
-    S: e,
-    $: a,
-    se: O,
-    U: p,
-    ee: null,
-    ne: null,
-    ce: null,
-    G: null
+    i: Q,
+    Se: null,
+    ue: null,
+    m: e,
+    re: d,
+    ce: x,
+    te: g,
+    ie: null,
+    oe: null,
+    de: null,
+    X: null
   };
-  if (r?.be) Object.assign(i, r.be);
-  i.h = i;
-  const s = A?.t ? A.u : A;
-  if (A) {
-    const e = A.re;
+  i.p = i;
+  const s = Q?.t ? Q.u : Q;
+  if (Q) {
+    const e = Q.ue;
     if (e === null) {
-      A.re = i;
+      Q.ue = i;
     } else {
-      i.ye = e;
-      A.re = i;
+      i.Se = e;
+      Q.ue = i;
     }
   }
   if (s) i.o = s.o + 1;
@@ -710,47 +867,99 @@ function computed(t, n, r) {
 }
 function signal(e, t, n = null) {
   const r = {
-    id: t?.id ?? (A?.id != null ? getNextChildId(A) : undefined),
-    ue: t?.equals != null ? t.equals : isEqual,
-    we: !!t?.pureWrite,
-    he: t?.unobserved,
-    L: e,
+    ae: t?.equals != null ? t.equals : isEqual,
+    be: !!t?.pureWrite,
+    ge: t?.unobserved,
+    ne: e,
     O: null,
-    de: null,
-    $: l,
-    se: O,
-    F: n,
-    j: n?.k || null,
-    U: p
+    ye: null,
+    ce: x,
+    I: n,
+    A: n?.k || null,
+    te: g
   };
   n && (n.k = r);
   return r;
 }
+function optimisticSignal(e, t) {
+  const n = signal(e, t);
+  n.le = true;
+  return n;
+}
+function optimisticComputed(e, t, n) {
+  const r = computed(e, t, n);
+  r.le = true;
+  return r;
+}
+function getPendingSignal(e) {
+  if (!e.Oe) {
+    e.Oe = optimisticSignal(false, { pureWrite: true });
+    if (computePendingState(e)) setSignal(e.Oe, true);
+  }
+  return e.Oe;
+}
+function computePendingState(e) {
+  if (e.te !== g) return true;
+  const t = e;
+  return !!(t.re & c && !(t.re & d));
+}
+function getPendingValueComputed(e) {
+  if (!e.xe) {
+    const t = I;
+    I = false;
+    e.xe = optimisticComputed(() => read(e));
+    I = t;
+  }
+  return e.xe;
+}
+function updatePendingSignal(e) {
+  if (e.Oe) setSignal(e.Oe, computePendingState(e));
+}
 function isEqual(e, t) {
   return e === t;
 }
 function untrack(e) {
-  if (!N) return e();
-  N = false;
+  if (!W) return e();
+  W = false;
   try {
     return e();
   } finally {
-    N = true;
+    W = true;
   }
 }
 function read(e) {
-  let t = A;
+  if (E) {
+    const t = e.I || e;
+    const n = getPendingSignal(t);
+    const r = E;
+    E = false;
+    if (read(n)) {
+      H = true;
+    }
+    E = r;
+    return e.ne;
+  }
+  if (I) {
+    const t = getPendingValueComputed(e);
+    const n = I;
+    I = false;
+    const r = read(t);
+    I = n;
+    if (t.re & c) return e.ne;
+    return r;
+  }
+  let t = Q;
   if (t?.t) t = t.u;
-  if (W && e.H) recompute(e);
-  if (t && N && !P && !j) {
-    if (e.H && e.S & u) recompute(e);
+  if (N && e.R) recompute(e);
+  if (t && W) {
+    if (e.R && e.m & u) recompute(e);
     link(e, t);
-    const n = e.F || e;
-    if (n.H) {
-      const r = e.S & o;
-      if (n.o >= (r ? m.P : b.P)) {
+    const n = e.I || e;
+    if (n.R) {
+      const r = e.m & o;
+      if (n.o >= (r ? O.W : _.W)) {
         markNode(t);
-        markHeap(r ? m : b);
+        markHeap(r ? O : _);
         updateIfNecessary(n);
       }
       const i = n.o;
@@ -759,110 +968,87 @@ function read(e) {
       }
     }
   }
-  if (j) {
-    if (!e.fe) {
-      e.fe = signal(e.L);
-      e.fe.oe = true;
-    }
-    j = false;
-    try {
-      return read(e.fe);
-    } finally {
-      j = true;
-    }
-  }
-  const n = e.F || e;
-  if (P) {
-    if (!n.Y) {
-      n.Y = signal(false);
-      n.Y.oe = true;
-      n.Y.Z = e => setSignal(n.Y, e);
-    }
-    const e = P;
-    P = null;
-    e.L = read(n.Y) || e.L;
-    P = e;
-  }
-  if (!P && n.$ & f) {
-    if ((t && !k) || n.$ & a || e.F) throw n.K;
-    else if (t && k) {
-      setStatusFlags(t, t.$ | f, n.K);
-    }
-  }
-  if (e.$ & c) {
-    if (e.se < O) {
+  const n = e.I || e;
+  if (t && !C && n.re & c && !(j && n.X && v !== n.X)) throw n.J;
+  if (e.R && e.re & a) {
+    if (e.ce < x) {
       recompute(e, true);
       return read(e);
-    } else {
-      throw e.K;
-    }
+    } else throw e.J;
   }
-  return !t || e.oe || e.U === p || (k && !P && (t.oe || (e.G && x !== e.G))) ? e.L : e.U;
+  return !t || C || e.te === g || (j && e.X && v !== e.X) ? e.ne : e.te;
 }
 function setSignal(e, t) {
-  if (typeof t === "function") {
-    t = t(e.U === p || (e.oe && e.G) ? e.L : e.U);
-  }
-  const n = !e.ue || !e.ue(e.U === p || (e.oe && e.G) ? e.L : e.U, t);
-  if (!n && !e.$) return t;
+  if (e.X && v !== e.X) A.initTransition(e.X);
+  const n = e.le && !k;
+  const r = n ? e.ne : e.te === g ? e.ne : e.te;
+  if (typeof t === "function") t = t(r);
+  const i = !e.ae || !e.ae(r, t);
+  if (!i) return t;
   if (n) {
-    if (e.oe) e.L = t;
-    else {
-      if (e.U === p) C.M.push(e);
-      e.U = t;
+    const n = e.te === g;
+    if (e.X && !n) {
+      A.initTransition(e.X);
     }
-    if (e.fe) setSignal(e.fe, t);
+    if (n) {
+      e.te = e.ne;
+      A.B.push(e);
+    }
+    e.ne = t;
+  } else {
+    if (e.te === g) A.D.push(e);
+    e.te = t;
   }
-  setStatusFlags(e, l);
-  e.se = O;
-  e.oe && !S ? C.T.push(e) : notifySubs(e);
+  updatePendingSignal(e);
+  if (e.xe) {
+    setSignal(e.xe, t);
+  }
+  e.ce = x;
+  insertSubs(e, n);
   schedule();
   return t;
 }
+const R = {};
 function getObserver() {
-  return N ? A : null;
+  if (E || I) return R;
+  return W ? Q : null;
 }
 function getOwner() {
-  return A;
+  return Q;
 }
 function onCleanup(e) {
-  if (!A) return e;
-  const t = A;
-  if (!t.te) {
-    t.te = e;
-  } else if (Array.isArray(t.te)) {
-    t.te.push(e);
-  } else {
-    t.te = [t.te, e];
-  }
+  if (!Q) return e;
+  if (!Q.se) Q.se = e;
+  else if (Array.isArray(Q.se)) Q.se.push(e);
+  else Q.se = [Q.se, e];
   return e;
 }
 function createOwner(e) {
-  const t = A;
+  const t = Q;
   const n = {
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
     t: true,
     u: t?.t ? t.u : t,
-    re: null,
-    ye: null,
-    te: null,
-    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
-    _e: t?._e ?? C,
-    Se: t?.Se || g,
-    ge: 0,
-    ee: null,
-    ne: null,
+    ue: null,
+    Se: null,
+    se: null,
+    $: t?.$ ?? A,
+    _e: t?._e || S,
+    me: 0,
+    ie: null,
+    oe: null,
     i: t,
     dispose(e = true) {
       disposeChildren(n, e);
     }
   };
   if (t) {
-    const e = t.re;
+    const e = t.ue;
     if (e === null) {
-      t.re = n;
+      t.ue = n;
     } else {
-      n.ye = e;
-      t.re = n;
+      n.Se = e;
+      t.ue = n;
     }
   }
   return n;
@@ -872,64 +1058,66 @@ function createRoot(e, t) {
   return runWithOwner(n, () => e(n.dispose));
 }
 function runWithOwner(e, t) {
-  const n = A;
-  A = e;
+  const n = Q;
+  const r = W;
+  Q = e;
+  W = false;
   try {
     return t();
   } finally {
-    A = n;
+    Q = n;
+    W = r;
   }
 }
 function staleValues(e, t = true) {
-  const n = k;
-  k = t;
+  const n = j;
+  j = t;
   try {
     return e();
   } finally {
-    k = n;
+    j = n;
   }
 }
 function pending(e) {
-  const t = j;
-  j = true;
+  const t = I;
+  I = true;
   try {
-    return staleValues(e, false);
+    return e();
   } finally {
-    j = t;
+    I = t;
   }
 }
 function isPending(e) {
-  const t = P;
-  P = { L: false };
+  const t = E;
+  const n = H;
+  E = true;
+  H = false;
   try {
-    staleValues(e);
-    return P.L;
-  } catch (e) {
-    if (!(e instanceof NotReadyError)) return false;
-    throw e;
+    e();
+    return H;
   } finally {
-    P = t;
+    E = t;
+    H = n;
   }
 }
 function refresh(e) {
-  let t = W;
-  W = true;
+  let t = N;
+  N = true;
   try {
     if (typeof e !== "function") {
-      recompute(e[w]);
+      recompute(e[m]);
       return e;
     }
     return untrack(e);
   } finally {
-    W = t;
+    N = t;
     if (!t) {
       schedule();
-      flush();
     }
   }
 }
 function isRefreshing() {
-  return W;
+  return N;
 }
 function createContext(e, t) {
   return { id: Symbol(t), defaultValue: e };
@@ -938,7 +1126,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.Se[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t._e[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -948,73 +1136,92 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.Se = { ...n.Se, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n._e = { ...n._e, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.Se[e.id]);
+  return !isUndefined(t?._e[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
 }
 function effect(e, t, n, r, i) {
   let s = false;
-  const o = computed(e, r, {
+  const o = computed(i?.render ? t => staleValues(() => e(t)) : e, r, {
     ...i,
-    be: {
-      X: true,
-      me: r,
-      Oe: t,
-      xe: n,
-      ve: undefined,
-      J: i?.render ? d : h,
-      le(e, t) {
-        if (s) {
-          const n = this.$ && this.$ === t && e;
-          this.X = !(this.$ & c) && !(this.$ & f & ~t) && !n;
-          if (this.X) this._e.enqueue(this.J, runEffect.bind(this));
-        }
-        if (this.$ & c) {
-          let e = this.K;
-          this._e.notify(this, f, 0);
-          if (this.J === h) {
-            try {
-              return this.xe
-                ? this.xe(e, () => {
-                    this.ve?.();
-                    this.ve = undefined;
-                  })
-                : console.error(e);
-            } catch (t) {
-              e = t;
-            }
-          }
-          if (!this._e.notify(this, c, c)) throw e;
-        } else if (this.J === d) {
-          this._e.notify(this, f | c, this.$);
+    equals: () => {
+      o.Z = !o.J;
+      if (s) o.$.enqueue(o.Y, runEffect.bind(o));
+      return false;
+    },
+    lazy: true
+  });
+  o.ve = r;
+  o.Pe = t;
+  o.Ce = n;
+  o.ke = undefined;
+  o.Y = i?.render ? p : h;
+  o.pe = () => {
+    if (o.re & a) {
+      let e = o.J;
+      o.$.notify(o, c, 0);
+      if (o.Y === h) {
+        try {
+          return o.Ce
+            ? o.Ce(e, () => {
+                o.ke?.();
+                o.ke = undefined;
+              })
+            : console.error(e);
+        } catch (t) {
+          e = t;
         }
       }
-    }
-  });
+      if (!o.$.notify(o, a, a)) throw e;
+    } else if (o.Y === p) o.$.notify(o, c | a, o.re);
+  };
+  recompute(o, true);
+  !i?.defer && (o.Y === h ? o.$.enqueue(o.Y, runEffect.bind(o)) : runEffect.call(o));
   s = true;
-  if (o.J === d) o.H = t => staleValues(() => e(t));
-  !i?.defer &&
-    !(o.$ & (c | f)) &&
-    (o.J === h ? o._e.enqueue(o.J, runEffect.bind(o)) : runEffect.call(o));
-  onCleanup(() => o.ve?.());
+  onCleanup(() => o.ke?.());
 }
 function runEffect() {
-  if (!this.X || this.S & u) return;
-  this.ve?.();
-  this.ve = undefined;
+  if (!this.Z || this.m & u) return;
+  this.ke?.();
+  this.ke = undefined;
   try {
-    this.ve = this.Oe(this.L, this.me);
+    this.ke = this.Pe(this.ne, this.ve);
   } catch (e) {
-    if (!this._e.notify(this, c, c)) throw e;
+    if (!this.$.notify(this, a, a)) throw e;
   } finally {
-    this.me = this.L;
-    this.X = false;
+    this.ve = this.ne;
+    this.Z = false;
   }
 }
+function trackedEffect(e, t) {
+  const run = () => {
+    if (!n.Z || n.m & u) return;
+    n.Z = false;
+    recompute(n);
+  };
+  const n = computed(
+    () => {
+      try {
+        n.ke?.();
+        n.ke = undefined;
+        n.ke = staleValues(e) || undefined;
+      } finally {
+      }
+    },
+    undefined,
+    { ...t, lazy: true, pureWrite: true }
+  );
+  n.ke = undefined;
+  n.Z = true;
+  n.Y = y;
+  n.ee = run;
+  n.$.enqueue(h, run);
+  onCleanup(() => n.ke?.());
+}
 function createSignal(e, t, n) {
   if (typeof e === "function") {
     const r = computed(e, t, n);
@@ -1028,12 +1235,14 @@ function createMemo(e, t, n) {
   return read.bind(null, r);
 }
 function createEffect(e, t, n, r) {
-  void effect(e, t.effect || t, t.error, n, r);
+  effect(e, t.effect || t, t.error, n, r);
 }
 function createRenderEffect(e, t, n, r) {
-  void effect(e, t, undefined, n, { render: true, ...r });
+  effect(e, t, undefined, n, { render: true, ...r });
+}
+function createTrackedEffect(e, t) {
+  trackedEffect(e, t);
 }
-function createTrackedEffect(e, t) {}
 function createReaction(e, t) {
   let n = undefined;
   onCleanup(() => n?.());
@@ -1070,42 +1279,19 @@ function resolve(e) {
   });
 }
 function createOptimistic(e, t, n) {
-  if (typeof e === "function") {
-    const r = computed(
-      t => {
-        const n = getOwner();
-        const r = e(t);
-        if (n.$ & a) return r;
-        n.U = r;
-        return t;
-      },
-      t,
-      n
-    );
-    r.oe = true;
-    return [read.bind(null, r), setSignal.bind(null, r)];
-  }
-  const r = signal(e, t);
-  r.oe = true;
-  return [
-    read.bind(null, r),
-    t => {
-      r.U = e;
-      return setSignal(r, t);
-    }
-  ];
+  const r = typeof e === "function" ? optimisticComputed(e, t, n) : optimisticSignal(e, t);
+  return [read.bind(null, r), setSignal.bind(null, r)];
 }
 function onSettled(e) {
-  let t;
-  const n = getOwner();
-  if (n) onCleanup(() => t?.());
-  C.enqueue(h, () => {
-    t = e();
-    !n && t?.();
-  });
+  getOwner()
+    ? createTrackedEffect(() => untrack(e))
+    : A.enqueue(h, () => {
+        const t = e();
+        t?.();
+      });
 }
 function unwrap(e) {
-  return e?.[H]?.[T] ?? e;
+  return e?.[V]?.[U] ?? e;
 }
 function getOverrideValue(e, t, n, r) {
   return t && r in t ? t[r] : e[r];
@@ -1116,108 +1302,108 @@ function getAllKeys(e, t, n) {
   return Array.from(new Set([...r, ...i]));
 }
 function applyState(e, t, n, r) {
-  const i = t?.[H];
+  const i = t?.[V];
   if (!i) return;
-  const s = i[q];
-  const o = i[M];
-  let u = i[T];
+  const s = i[G];
+  const o = i[K];
+  let u = i[U];
   if (e === s && !o) return;
-  (i[K] || U).set(e, i[Q]);
-  i[q] = e;
-  i[M] = undefined;
+  (i[X] || $).set(e, i[M]);
+  i[G] = e;
+  i[K] = undefined;
   if (Array.isArray(s)) {
     let t = false;
     const l = getOverrideValue(s, o, u, "length");
     if (e.length && l && e[0] && n(e[0]) != null) {
-      let f, c, a, d, h, p, y, g;
+      let f, c, a, d, p, h, y, g;
       for (
         a = 0, d = Math.min(l, e.length);
-        a < d && ((p = getOverrideValue(s, o, u, a)) === e[a] || (p && e[a] && n(p) === n(e[a])));
+        a < d && ((h = getOverrideValue(s, o, u, a)) === e[a] || (h && e[a] && n(h) === n(e[a])));
         a++
       ) {
-        applyState(e[a], wrap(p, i), n, r);
+        applyState(e[a], wrap(h, i), n, r);
       }
       const w = new Array(e.length),
-        _ = new Map();
+        S = new Map();
       for (
-        d = l - 1, h = e.length - 1;
+        d = l - 1, p = e.length - 1;
         d >= a &&
-        h >= a &&
-        ((p = getOverrideValue(s, o, u, d)) === e[h] || (p && e[h] && n(p) === n(e[h])));
-        d--, h--
+        p >= a &&
+        ((h = getOverrideValue(s, o, u, d)) === e[p] || (h && e[p] && n(h) === n(e[p])));
+        d--, p--
       ) {
-        w[h] = p;
+        w[p] = h;
       }
-      if (a > h || a > d) {
-        for (c = a; c <= h; c++) {
+      if (a > p || a > d) {
+        for (c = a; c <= p; c++) {
           t = true;
-          i[T][c] && setSignal(i[T][c], wrap(e[c], i));
+          i[U][c] && setSignal(i[U][c], wrap(e[c], i));
         }
         for (; c < e.length; c++) {
           t = true;
           const s = wrap(w[c], i);
-          i[T][c] && setSignal(i[T][c], s);
+          i[U][c] && setSignal(i[U][c], s);
           applyState(e[c], s, n, r);
         }
-        t && i[T][I] && setSignal(i[T][I], void 0);
-        l !== e.length && i[T].length && setSignal(i[T].length, e.length);
+        t && i[U][q] && setSignal(i[U][q], void 0);
+        l !== e.length && i[U].length && setSignal(i[U].length, e.length);
         return;
       }
-      y = new Array(h + 1);
-      for (c = h; c >= a; c--) {
-        p = e[c];
-        g = p ? n(p) : p;
-        f = _.get(g);
+      y = new Array(p + 1);
+      for (c = p; c >= a; c--) {
+        h = e[c];
+        g = h ? n(h) : h;
+        f = S.get(g);
         y[c] = f === undefined ? -1 : f;
-        _.set(g, c);
+        S.set(g, c);
       }
       for (f = a; f <= d; f++) {
-        p = getOverrideValue(s, o, u, f);
-        g = p ? n(p) : p;
-        c = _.get(g);
+        h = getOverrideValue(s, o, u, f);
+        g = h ? n(h) : h;
+        c = S.get(g);
         if (c !== undefined && c !== -1) {
-          w[c] = p;
+          w[c] = h;
           c = y[c];
-          _.set(g, c);
+          S.set(g, c);
         }
       }
       for (c = a; c < e.length; c++) {
         if (c in w) {
           const t = wrap(w[c], i);
-          i[T][c] && setSignal(i[T][c], t);
+          i[U][c] && setSignal(i[U][c], t);
           applyState(e[c], t, n, r);
-        } else i[T][c] && setSignal(i[T][c], wrap(e[c], i));
+        } else i[U][c] && setSignal(i[U][c], wrap(e[c], i));
       }
       if (a < 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);
-        isWrappable(l) ? applyState(e[t], wrap(l, i), n, r) : i[T][t] && setSignal(i[T][t], e[t]);
+        isWrappable(l) ? applyState(e[t], wrap(l, i), n, r) : i[U][t] && setSignal(i[U][t], e[t]);
       }
     }
     if (l !== e.length) {
       t = true;
-      i[T].length && setSignal(i[T].length, e.length);
+      i[U].length && setSignal(i[U].length, e.length);
     }
-    t && i[T][I] && setSignal(i[T][I], void 0);
+    t && i[U][q] && setSignal(i[U][q], void 0);
     return;
   }
   if (u) {
-    const t = u[I];
+    const t = u[q];
     const l = t || r ? getAllKeys(s, o, e) : Object.keys(u);
     for (let f = 0, c = l.length; f < c; f++) {
       const c = l[f];
       const a = u[c];
       const d = unwrap(getOverrideValue(s, o, u, c));
-      let h = unwrap(e[c]);
-      if (d === h) continue;
-      if (!d || !isWrappable(d) || (n(d) != null && n(d) !== n(h))) {
+      let p = unwrap(e[c]);
+      if (d === p) continue;
+      if (!d || !isWrappable(d) || (n(d) != null && n(d) !== n(p))) {
         t && setSignal(t, void 0);
-        a && setSignal(a, isWrappable(h) ? wrap(h, i) : h);
-      } else applyState(h, wrap(d, i), n, r);
+        a && setSignal(a, isWrappable(p) ? wrap(p, i) : p);
+      } else applyState(p, wrap(d, i), n, r);
     }
   }
-  if ((u = i[D])) {
+  if ((u = i[L])) {
     const t = Object.keys(u);
     for (let n = 0, r = t.length; n < r; n++) {
       const r = t[n];
@@ -1239,9 +1425,9 @@ function createProjectionInternal(e, t = {}, n) {
   let r;
   const i = new WeakMap();
   const wrapper = e => {
-    e[B] = wrapProjection;
-    e[K] = i;
-    Object.defineProperty(e, G, {
+    e[J] = wrapProjection;
+    e[X] = i;
+    Object.defineProperty(e, Y, {
       get() {
         return r;
       },
@@ -1250,105 +1436,113 @@ function createProjectionInternal(e, t = {}, n) {
   };
   const wrapProjection = e => {
     if (i.has(e)) return i.get(e);
-    if (e[H]?.[B] === wrapProjection) return e;
-    const t = createStoreProxy(e, J, wrapper);
+    if (e[V]?.[J] === wrapProjection) return e;
+    const t = createStoreProxy(e, ne, wrapper);
     i.set(e, t);
     return t;
   };
   const s = wrapProjection(t);
   r = computed(() => {
     const t = getOwner();
-    storeSetter(new Proxy(s, E), r => {
+    storeSetter(new Proxy(s, T), r => {
       const i = handleAsync(t, e(r), e => {
-        e !== s && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        e !== r && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
         setSignal(t, undefined);
       });
-      i !== s && i !== undefined && reconcile(i, n?.key || "id", n?.all)(s);
+      i !== r && i !== undefined && reconcile(i, n?.key || "id", n?.all)(s);
     });
   });
-  r.pe = true;
+  r.we = true;
   return { store: s, node: r };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
 }
-const E = {
+const T = {
   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, E) : n;
+    return typeof n === "object" && n !== null ? new Proxy(n, T) : 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;
   }
 };
-const I = Symbol(0),
+const q = Symbol(0),
   F = Symbol(0),
-  H = Symbol(0),
-  Q = Symbol(0),
-  R = Symbol(0);
-const V = new WeakMap();
-const q = "v",
-  M = "o",
-  T = "n",
-  D = "h",
-  B = "w",
-  K = "l",
-  G = "f";
-function createStoreProxy(e, t = J, n) {
+  V = Symbol(0),
+  M = Symbol(0),
+  D = Symbol(0);
+const B = new WeakMap();
+const G = "v",
+  K = "o",
+  z = "x",
+  U = "n",
+  L = "h",
+  J = "w",
+  X = "l",
+  Y = "f",
+  Z = "p";
+function createStoreProxy(e, t = ne, n) {
   let r;
   if (Array.isArray(e)) {
     r = [];
     r.v = e;
   } else r = { v: e };
   n && n(r);
-  return (r[Q] = new Proxy(r, t));
+  return (r[M] = new Proxy(r, t));
 }
-const U = new WeakMap();
+const $ = new WeakMap();
 function wrap(e, t) {
-  if (t?.[B]) return t[B](e, t);
-  let n = e[Q] || U.get(e);
-  if (!n) U.set(e, (n = createStoreProxy(e)));
+  if (t?.[J]) return t[J](e, t);
+  let n = e[M] || $.get(e);
+  if (!n) $.set(e, (n = createStoreProxy(e)));
   return n;
 }
 function isWrappable(e) {
   return e != null && typeof e === "object" && !Object.isFrozen(e);
 }
-let L = false;
+let ee = false;
 function setWriteOverride(e) {
-  L = e;
+  ee = e;
 }
 function writeOnly(e) {
-  return L || !!z?.has(e);
+  return ee || !!te?.has(e);
 }
 function getNodes(e, t) {
   let n = e[t];
   if (!n) e[t] = n = Object.create(null);
   return n;
 }
-function getNode(e, t, n, r, i = isEqual) {
+function getNode(e, t, n, r, i = isEqual, s) {
   if (e[t]) return e[t];
-  return (e[t] = signal(
+  const o = signal(
     n,
     {
       equals: i,
@@ -1357,10 +1551,12 @@ function getNode(e, t, n, r, i = isEqual) {
       }
     },
     r
-  ));
+  );
+  if (s) o.le = true;
+  return (e[t] = o);
 }
-function trackSelf(e, t = I) {
-  getObserver() && read(getNode(getNodes(e, T), t, undefined, e[G], false));
+function trackSelf(e, t = q) {
+  getObserver() && read(getNode(getNodes(e, U), t, undefined, e[Y], false, e[Z]));
 }
 function getKeys(e, t, n = true) {
   const r = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -1368,7 +1564,7 @@ function getKeys(e, t, n = true) {
   const i = new Set(r);
   const s = Reflect.ownKeys(t);
   for (const e of s) {
-    if (t[e] !== R) i.add(e);
+    if (t[e] !== D) i.add(e);
     else i.delete(e);
   }
   return Array.from(i);
@@ -1376,125 +1572,161 @@ function getKeys(e, t, n = true) {
 function getPropertyDescriptor(e, t, n) {
   let r = e;
   if (t && n in t) {
-    if (r[n] === R) return void 0;
+    if (r[n] === D) return void 0;
     if (!(n in r)) r = t;
   }
   return Reflect.getOwnPropertyDescriptor(r, n);
 }
-let z = null;
-const J = {
+let te = null;
+const ne = {
   get(e, t, n) {
-    if (t === H) return e;
-    if (t === Q) return n;
-    if (t === w) return e[G];
-    if (t === I || t === F) {
+    if (t === V) return e;
+    if (t === M) return n;
+    if (t === m) return e[Y];
+    if (t === q || t === F) {
       trackSelf(e, t);
       return n;
     }
-    const r = getNodes(e, T);
+    const r = getNodes(e, U);
     const i = r[t];
-    const s = e[M] && t in e[M];
-    const o = !!e[q][H];
-    const u = s ? e[M] : e[q];
+    const s = e[z] && t in e[z];
+    const o = s || (e[K] && t in e[K]);
+    const u = !!e[G][V];
+    const l = s ? e[z] : e[K] && t in e[K] ? e[K] : e[G];
     if (!i) {
-      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 = i && (s || !o) ? (i.U !== p ? i.U : i.L) : u[t];
-      n === R && (n = undefined);
+      let n = i && (o || !u) ? (i.te !== g ? (i.le ? i.ne : i.te) : i.ne) : l[t];
+      n === D && (n = undefined);
       if (!isWrappable(n)) return n;
       const r = wrap(n, e);
-      z?.add(r);
+      te?.add(r);
       return r;
     }
-    let l = i ? (s || !o ? read(r[t]) : (read(r[t]), u[t])) : u[t];
-    l === R && (l = undefined);
+    let f = i ? (o || !u ? read(r[t]) : (read(r[t]), l[t])) : l[t];
+    f === D && (f = undefined);
     if (!i) {
-      if (!s && typeof l === "function" && !u.hasOwnProperty(t)) {
+      if (!o && typeof f === "function" && !l.hasOwnProperty(t)) {
         let t;
-        return !Array.isArray(e[q]) && (t = Object.getPrototypeOf(e[q])) && t !== Object.prototype
-          ? l.bind(u)
-          : l;
+        return !Array.isArray(e[G]) && (t = Object.getPrototypeOf(e[G])) && t !== Object.prototype
+          ? f.bind(l)
+          : f;
       } else if (getObserver()) {
-        return read(getNode(r, t, isWrappable(l) ? wrap(l, e) : l, e[G]));
+        return read(getNode(r, t, isWrappable(f) ? wrap(f, e) : f, e[Y], isEqual, e[Z]));
       }
     }
-    return isWrappable(l) ? wrap(l, e) : l;
+    return isWrappable(f) ? wrap(f, e) : f;
   },
   has(e, t) {
-    if (t === Q || t === I || t === "__proto__") return true;
-    const n = e[M] && t in e[M] ? e[M][t] !== R : t in e[q];
-    getObserver() && read(getNode(getNodes(e, D), t, n, e[G]));
+    if (t === M || t === q || t === "__proto__") return true;
+    const n = e[z] && t in e[z] ? e[z][t] !== D : e[K] && t in e[K] ? e[K][t] !== D : t in e[G];
+    getObserver() && read(getNode(getNodes(e, L), t, n, e[Y], isEqual, e[Z]));
     return n;
   },
   set(e, t, n) {
-    const r = e[Q];
+    const r = e[M];
     if (writeOnly(r)) {
+      if (e[Z]) {
+        const t = e[Y];
+        if (t?.X) {
+          A.initTransition(t.X);
+        }
+      }
       untrack(() => {
-        const i = e[q];
+        const i = e[G];
         const s = i[t];
-        const o = e[M] && t in e[M] ? e[M][t] : s;
-        const u = n?.[H]?.[q] ?? n;
-        if (o === u) return true;
-        const l = e[M]?.length || i.length;
-        if (u !== undefined && u === s) delete e[M][t];
-        else (e[M] || (e[M] = Object.create(null)))[t] = u;
-        const f = isWrappable(u);
-        if (isWrappable(o)) {
-          const e = V.get(o);
-          e && (e instanceof Set ? e.delete(r) : V.delete(o));
+        const o = e[Z] && !k;
+        const u = o ? z : K;
+        if (o) trackOptimisticStore(r);
+        const l = e[z] && t in e[z] ? e[z][t] : e[K] && t in e[K] ? e[K][t] : s;
+        const f = n?.[V]?.[G] ?? n;
+        if (l === f) return true;
+        const c = e[z]?.length || e[K]?.length || i.length;
+        if (f !== undefined && f === s) delete e[u][t];
+        else (e[u] || (e[u] = Object.create(null)))[t] = f;
+        const a = isWrappable(f);
+        if (isWrappable(l)) {
+          const e = B.get(l);
+          e && (e instanceof Set ? e.delete(r) : B.delete(l));
         }
-        if (recursivelyNotify(r, U) && f) recursivelyAddParent(u, r);
-        e[D]?.[t] && setSignal(e[D][t], true);
-        const c = getNodes(e, T);
-        c[t] && setSignal(c[t], () => (f ? wrap(u, e) : u));
+        if (recursivelyNotify(r, $) && a) recursivelyAddParent(f, r);
+        e[L]?.[t] && setSignal(e[L][t], true);
+        const d = getNodes(e, U);
+        d[t] && setSignal(d[t], () => (a ? wrap(f, e) : f));
         if (Array.isArray(i)) {
-          const e = parseInt(t) + 1;
-          if (e > l) c.length && setSignal(c.length, e);
+          if (t === "length") {
+            d.length && setSignal(d.length, f);
+          } else {
+            const e = parseInt(t) + 1;
+            if (e > c) d.length && setSignal(d.length, e);
+          }
         }
-        c[I] && setSignal(c[I], undefined);
+        d[q] && setSignal(d[q], undefined);
       });
     }
     return true;
   },
   deleteProperty(e, t) {
-    if (writeOnly(e[Q]) && e[M]?.[t] !== R) {
+    const n = e[z]?.[t] === D;
+    const r = e[K]?.[t] === D;
+    if (writeOnly(e[M]) && !n && !r) {
       untrack(() => {
-        const n = e[M] && t in e[M] ? e[M][t] : e[q][t];
-        if (t in e[q]) {
-          (e[M] || (e[M] = Object.create(null)))[t] = R;
-        } else if (e[M] && t in e[M]) {
-          delete e[M][t];
+        const n = e[Z] && !k;
+        const r = n ? z : K;
+        if (n) trackOptimisticStore(e[M]);
+        const i = e[z] && t in e[z] ? e[z][t] : e[K] && t in e[K] ? e[K][t] : e[G][t];
+        if (t in e[G] || (e[K] && t in e[K])) {
+          (e[r] || (e[r] = Object.create(null)))[t] = D;
+        } else if (e[r] && t in e[r]) {
+          delete e[r][t];
         } else return true;
-        if (isWrappable(n)) {
-          const t = V.get(n);
-          t && (t instanceof Set ? t.delete(e) : V.delete(n));
+        if (isWrappable(i)) {
+          const t = B.get(i);
+          t && (t instanceof Set ? t.delete(e) : B.delete(i));
         }
-        if (e[D]?.[t]) setSignal(e[D][t], false);
-        const r = getNodes(e, T);
-        r[t] && setSignal(r[t], undefined);
-        r[I] && setSignal(r[I], undefined);
+        if (e[L]?.[t]) setSignal(e[L][t], false);
+        const s = getNodes(e, U);
+        s[t] && setSignal(s[t], undefined);
+        s[q] && setSignal(s[q], undefined);
       });
     }
     return true;
   },
   ownKeys(e) {
     trackSelf(e);
-    return getKeys(e[q], e[M], false);
+    let t = getKeys(e[G], e[K], false);
+    if (e[z]) {
+      const n = new Set(t);
+      for (const t of Reflect.ownKeys(e[z])) {
+        if (e[z][t] !== D) n.add(t);
+        else n.delete(t);
+      }
+      t = Array.from(n);
+    }
+    return t;
   },
   getOwnPropertyDescriptor(e, t) {
-    if (t === Q) return { value: e[Q], writable: true, configurable: true };
-    return getPropertyDescriptor(e[q], e[M], t);
+    if (t === M) return { value: e[M], writable: true, configurable: true };
+    if (e[z] && t in e[z]) {
+      if (e[z][t] === D) return undefined;
+      const n = getPropertyDescriptor(e[G], e[K], t);
+      if (n) {
+        return { ...n, value: e[z][t] };
+      }
+      return { value: e[z][t], writable: true, enumerable: true, configurable: true };
+    }
+    return getPropertyDescriptor(e[G], e[K], t);
   },
   getPrototypeOf(e) {
-    return Object.getPrototypeOf(e[q]);
+    return Object.getPrototypeOf(e[G]);
   }
 };
 function storeSetter(e, t) {
-  const n = z;
-  z = new Set();
-  z.add(e);
+  const n = te;
+  te = new Set();
+  te.add(e);
   try {
     const n = t(e);
     if (n !== e && n !== undefined) {
@@ -1510,8 +1742,8 @@ function storeSetter(e, t) {
       }
     }
   } finally {
-    z.clear();
-    z = n;
+    te.clear();
+    te = n;
   }
 }
 function createStore(e, t, n) {
@@ -1520,17 +1752,17 @@ function createStore(e, t, n) {
   return [i, e => storeSetter(i, e)];
 }
 function recursivelyNotify(e, t) {
-  let n = e[H] || t?.get(e)?.[H];
+  let n = e[V] || t?.get(e)?.[V];
   let r = false;
   if (n) {
-    const e = getNodes(n, T)[F];
+    const e = getNodes(n, U)[F];
     if (e) {
       setSignal(e, undefined);
       r = true;
     }
-    t = n[K] || t;
+    t = n[X] || t;
   }
-  const i = V.get(n?.[q] || e);
+  const i = B.get(n?.[G] || e);
   if (!i) return r;
   if (i instanceof Set) {
     for (let e of i) r = recursivelyNotify(e, t) || r;
@@ -1539,16 +1771,16 @@ function recursivelyNotify(e, t) {
 }
 function recursivelyAddParent(e, t) {
   let n;
-  const r = e[H];
+  const r = e[V];
   if (r) {
-    n = r[M];
-    e = r[q];
+    n = r[K];
+    e = r[G];
   }
   if (t) {
-    let n = V.get(e);
-    if (!n) V.set(e, t);
+    let n = B.get(e);
+    if (!n) B.set(e, t);
     else if (n !== t) {
-      if (!(n instanceof Set)) V.set(e, (n = new Set([n])));
+      if (!(n instanceof Set)) B.set(e, (n = new Set([n])));
       else if (n.has(t)) return;
       n.add(t);
     } else return;
@@ -1573,19 +1805,87 @@ function deep(e) {
   return e[F];
 }
 function createOptimisticStore(e, t, n) {
-  return [];
+  GlobalQueue.L ||= clearOptimisticStore;
+  const r = typeof e === "function";
+  const i = (r ? t : e) ?? {};
+  const s = r ? e : undefined;
+  const { store: o } = createOptimisticProjectionInternal(s, i, n);
+  return [o, e => storeSetter(o, e)];
+}
+function clearOptimisticStore(e) {
+  const t = e[V];
+  if (!t || !t[z]) return;
+  const n = t[z];
+  const r = t[U];
+  if (r) {
+    for (const e of Reflect.ownKeys(n)) {
+      if (r[e]) {
+        const n = t[K] && e in t[K] ? t[K][e] : t[G][e];
+        const i = n === D ? undefined : n;
+        setSignal(r[e], isWrappable(i) ? wrap(i, t) : i);
+      }
+    }
+    r[q] && setSignal(r[q], undefined);
+  }
+  delete t[z];
+}
+function createOptimisticProjectionInternal(e, t = {}, n) {
+  let r;
+  const i = new WeakMap();
+  const wrapper = e => {
+    e[J] = wrapProjection;
+    e[X] = i;
+    e[Z] = true;
+    Object.defineProperty(e, Y, {
+      get() {
+        return r;
+      },
+      configurable: true
+    });
+  };
+  const wrapProjection = e => {
+    if (i.has(e)) return i.get(e);
+    if (e[V]?.[J] === wrapProjection) return e;
+    const t = createStoreProxy(e, ne, wrapper);
+    i.set(e, t);
+    return t;
+  };
+  const s = wrapProjection(t);
+  if (e) {
+    r = computed(() => {
+      const t = getOwner();
+      setProjectionWriteActive(true);
+      try {
+        storeSetter(new Proxy(s, T), r => {
+          const i = handleAsync(t, e(r), e => {
+            setProjectionWriteActive(true);
+            try {
+              e !== r && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+            } finally {
+              setProjectionWriteActive(false);
+            }
+          });
+          i !== r && i !== undefined && reconcile(i, n?.key || "id", n?.all)(s);
+        });
+      } finally {
+        setProjectionWriteActive(false);
+      }
+    });
+    r.we = true;
+  }
+  return { store: s, node: r };
 }
 function snapshot(e, t, n) {
   let r, i, s, o, u, l;
   if (!isWrappable(e)) return e;
   if (t && t.has(e)) return t.get(e);
   if (!t) t = new Map();
-  if ((r = e[H] || n?.get(e)?.[H])) {
-    s = r[M];
-    i = Array.isArray(r[q]);
-    t.set(e, s ? (o = i ? [] : Object.create(Object.getPrototypeOf(r[q]))) : r[q]);
-    e = r[q];
-    n = U;
+  if ((r = e[V] || n?.get(e)?.[V])) {
+    s = r[K];
+    i = Array.isArray(r[G]);
+    t.set(e, s ? (o = i ? [] : Object.create(Object.getPrototypeOf(r[G]))) : r[G]);
+    e = r[G];
+    n = $;
   } else {
     i = Array.isArray(e);
     t.set(e, e);
@@ -1594,7 +1894,7 @@ function snapshot(e, t, n) {
     const r = s?.length || e.length;
     for (let i = 0; i < r; i++) {
       l = s && i in s ? s[i] : e[i];
-      if (l === R) continue;
+      if (l === D) continue;
       if ((u = snapshot(l, t, n)) !== l || o) {
         if (!o) t.set(e, (o = [...e]));
         o[i] = u;
@@ -1621,13 +1921,13 @@ function snapshot(e, t, n) {
 function trueFn() {
   return true;
 }
-const X = {
+const re = {
   get(e, t, n) {
-    if (t === Q) return n;
+    if (t === M) return n;
     return e.get(t);
   },
   has(e, t) {
-    if (t === Q) return true;
+    if (t === M) return true;
     return e.has(t);
   },
   set: trueFn,
@@ -1650,23 +1950,23 @@ const X = {
 function resolveSource(e) {
   return !(e = typeof e === "function" ? e() : e) ? {} : e;
 }
-const Y = Symbol(0);
+const ie = Symbol(0);
 function merge(...e) {
   if (e.length === 1 && typeof e[0] !== "function") return e[0];
   let t = false;
   const n = [];
   for (let r = 0; r < e.length; r++) {
     const i = e[r];
-    t = t || (!!i && Q in i);
-    const s = !!i && i[Y];
+    t = t || (!!i && M in i);
+    const s = !!i && i[ie];
     if (s) n.push(...s);
     else n.push(typeof i === "function" ? ((t = true), createMemo(i)) : i);
   }
-  if (y && t) {
+  if (w && t) {
     return new Proxy(
       {
         get(e) {
-          if (e === Y) return n;
+          if (e === ie) return n;
           for (let t = n.length - 1; t >= 0; t--) {
             const r = resolveSource(n[t]);
             if (e in r) return r[e];
@@ -1684,7 +1984,7 @@ function merge(...e) {
           return [...new Set(e)];
         }
       },
-      X
+      re
     );
   }
   const r = Object.create(null);
@@ -1716,12 +2016,12 @@ function merge(...e) {
     if (n.get) Object.defineProperty(o, t, n);
     else o[t] = n.value;
   }
-  o[Y] = n;
+  o[ie] = n;
   return o;
 }
 function omit(e, ...t) {
   const n = new Set(t);
-  if (y && Q in e) {
+  if (w && M in e) {
     return new Proxy(
       {
         get(t) {
@@ -1734,7 +2034,7 @@ function omit(e, ...t) {
           return Object.keys(e).filter(e => !n.has(e));
         }
       },
-      X
+      re
     );
   }
   const r = {};
@@ -1752,68 +2052,68 @@ function mapArray(e, t, n) {
   const r = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      Ce: createOwner(),
-      Ne: 0,
-      ke: e,
-      je: [],
-      Pe: t,
-      We: [],
-      Ae: [],
-      Ee: r,
-      Ie: r || n?.keyed === false ? [] : undefined,
-      Fe: t.length > 1 ? [] : undefined,
-      He: n?.fallback
+      Ae: createOwner(),
+      We: 0,
+      je: e,
+      Ne: [],
+      Ee: t,
+      He: [],
+      Ie: [],
+      Qe: r,
+      Re: r || n?.keyed === false ? [] : undefined,
+      Te: t.length > 1 ? [] : undefined,
+      qe: n?.fallback
     })
   );
 }
-const Z = { pureWrite: true };
+const se = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.ke() || [],
+  const e = this.je() || [],
     t = e.length;
-  e[I];
-  runWithOwner(this.Ce, () => {
+  e[q];
+  runWithOwner(this.Ae, () => {
     let n,
       r,
-      i = this.Ie
+      i = this.Re
         ? () => {
-            this.Ie[r] = signal(e[r], Z);
-            this.Fe && (this.Fe[r] = signal(r, Z));
-            return this.Pe(
-              read.bind(null, this.Ie[r]),
-              this.Fe ? read.bind(null, this.Fe[r]) : undefined
+            this.Re[r] = signal(e[r], se);
+            this.Te && (this.Te[r] = signal(r, se));
+            return this.Ee(
+              read.bind(null, this.Re[r]),
+              this.Te ? read.bind(null, this.Te[r]) : undefined
             );
           }
-        : this.Fe
+        : this.Te
           ? () => {
               const t = e[r];
-              this.Fe[r] = signal(r, Z);
-              return this.Pe(() => t, read.bind(null, this.Fe[r]));
+              this.Te[r] = signal(r, se);
+              return this.Ee(() => t, read.bind(null, this.Te[r]));
             }
           : () => {
               const t = e[r];
-              return this.Pe(() => t);
+              return this.Ee(() => t);
             };
     if (t === 0) {
-      if (this.Ne !== 0) {
-        this.Ce.dispose(false);
-        this.Ae = [];
-        this.je = [];
-        this.We = [];
-        this.Ne = 0;
-        this.Ie && (this.Ie = []);
-        this.Fe && (this.Fe = []);
+      if (this.We !== 0) {
+        this.Ae.dispose(false);
+        this.Ie = [];
+        this.Ne = [];
+        this.He = [];
+        this.We = 0;
+        this.Re && (this.Re = []);
+        this.Te && (this.Te = []);
       }
-      if (this.He && !this.We[0]) {
-        this.We[0] = runWithOwner((this.Ae[0] = createOwner()), this.He);
+      if (this.qe && !this.He[0]) {
+        this.He[0] = runWithOwner((this.Ie[0] = createOwner()), this.qe);
       }
-    } else if (this.Ne === 0) {
-      if (this.Ae[0]) this.Ae[0].dispose();
-      this.We = new Array(t);
+    } else if (this.We === 0) {
+      if (this.Ie[0]) this.Ie[0].dispose();
+      this.He = new Array(t);
       for (r = 0; r < t; r++) {
-        this.je[r] = e[r];
-        this.We[r] = runWithOwner((this.Ae[r] = createOwner()), i);
+        this.Ne[r] = e[r];
+        this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
       }
-      this.Ne = t;
+      this.We = t;
     } else {
       let s,
         o,
@@ -1823,275 +2123,271 @@ function updateKeyedMap() {
         c,
         a,
         d = new Array(t),
-        h = new Array(t),
-        p = this.Ie ? new Array(t) : undefined,
-        y = this.Fe ? new Array(t) : undefined;
+        p = new Array(t),
+        h = this.Re ? new Array(t) : undefined,
+        y = this.Te ? new Array(t) : undefined;
       for (
-        s = 0, o = Math.min(this.Ne, t);
-        s < o && (this.je[s] === e[s] || (this.Ie && compare(this.Ee, this.je[s], e[s])));
+        s = 0, o = Math.min(this.We, t);
+        s < o && (this.Ne[s] === e[s] || (this.Re && compare(this.Qe, this.Ne[s], e[s])));
         s++
       ) {
-        if (this.Ie) setSignal(this.Ie[s], e[s]);
+        if (this.Re) setSignal(this.Re[s], e[s]);
       }
       for (
-        o = this.Ne - 1, u = t - 1;
+        o = this.We - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.je[o] === e[u] || (this.Ie && compare(this.Ee, this.je[o], e[u])));
+        (this.Ne[o] === e[u] || (this.Re && compare(this.Qe, this.Ne[o], e[u])));
         o--, u--
       ) {
-        d[u] = this.We[o];
-        h[u] = this.Ae[o];
-        p && (p[u] = this.Ie[o]);
-        y && (y[u] = this.Fe[o]);
+        d[u] = this.He[o];
+        p[u] = this.Ie[o];
+        h && (h[u] = this.Re[o]);
+        y && (y[u] = this.Te[o]);
       }
       c = new Map();
       a = new Array(u + 1);
       for (r = u; r >= s; r--) {
         l = e[r];
-        f = this.Ee ? this.Ee(l) : l;
+        f = this.Qe ? this.Qe(l) : l;
         n = c.get(f);
         a[r] = n === undefined ? -1 : n;
         c.set(f, r);
       }
       for (n = s; n <= o; n++) {
-        l = this.je[n];
-        f = this.Ee ? this.Ee(l) : l;
+        l = this.Ne[n];
+        f = this.Qe ? this.Qe(l) : l;
         r = c.get(f);
         if (r !== undefined && r !== -1) {
-          d[r] = this.We[n];
-          h[r] = this.Ae[n];
-          p && (p[r] = this.Ie[n]);
-          y && (y[r] = this.Fe[n]);
+          d[r] = this.He[n];
+          p[r] = this.Ie[n];
+          h && (h[r] = this.Re[n]);
+          y && (y[r] = this.Te[n]);
           r = a[r];
           c.set(f, r);
-        } else this.Ae[n].dispose();
+        } else this.Ie[n].dispose();
       }
       for (r = s; r < t; r++) {
         if (r in d) {
-          this.We[r] = d[r];
-          this.Ae[r] = h[r];
-          if (p) {
-            this.Ie[r] = p[r];
-            setSignal(this.Ie[r], e[r]);
+          this.He[r] = d[r];
+          this.Ie[r] = p[r];
+          if (h) {
+            this.Re[r] = h[r];
+            setSignal(this.Re[r], e[r]);
           }
           if (y) {
-            this.Fe[r] = y[r];
-            setSignal(this.Fe[r], r);
+            this.Te[r] = y[r];
+            setSignal(this.Te[r], r);
           }
         } else {
-          this.We[r] = runWithOwner((this.Ae[r] = createOwner()), i);
+          this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
         }
       }
-      this.We = this.We.slice(0, (this.Ne = t));
-      this.je = e.slice(0);
+      this.He = this.He.slice(0, (this.We = t));
+      this.Ne = e.slice(0);
     }
   });
-  return this.We;
+  return this.He;
 }
 function repeat(e, t, n) {
   return updateRepeat.bind({
-    Ce: createOwner(),
-    Ne: 0,
-    Qe: 0,
-    Re: e,
-    Pe: t,
-    Ae: [],
-    We: [],
-    Ve: n?.from,
-    He: n?.fallback
+    Ae: createOwner(),
+    We: 0,
+    Fe: 0,
+    Ve: e,
+    Ee: t,
+    Ie: [],
+    He: [],
+    Me: n?.from,
+    qe: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.Re();
-  const t = this.Ve?.() || 0;
-  runWithOwner(this.Ce, () => {
+  const e = this.Ve();
+  const t = this.Me?.() || 0;
+  runWithOwner(this.Ae, () => {
     if (e === 0) {
-      if (this.Ne !== 0) {
-        this.Ce.dispose(false);
-        this.Ae = [];
-        this.We = [];
-        this.Ne = 0;
+      if (this.We !== 0) {
+        this.Ae.dispose(false);
+        this.Ie = [];
+        this.He = [];
+        this.We = 0;
       }
-      if (this.He && !this.We[0]) {
-        this.We[0] = runWithOwner((this.Ae[0] = createOwner()), this.He);
+      if (this.qe && !this.He[0]) {
+        this.He[0] = runWithOwner((this.Ie[0] = createOwner()), this.qe);
       }
       return;
     }
     const n = t + e;
-    const r = this.Qe + this.Ne;
-    if (this.Ne === 0 && this.Ae[0]) this.Ae[0].dispose();
-    for (let e = n; e < r; e++) this.Ae[e - this.Qe].dispose();
-    if (this.Qe < t) {
-      let e = this.Qe;
-      while (e < t && e < this.Ne) this.Ae[e++].dispose();
-      this.Ae.splice(0, t - this.Qe);
-      this.We.splice(0, t - this.Qe);
-    } else if (this.Qe > t) {
-      let n = r - this.Qe - 1;
-      let i = this.Qe - t;
-      this.Ae.length = this.We.length = e;
+    const r = this.Fe + this.We;
+    if (this.We === 0 && this.Ie[0]) this.Ie[0].dispose();
+    for (let e = n; e < r; e++) this.Ie[e - this.Fe].dispose();
+    if (this.Fe < t) {
+      let e = this.Fe;
+      while (e < t && e < this.We) this.Ie[e++].dispose();
+      this.Ie.splice(0, t - this.Fe);
+      this.He.splice(0, t - this.Fe);
+    } else if (this.Fe > t) {
+      let n = r - this.Fe - 1;
+      let i = this.Fe - t;
+      this.Ie.length = this.He.length = e;
       while (n >= i) {
-        this.Ae[n] = this.Ae[n - i];
-        this.We[n] = this.We[n - i];
+        this.Ie[n] = this.Ie[n - i];
+        this.He[n] = this.He[n - i];
         n--;
       }
       for (let e = 0; e < i; e++) {
-        this.We[e] = runWithOwner((this.Ae[e] = createOwner()), () => this.Pe(e + t));
+        this.He[e] = runWithOwner((this.Ie[e] = createOwner()), () => this.Ee(e + t));
       }
     }
     for (let e = r; e < n; e++) {
-      this.We[e - t] = runWithOwner((this.Ae[e - t] = createOwner()), () => this.Pe(e));
+      this.He[e - t] = runWithOwner((this.Ie[e - t] = createOwner()), () => this.Ee(e));
     }
-    this.We = this.We.slice(0, e);
-    this.Qe = t;
-    this.Ne = e;
+    this.He = this.He.slice(0, e);
+    this.Fe = t;
+    this.We = e;
   });
-  return this.We;
+  return this.He;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
-  const n = computed(e, undefined, {
-    be: {
-      le() {
-        let e = this.$;
-        this.$ &= ~this.qe;
-        if (this.qe & f && !(this.$ & a)) {
-          e &= ~f;
-        }
-        this._e.notify(this, this.qe, e);
-      },
-      qe: t
-    }
-  });
-  n.qe = t;
-  n.pe = true;
+  const n = computed(e, undefined, { lazy: true });
+  n.pe = () => {
+    const e = n.re;
+    n.re &= ~n.De;
+    n.$.notify(n, n.De, e);
+  };
+  n.De = t;
+  n.we = true;
+  recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, r) {
-  const i = e._e;
-  i.addChild((e._e = n));
-  onCleanup(() => i.removeChild(e._e));
+  const i = e.$;
+  i.addChild((e.$ = n));
+  onCleanup(() => i.removeChild(e.$));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), r);
   });
 }
 class ConditionalQueue extends Queue {
-  Me;
-  Te = new Set();
-  M = new Set();
+  Be;
+  Ge = new Set();
+  D = new Set();
   constructor(e) {
     super();
-    this.Me = e;
+    this.Be = e;
   }
   run(e) {
-    if (!e || read(this.Me)) return;
+    if (!e || read(this.Be)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (read(this.Me)) {
-      if (t & f) {
-        if (n & f) {
-          this.M.add(e);
-          t &= ~f;
-        } else if (this.M.delete(e)) t &= ~f;
-      }
+    if (read(this.Be)) {
       if (t & c) {
         if (n & c) {
-          this.Te.add(e);
+          this.D.add(e);
           t &= ~c;
-        } else if (this.Te.delete(e)) t &= ~c;
+        } else if (this.D.delete(e)) t &= ~c;
+      }
+      if (t & a) {
+        if (n & a) {
+          this.Ge.add(e);
+          t &= ~a;
+        } else if (this.Ge.delete(e)) t &= ~a;
       }
     }
     return t ? super.notify(e, t, n) : true;
   }
 }
 class CollectionQueue extends Queue {
-  De;
-  Ae = new Set();
-  Me = signal(false, { pureWrite: true });
-  Be = false;
+  Ke;
+  Ie = new Set();
+  Be = signal(false, { pureWrite: true });
+  ze = false;
   constructor(e) {
     super();
-    this.De = e;
+    this.Ke = e;
   }
   run(e) {
-    if (!e || read(this.Me)) return;
+    if (!e || read(this.Be)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (!(t & this.De) || (this.De & f && this.Be)) return super.notify(e, t, n);
-    if (n & this.De) {
-      this.Ae.add(e);
-      if (this.Ae.size === 1) setSignal(this.Me, true);
-    } else if (this.Ae.size > 0) {
-      this.Ae.delete(e);
-      if (this.Ae.size === 0) setSignal(this.Me, false);
-    }
-    t &= ~this.De;
+    if (!(t & this.Ke) || (this.Ke & c && this.ze)) return super.notify(e, t, n);
+    if (n & this.Ke) {
+      this.Ie.add(e);
+      if (this.Ie.size === 1) setSignal(this.Be, true);
+    } else if (this.Ie.size > 0) {
+      this.Ie.delete(e);
+      if (this.Ie.size === 0) setSignal(this.Be, false);
+    }
+    t &= ~this.Ke;
     return t ? super.notify(e, t, n) : true;
   }
 }
-var $;
+var oe;
 (function (e) {
   e["VISIBLE"] = "visible";
   e["HIDDEN"] = "hidden";
-})($ || ($ = {}));
+})(oe || (oe = {}));
 function createBoundary(e, t) {
   const n = createOwner();
-  const r = new ConditionalQueue(computed(() => t() === $.HIDDEN));
+  const r = new ConditionalQueue(computed(() => t() === oe.HIDDEN));
   const i = createBoundChildren(n, e, r, 0);
   computed(() => {
-    const e = read(r.Me);
-    i.qe = e ? c | f : 0;
+    const e = read(r.Be);
+    i.De = e ? a | c : 0;
     if (!e) {
-      r.M.forEach(e => r.notify(e, f, f));
-      r.Te.forEach(e => r.notify(e, c, c));
-      r.M.clear();
-      r.Te.clear();
+      r.D.forEach(e => r.notify(e, c, c));
+      r.Ge.forEach(e => r.notify(e, a, a));
+      r.D.clear();
+      r.Ge.clear();
     }
   });
-  return () => (read(r.Me) ? undefined : read(i));
+  return () => (read(r.Be) ? undefined : read(i));
 }
 function createCollectionBoundary(e, t, n) {
   const r = createOwner();
   const i = new CollectionQueue(e);
   const s = createBoundChildren(r, t, i, e);
   const o = computed(() => {
-    if (!read(i.Me)) {
+    if (!read(i.Be)) {
       const e = read(s);
-      if (!untrack(() => read(i.Me))) i.Be = true;
-      return e;
+      if (!untrack(() => read(i.Be))) {
+        i.ze = true;
+        return e;
+      }
     }
     return n(i);
   });
   return read.bind(null, o);
 }
 function createLoadBoundary(e, t) {
-  return createCollectionBoundary(f, e, () => t());
+  return createCollectionBoundary(c, e, () => t());
 }
 function collectErrorSources(e, t) {
   let n = true;
-  let r = e.W;
+  let r = e.j;
   while (r !== null) {
-    const e = r.I;
-    if (e.W && e.$ & c) {
+    const e = r.H;
+    if (e.j && e.re & a) {
       n = false;
       collectErrorSources(e, t);
     }
-    r = r.A;
+    r = r.N;
   }
   n && t.push(e);
 }
 function createErrorBoundary(e, t) {
-  return createCollectionBoundary(c, e, e => {
-    let n = e.Ae.values().next().value;
-    return t(n.K, () => {
+  return createCollectionBoundary(a, e, e => {
+    let n = e.Ie.values().next().value;
+    return t(n.J, () => {
       const t = [];
-      for (const n of e.Ae) collectErrorSources(n, t);
+      for (const n of e.Ie) collectErrorSources(n, t);
       for (const e of t) recompute(e);
       schedule();
     });
@@ -2146,13 +2442,13 @@ function flattenArray(e, t = [], n) {
   if (r) throw r;
   return i;
 }
-exports.$PROXY = Q;
-exports.$TARGET = H;
-exports.$TRACK = I;
+exports.$PROXY = M;
+exports.$TARGET = V;
+exports.$TRACK = q;
 exports.ContextNotFoundError = ContextNotFoundError;
 exports.NoOwnerError = NoOwnerError;
 exports.NotReadyError = NotReadyError;
-exports.SUPPORTS_PROXY = y;
+exports.SUPPORTS_PROXY = w;
 exports.action = action;
 exports.createBoundary = createBoundary;
 exports.createContext = createContext;