@solidjs/signals 0.9.8 → 0.9.10

package/dist/node.cjs

@@ -1,9 +1,16 @@
 "use strict";
 class NotReadyError extends Error {
-  cause;
+  t;
   constructor(e) {
     super();
-    this.cause = e;
+    this.t = e;
+  }
+}
+class StatusError extends Error {
+  t;
+  constructor(e, t) {
+    super(t instanceof Error ? t.message : String(t), { cause: t });
+    this.t = e;
   }
 }
 class NoOwnerError extends Error {
@@ -24,258 +31,329 @@ const i = 1 << 3;
 const s = 1 << 4;
 const o = 1 << 5;
 const u = 1 << 6;
-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 y = 3;
-const g = {};
-const w = typeof Proxy === "function";
-const S = {};
-const m = Symbol("refresh");
+const f = 1 << 7;
+const l = 1 << 0;
+const c = 1 << 1;
+const a = 1 << 2;
+const d = 1;
+const p = 2;
+const h = 3;
+const y = {};
+const g = typeof Proxy === "function";
+const w = {};
+const S = 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;
-  const r = e.o;
-  const i = t.l[r];
-  if (i === undefined) t.l[r] = e;
+  const n = (e.o?.i ? e.o.l?.u : e.o?.u) ?? -1;
+  if (n >= e.u) e.u = n + 1;
+  const r = e.u;
+  const i = t.p[r];
+  if (i === undefined) t.p[r] = e;
   else {
-    const t = i.p;
-    t.h = e;
-    e.p = t;
-    i.p = e;
+    const t = i.h;
+    t.S = e;
+    e.h = t;
+    i.h = e;
   }
-  if (r > t.S) t.S = r;
+  if (r > t.m) t.m = r;
 }
 function insertIntoHeap(e, o) {
-  let u = e.m;
+  let u = e._;
   if (u & (i | r)) return;
   if (u & t) {
-    e.m = (u & -4) | n | i;
-  } else e.m = u | i;
+    e._ = (u & -4) | n | i;
+  } else e._ = u | i;
   if (!(u & s)) actualInsertIntoHeap(e, o);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e.m;
+  let n = e._;
   if (n & (i | r | s)) return;
-  e.m = n | s;
+  e._ = n | s;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e.m;
+  const n = e._;
   if (!(n & (i | s))) return;
-  e.m = n & -25;
-  const r = e.o;
-  if (e.p === e) t.l[r] = undefined;
+  e._ = n & -25;
+  const r = e.u;
+  if (e.h === e) t.p[r] = undefined;
   else {
-    const n = e.h;
-    const i = t.l[r];
+    const n = e.S;
+    const i = t.p[r];
     const s = n ?? i;
-    if (e === i) t.l[r] = n;
-    else e.p.h = n;
-    s.p = e.p;
+    if (e === i) t.p[r] = n;
+    else e.h.S = n;
+    s.h = e.h;
   }
-  e.p = e;
-  e.h = undefined;
+  e.h = e;
+  e.S = undefined;
 }
 function markHeap(e) {
-  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);
+  if (e.O) return;
+  e.O = true;
+  for (let t = 0; t <= e.m; t++) {
+    for (let n = e.p[t]; n !== undefined; n = n.S) {
+      if (n._ & i) markNode(n);
     }
   }
 }
 function markNode(e, r = n) {
-  const i = e.m;
+  const i = e._;
   if ((i & (t | n)) >= r) return;
-  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.A) {
-      for (let e = n.O; e !== null; e = e.P) {
-        markNode(e.C, t);
+  e._ = (i & -4) | r;
+  for (let n = e.P; n !== null; n = n.C) {
+    markNode(n.k, t);
+  }
+  if (e.A !== null) {
+    for (let n = e.A; n !== null; n = n.W) {
+      for (let e = n.P; e !== null; e = e.C) {
+        markNode(e.k, t);
       }
     }
   }
 }
 function runHeap(e, t) {
-  e._ = false;
-  for (e.W = 0; e.W <= e.S; e.W++) {
-    let n = e.l[e.W];
+  e.O = false;
+  for (e.j = 0; e.j <= e.m; e.j++) {
+    let n = e.p[e.j];
     while (n !== undefined) {
-      if (n.m & i) t(n);
+      if (n._ & i) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.W];
+      n = e.p[e.j];
     }
   }
-  e.S = 0;
+  e.m = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
-  let n = e.o;
-  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;
+  let n = e.u;
+  for (let t = e.N; t; t = t.L) {
+    const e = t.I;
+    const r = e.H || e;
+    if (r.R && r.u >= n) n = r.u + 1;
   }
-  if (e.o !== n) {
-    e.o = n;
-    for (let n = e.O; n !== null; n = n.P) {
-      insertIntoHeapHeight(n.C, t);
+  if (e.u !== n) {
+    e.u = n;
+    for (let n = e.P; n !== null; n = n.C) {
+      insertIntoHeapHeight(n.k, t);
     }
   }
 }
-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;
+const m = new Set();
+const _ = { p: new Array(2e3).fill(undefined), O: false, j: 0, m: 0 };
+const b = { p: new Array(2e3).fill(undefined), O: false, j: 0, m: 0 };
+let O = 0;
+let x = null;
+let v = false;
 let P = false;
-let C = false;
-let k = false;
-function setOptimisticReadActive(e) {
-  C = e;
+const C = new WeakMap();
+const k = new Set();
+let A = null;
+function setCurrentOptimisticLane(e) {
+  A = e;
+}
+function getOrCreateLane(e) {
+  let t = C.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.T;
+  const r = n?.M ? findLane(n.M) : null;
+  t = { t: e, q: new Set(), F: [[], []], V: null, B: x, D: r };
+  C.set(e, t);
+  k.add(t);
+  e.G = e.K || 0;
+  return t;
+}
+function findLane(e) {
+  while (e.V) e = e.V;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.V = e;
+  for (const n of t.q) e.q.add(n);
+  e.F[0].push(...t.F[0]);
+  e.F[1].push(...t.F[1]);
+  return e;
+}
+function clearLaneEntry(e) {
+  C.delete(e);
+}
+function resolveLane(e) {
+  const t = e.M;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (k.has(n)) return n;
+  e.M = undefined;
+  return undefined;
+}
+function hasActiveOverride(e) {
+  return !!(e.U && e.J !== y);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const r = e.M;
+  if (r) {
+    if (r.V) {
+      e.M = t;
+      return;
+    }
+    const i = findLane(r);
+    if (k.has(i)) {
+      if (i !== n && !hasActiveOverride(e)) {
+        if (n.D && findLane(n.D) === i) {
+          e.M = t;
+        } else if (i.D && findLane(i.D) === n);
+        else {
+          mergeLanes(n, i);
+        }
+      }
+      return;
+    }
+  }
+  e.M = t;
+}
+function runLaneEffects(e) {
+  for (const t of k) {
+    if (t.V || t.q.size > 0) continue;
+    const n = t.F[e - 1];
+    if (n.length) {
+      t.F[e - 1] = [];
+      runQueue(n, e);
+    }
+  }
 }
 function setProjectionWriteActive(e) {
-  k = e;
+  P = e;
 }
 function schedule() {
-  if (P) return;
-  P = true;
-  if (!A.T) queueMicrotask(flush);
+  if (v) return;
+  v = true;
+  if (!E.X) queueMicrotask(flush);
 }
 class Queue {
-  i = null;
-  q = [[], []];
-  F = [[], []];
-  V = [];
-  created = x;
+  o = null;
+  Y = [[], []];
+  Z = [];
+  created = O;
   addChild(e) {
-    this.V.push(e);
-    e.i = this;
+    this.Z.push(e);
+    e.o = this;
   }
   removeChild(e) {
-    const t = this.V.indexOf(e);
+    const t = this.Z.indexOf(e);
     if (t >= 0) {
-      this.V.splice(t, 1);
-      e.i = null;
+      this.Z.splice(t, 1);
+      e.o = null;
     }
   }
-  notify(e, t, n) {
-    if (this.i) return this.i.notify(e, t, n);
+  notify(e, t, n, r) {
+    if (this.o) return this.o.notify(e, t, n, r);
     return false;
   }
-  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.V.length; t++) {
-      this.V[t][n]?.(e);
-    }
-  }
   run(e) {
-    this.M(e, this.q, "run");
-  }
-  runOptimistic(e) {
-    this.M(e, this.F, "runOptimistic");
+    if (this.Y[e - 1].length) {
+      const t = this.Y[e - 1];
+      this.Y[e - 1] = [];
+      runQueue(t, e);
+    }
+    for (let t = 0; t < this.Z.length; t++) this.Z[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
-      const n = C ? this.F : this.q;
-      n[e - 1].push(t);
+      if (A) {
+        const n = findLane(A);
+        n.F[e - 1].push(t);
+      } else {
+        this.Y[e - 1].push(t);
+      }
     }
     schedule();
   }
   stashQueues(e) {
-    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];
+    e.Y[0].push(...this.Y[0]);
+    e.Y[1].push(...this.Y[1]);
+    this.Y = [[], []];
+    for (let t = 0; t < this.Z.length; t++) {
+      let n = this.Z[t];
+      let r = e.Z[t];
       if (!r) {
-        r = { q: [[], []], V: [] };
-        e.V[t] = r;
+        r = { Y: [[], []], Z: [] };
+        e.Z[t] = r;
       }
       n.stashQueues(r);
     }
   }
   restoreQueues(e) {
-    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];
+    this.Y[0].push(...e.Y[0]);
+    this.Y[1].push(...e.Y[1]);
+    for (let t = 0; t < e.Z.length; t++) {
+      const n = e.Z[t];
+      let r = this.Z[t];
       if (r) r.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  T = false;
-  D = [];
-  B = [];
-  G = new Set();
-  static K;
-  static U;
-  static L = null;
+  X = false;
+  $ = [];
+  ee = [];
+  te = new Set();
+  static ne;
+  static re;
+  static ie = null;
   flush() {
-    if (this.T) return;
-    this.T = true;
+    if (this.X) return;
+    this.X = true;
     try {
-      runHeap(_, GlobalQueue.K);
-      if (v) {
-        const e = transitionComplete(v);
+      runHeap(_, GlobalQueue.ne);
+      if (x) {
+        const e = transitionComplete(x);
         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;
+          let e = x;
+          runHeap(b, GlobalQueue.ne);
+          this.$ = [];
+          this.ee = [];
+          this.te = new Set();
+          runLaneEffects(d);
+          runLaneEffects(p);
+          this.stashQueues(x.se);
+          O++;
+          v = _.m >= _.j;
+          reassignPendingTransition(x.$);
+          x = null;
           finalizePureQueue(null, true);
           return;
         }
-        this.D !== v.pendingNodes && this.D.push(...v.pendingNodes);
-        this.restoreQueues(v.queueStash);
-        b.delete(v);
-        const t = v;
-        v = null;
-        runTransitionPending(this.D);
+        this.$ !== x.$ && this.$.push(...x.$);
+        this.restoreQueues(x.se);
+        m.delete(x);
+        const t = x;
+        x = null;
+        reassignPendingTransition(this.$);
         finalizePureQueue(t);
       } else {
-        if (b.size) runHeap(O, GlobalQueue.K);
+        if (m.size) runHeap(b, GlobalQueue.ne);
         finalizePureQueue();
       }
-      x++;
-      P = _.S >= _.W;
-      this.runOptimistic(p);
+      O++;
+      v = _.m >= _.j;
+      runLaneEffects(d);
+      this.run(d);
+      runLaneEffects(p);
       this.run(p);
-      this.runOptimistic(h);
-      this.run(h);
     } finally {
-      this.T = false;
+      this.X = false;
     }
   }
-  notify(e, t, n) {
-    if (t & c) {
-      if (n & c) {
-        if (v && e.J && !v.asyncNodes.includes(e.J.cause)) {
-          v.asyncNodes.push(e.J.cause);
+  notify(e, t, n, r) {
+    if (t & l) {
+      if (n & l) {
+        const t = r !== undefined ? r : e.oe;
+        if (x && t && !x.ue.includes(t.t)) {
+          x.ue.push(t.t);
           schedule();
         }
       }
@@ -285,146 +363,184 @@ class GlobalQueue extends Queue {
   }
   initTransition(e) {
     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: { q: [[], []], V: [] },
-        done: false
+    if (e && e === x) return;
+    if (!e && x && x.fe === O) return;
+    if (!x) {
+      x = e ?? {
+        fe: O,
+        $: [],
+        ue: [],
+        ee: [],
+        te: new Set(),
+        le: [],
+        se: { Y: [[], []], Z: [] },
+        ce: false
       };
     } else if (e) {
-      v.done = e;
-      e.actions.push(...v.actions);
-      b.delete(v);
-      v = e;
+      const t = x;
+      t.ce = e;
+      e.le.push(...t.le);
+      for (const n of k) {
+        if (n.B === t) n.B = e;
+      }
+      e.ee.push(...t.ee);
+      for (const n of t.te) {
+        e.te.add(n);
+      }
+      m.delete(t);
+      x = 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);
+    m.add(x);
+    x.fe = O;
+    for (let e = 0; e < this.$.length; e++) {
+      const t = this.$[e];
+      t.B = x;
+      x.$.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.$ = x.$;
+    for (let e = 0; e < this.ee.length; e++) {
+      const t = this.ee[e];
+      t.B = x;
+      x.ee.push(t);
     }
-    this.B = v.optimisticNodes;
-    for (const e of this.G) {
-      v.optimisticStores.add(e);
+    this.ee = x.ee;
+    for (const e of k) {
+      if (!e.B) e.B = x;
     }
-    this.G = v.optimisticStores;
+    for (const e of this.te) x.te.add(e);
+    this.te = x.te;
   }
 }
 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);
+  const n = e.M || A;
+  for (let r = e.P; r !== null; r = r.C) {
+    if (t && n) {
+      r.k._ |= f;
+      assignOrMergeLane(r.k, n);
+    } else if (t) {
+      r.k._ |= f;
+      r.k.M = undefined;
+    }
+    const e = r.k;
+    if (e.ae === h) {
+      if (!e.de) {
+        e.de = true;
+        e.pe.enqueue(p, e.he);
       }
       continue;
     }
-    const r = n.C.m & o ? O : _;
-    if (r.W > n.C.o) r.W = n.C.o;
-    insertIntoHeap(n.C, r);
+    const i = r.k._ & o ? b : _;
+    if (i.j > r.k.u) i.j = r.k.u;
+    insertIntoHeap(r.k, i);
   }
 }
 function finalizePureQueue(e = null, t = false) {
   let n = !t;
-  if (_.S >= _.W) {
-    runHeap(_, GlobalQueue.K);
-  }
+  if (!t) checkBoundaryChildren(E);
+  if (_.m >= _.j) runHeap(_, GlobalQueue.ne);
   if (n) {
-    const t = A.D;
+    const t = E.$;
     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.J !== y) {
+        n.ye = n.J;
+        n.J = y;
+        if (n.ae && n.ae !== h) n.de = true;
       }
-      if (n.R) GlobalQueue.U(n, false, true);
+      n.ge &= ~a;
+      if (n.R) GlobalQueue.re(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.optimisticNodes : A.B;
+    const n = e ? e.ee : E.ee;
     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;
+      const r = t.J;
+      t.M = undefined;
+      if (r !== y && t.ye !== r) {
+        t.ye = r;
         insertSubs(t, true);
       }
-      t.te = g;
-      t.X = null;
+      t.J = y;
+      t.B = null;
     }
     n.length = 0;
-    const r = e ? e.optimisticStores : A.G;
-    if (GlobalQueue.L && r.size) {
+    const r = e ? e.te : E.te;
+    if (GlobalQueue.ie && r.size) {
       for (const e of r) {
-        GlobalQueue.L(e);
+        GlobalQueue.ie(e);
       }
       r.clear();
       schedule();
     }
+    for (const t of k) {
+      const n = e ? t.B === e : !t.B;
+      if (!n) continue;
+      if (!t.V) {
+        if (t.F[0].length) runQueue(t.F[0], d);
+        if (t.F[1].length) runQueue(t.F[1], p);
+      }
+      if (t.t.M === t) t.t.M = undefined;
+      t.q.clear();
+      t.F[0].length = 0;
+      t.F[1].length = 0;
+      k.delete(t);
+      C.delete(t.t);
+    }
+  }
+}
+function checkBoundaryChildren(e) {
+  for (const t of e.Z) {
+    t.checkSources?.();
+    checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  A.G.add(e);
+  E.te.add(e);
   schedule();
 }
-function runTransitionPending(e) {
+function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].X = v;
+    e[t].B = x;
   }
 }
-const A = new GlobalQueue();
+const E = new GlobalQueue();
 function flush() {
-  while (P) {
-    A.flush();
+  while (v) {
+    E.flush();
   }
 }
 function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.done) return true;
-  if (e.actions.length) return false;
+  if (e.ce) return true;
+  if (e.le.length) return false;
   let t = true;
-  for (let n = 0; n < e.asyncNodes.length; n++) {
-    if (e.asyncNodes[n].re & c) {
+  for (let n = 0; n < e.ue.length; n++) {
+    const r = e.ue[n];
+    if (r.ge & l && r.oe?.t === r) {
       t = false;
       break;
     }
   }
-  t && (e.done = true);
+  t && (e.ce = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.done && typeof e.done === "object") e = e.done;
+  while (e.ce && typeof e.ce === "object") e = e.ce;
   return e;
 }
 function runInTransition(e, t) {
-  const n = v;
+  const n = x;
   try {
-    v = currentTransition(e);
+    x = currentTransition(e);
     return t();
   } finally {
-    v = n;
+    x = n;
   }
 }
 function restoreTransition(e, t) {
-  A.initTransition(e);
+  E.initTransition(e);
   const n = t();
   flush();
   return n;
@@ -433,14 +549,14 @@ function action(e) {
   return (...t) =>
     new Promise((n, r) => {
       const i = e(...t);
-      A.initTransition();
-      let s = v;
-      s.actions.push(i);
+      E.initTransition();
+      let s = x;
+      s.le.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;
+        const o = s.le.indexOf(i);
+        if (o >= 0) s.le.splice(o, 1);
+        x = s;
         schedule();
         t ? r(t) : n(e);
       };
@@ -467,124 +583,168 @@ function action(e) {
       step();
     });
 }
-GlobalQueue.K = recompute;
-GlobalQueue.U = disposeChildren;
+GlobalQueue.ne = recompute;
+GlobalQueue.re = disposeChildren;
 let W = false;
 let j = false;
 let N = false;
-let E = false;
-let H = false;
+let L = false;
+let Q = false;
 let I = false;
-let Q = null;
+let H = null;
 function recompute(t, n = false) {
-  const i = t.Y;
+  const i = t.ae;
   if (!n) {
-    if (t.X && (!i || v) && v !== t.X) A.initTransition(t.X);
-    deleteFromHeap(t, t.m & o ? O : _);
-    if (t.X) disposeChildren(t);
+    if (t.B && (!i || x) && x !== t.B) E.initTransition(t.B);
+    deleteFromHeap(t, t._ & o ? b : _);
+    if (t.B || i === h) disposeChildren(t);
     else {
       markDisposal(t);
-      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;
+      t.we = t.Se;
+      t.me = t._e;
+      t.Se = null;
+      t._e = null;
+    }
+  }
+  const s = !!(t._ & f);
+  const u = hasActiveOverride(t);
+  const a = !!(t.ge & l);
+  const d = H;
+  H = t;
+  t.be = null;
+  t._ = r;
+  t.fe = O;
+  let p = t.J === y ? t.ye : t.J;
+  let g = t.u;
+  let w = W;
+  let S = A;
   W = true;
-  if (s) setOptimisticReadActive(true);
+  if (s) {
+    const e = resolveLane(t);
+    if (e) setCurrentOptimisticLane(e);
+  }
   try {
-    d = handleAsync(t, t.R(d));
+    p = handleAsync(t, t.R(p));
     clearStatus(t);
+    const e = resolveLane(t);
+    if (e) {
+      e.q.delete(t);
+      updatePendingSignal(e.t);
+    }
   } catch (e) {
-    if (e instanceof NotReadyError) {
-      if (e.cause !== t) link(e.cause, t);
-      notifyStatus(t, c, e);
-    } else notifyStatus(t, a, e);
+    if (e instanceof NotReadyError && A) {
+      const e = findLane(A);
+      if (e.t !== t) {
+        e.q.add(t);
+        t.M = e;
+        updatePendingSignal(e.t);
+      }
+    }
+    notifyStatus(
+      t,
+      e instanceof NotReadyError ? l : c,
+      e,
+      undefined,
+      e instanceof NotReadyError ? t.M : undefined
+    );
   } finally {
-    W = h;
-    t.m = e;
-    Q = f;
+    W = w;
+    t._ = e;
+    H = d;
   }
-  if (!t.J) {
-    const e = t.fe;
-    let r = e !== null ? e.N : t.j;
+  if (!t.oe) {
+    const e = t.be;
+    let r = e !== null ? e.L : t.N;
     if (r !== null) {
       do {
         r = unlinkSubs(r);
       } while (r !== null);
-      if (e !== null) e.N = null;
-      else t.j = null;
+      if (e !== null) e.L = null;
+      else t.N = null;
     }
-    const l = !t.ae || !t.ae(t.te === g ? t.ne : t.te, d);
+    const f = u ? t.ye : t.J === y ? t.ye : t.J;
+    const l = !t.Oe || !t.Oe(f, p);
     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 : _);
+      const e = u ? t.ye : undefined;
+      if (n || (i && x !== t.B) || s) t.ye = p;
+      else t.J = p;
+      if (u && !s && a) {
+        const e = t.K || 0;
+        const n = t.G || 0;
+        if (e <= n) t.ye = p;
+      }
+      if (!u || s || t.ye !== e) {
+        insertSubs(t, s || u);
+      }
+    } else if (u) {
+      t.J = p;
+    } else if (t.u != g) {
+      for (let e = t.P; e !== null; e = e.C) {
+        insertIntoHeapHeight(e.k, e.k._ & o ? b : _);
       }
     }
   }
-  setOptimisticReadActive(y);
-  (!n || t.re & c) && !t.X && !(v && t.le) && A.D.push(t);
-  t.X && i && v !== t.X && runInTransition(t.X, () => recompute(t));
+  setCurrentOptimisticLane(S);
+  (!n || t.ge & l) && !t.B && !(x && t.U) && E.$.push(t);
+  t.B && i && x !== t.B && runInTransition(t.B, () => recompute(t));
 }
-function handleAsync(e, t, n) {
-  const r = typeof t === "object" && t !== null;
-  const i = r && untrack(() => t[Symbol.asyncIterator]);
-  const s = !i && r && untrack(() => typeof t.then === "function");
-  if (!s && !i) {
-    e.de = null;
+function handleAsync(e, t, r) {
+  const i = typeof t === "object" && t !== null;
+  const s = i && untrack(() => t[Symbol.asyncIterator]);
+  const o = !s && i && untrack(() => typeof t.then === "function");
+  if (!o && !s) {
+    e.xe = null;
     return t;
   }
-  e.de = t;
-  let o;
+  e.xe = t;
+  let u;
   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;
+    if (e.xe !== t) return;
+    E.initTransition(e.B);
+    notifyStatus(e, n instanceof NotReadyError ? l : c, n);
+    e.fe = O;
   };
-  const asyncWrite = (r, i) => {
-    if (e.de !== t) return;
-    A.initTransition(e.X);
+  const asyncWrite = (i, s) => {
+    if (e.xe !== t) return;
+    if (e._ & (n | f)) return;
+    E.initTransition(e.B);
     clearStatus(e);
-    if (n) n(r);
-    else if (e.le) {
-      const t = e.te !== g;
-      if (e.R) e.te = r;
+    const o = resolveLane(e);
+    if (o) o.q.delete(e);
+    if (r) r(i);
+    else if (e.U) {
+      const t = e.J !== y;
+      if (e.R) e.J = i;
       if (!t) {
-        e.ne = r;
+        e.ye = i;
         insertSubs(e);
       }
-      e.ce = x;
-      schedule();
-    } else setSignal(e, () => r);
+      e.fe = O;
+    } else if (o) {
+      const t = e.ye;
+      const n = e.Oe;
+      if (!n || !n(i, t)) {
+        e.ye = i;
+        e.fe = O;
+        if (e.ve) {
+          setSignal(e.ve, i);
+        }
+        insertSubs(e, true);
+      }
+    } else {
+      setSignal(e, () => i);
+    }
+    schedule();
     flush();
-    i?.();
+    s?.();
   };
-  if (s) {
+  if (o) {
     let n = false,
       r = true;
     t.then(
       e => {
         if (r) {
-          o = e;
+          u = e;
           n = true;
         } else asyncWrite(e);
       },
@@ -594,11 +754,11 @@ function handleAsync(e, t, n) {
     );
     r = false;
     if (!n) {
-      A.initTransition(e.X);
-      throw new NotReadyError(Q);
+      E.initTransition(e.B);
+      throw new NotReadyError(H);
     }
   }
-  if (i) {
+  if (s) {
     const n = t[Symbol.asyncIterator]();
     let r = false;
     const iterate = () => {
@@ -618,7 +778,7 @@ function handleAsync(e, t, n) {
       );
       i = false;
       if (t && !e.done) {
-        o = e.value;
+        u = e.value;
         r = true;
         return iterate();
       }
@@ -626,177 +786,191 @@ function handleAsync(e, t, n) {
     };
     const i = iterate();
     if (!r && !i) {
-      A.initTransition(e.X);
-      throw new NotReadyError(Q);
+      E.initTransition(e.B);
+      throw new NotReadyError(H);
     }
   }
-  return o;
+  return u;
 }
 function clearStatus(e) {
-  e.re = f;
-  e.J = null;
+  e.ge = e.ge & a;
+  e.oe = null;
   updatePendingSignal(e);
-  if (e.pe) {
-    e.pe();
-  } else {
-    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 : _);
-        }
-      }
+  e.Pe?.();
+}
+function notifyStatus(e, t, n, r, i) {
+  if (t === c && !(n instanceof StatusError) && !(n instanceof NotReadyError))
+    n = new StatusError(e, n);
+  const s = n instanceof NotReadyError && n.t === e;
+  const o = t === l && e.U && !s;
+  const u = o && hasActiveOverride(e);
+  if (!r) {
+    e.ge = t | (t !== c ? e.ge & a : 0);
+    e.oe = n;
+    updatePendingSignal(e);
+  }
+  if (i && !r) {
+    assignOrMergeLane(e, i);
+  }
+  if (u && x && n instanceof NotReadyError) {
+    const e = n.t;
+    if (!x.ue.includes(e)) {
+      x.ue.push(e);
+    }
+  }
+  const f = r || u;
+  const d = r || o ? undefined : i;
+  if (e.Pe) {
+    if (f) {
+      e.Pe(t, n);
+    } else {
+      e.Pe();
     }
-    schedule();
+    return;
   }
-}
-function notifyStatus(e, t, n) {
-  e.re = t | (t !== a ? e.re & d : 0);
-  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.P; r !== null; r = r.C) {
+    r.k.fe = O;
+    if (r.k.oe !== n) {
+      !r.k.B && E.$.push(r.k);
+      notifyStatus(r.k, t, n, f, d);
     }
   }
-  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);
+  for (let r = e.A; r !== null; r = r.W) {
+    for (let e = r.P; e !== null; e = e.C) {
+      e.k.fe = O;
+      if (e.k.oe !== n) {
+        !e.k.B && E.$.push(e.k);
+        notifyStatus(e.k, t, n, f, d);
       }
     }
   }
 }
 function updateIfNecessary(r) {
-  if (r.m & t) {
-    for (let e = r.j; e; e = e.N) {
-      const t = e.H;
-      const i = t.I || t;
+  if (r._ & t) {
+    for (let e = r.N; e; e = e.L) {
+      const t = e.I;
+      const i = t.H || t;
       if (i.R) {
         updateIfNecessary(i);
       }
-      if (r.m & n) {
+      if (r._ & n) {
         break;
       }
     }
   }
-  if (r.m & n) {
+  if (r._ & (n | f) || (r.oe && r.fe < O)) {
     recompute(r);
   }
-  r.m = e;
+  r._ = e;
 }
 function unlinkSubs(e) {
-  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;
+  const t = e.I;
+  const n = e.L;
+  const r = e.C;
+  const i = e.Ce;
+  if (r !== null) r.Ce = i;
+  else t.ke = i;
+  if (i !== null) i.C = r;
   else {
-    t.O = r;
+    t.P = r;
     if (r === null) {
-      t.ge?.();
-      t.R && !t.we && unobserved(t);
+      t.Ae?.();
+      t.R && !t.Ee && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
-  deleteFromHeap(e, e.m & o ? O : _);
-  let t = e.j;
+  deleteFromHeap(e, e._ & o ? b : _);
+  let t = e.N;
   while (t !== null) {
     t = unlinkSubs(t);
   }
-  e.j = null;
+  e.N = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.fe;
-  if (n !== null && n.H === e) return;
+  const n = t.be;
+  if (n !== null && n.I === e) return;
   let i = null;
-  const s = t.m & r;
+  const s = t._ & r;
   if (s) {
-    i = n !== null ? n.N : t.j;
-    if (i !== null && i.H === e) {
-      t.fe = i;
+    i = n !== null ? n.L : t.N;
+    if (i !== null && i.I === e) {
+      t.be = i;
       return;
     }
   }
-  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;
+  const o = e.ke;
+  if (o !== null && o.k === t && (!s || isValidLink(o, t))) return;
+  const u = (t.be = e.ke = { I: e, k: t, L: i, Ce: o, C: null });
+  if (n !== null) n.L = u;
+  else t.N = u;
+  if (o !== null) o.C = u;
+  else e.P = u;
 }
 function isValidLink(e, t) {
-  const n = t.fe;
+  const n = t.be;
   if (n !== null) {
-    let r = t.j;
+    let r = t.N;
     do {
       if (r === e) return true;
       if (r === n) break;
-      r = r.N;
+      r = r.L;
     } while (r !== null);
   }
   return false;
 }
 function markDisposal(e) {
-  let t = e.ue;
+  let t = e._e;
   while (t) {
-    t.m |= o;
-    if (t.m & i) {
+    t._ |= o;
+    if (t._ & i) {
       deleteFromHeap(t, _);
-      insertIntoHeap(t, O);
+      insertIntoHeap(t, b);
     }
     markDisposal(t);
-    t = t.Se;
+    t = t.We;
   }
 }
 function dispose(e) {
-  let t = e.j || null;
+  let t = e.N || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.j = null;
-  e.fe = null;
+  e.N = null;
+  e.be = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e.m & u) return;
-  if (t) e.m = u;
-  let r = n ? e.oe : e.ue;
+  if (e._ & u) return;
+  if (t) e._ = u;
+  let r = n ? e.me : e._e;
   while (r) {
-    const e = r.Se;
-    if (r.j) {
+    const e = r.We;
+    if (r.N) {
       const e = r;
-      deleteFromHeap(e, e.m & o ? O : _);
-      let t = e.j;
+      deleteFromHeap(e, e._ & o ? b : _);
+      let t = e.N;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.j = null;
-      e.fe = null;
+      e.N = null;
+      e.be = null;
     }
     disposeChildren(r, true);
     r = e;
   }
   if (n) {
-    e.oe = null;
+    e.me = null;
   } else {
-    e.ue = null;
-    e.Se = null;
+    e._e = null;
+    e.We = null;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.ie : e.se;
+  let n = t ? e.we : e.Se;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -806,10 +980,10 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.ie = null) : (e.se = null);
+  t ? (e.we = null) : (e.Se = null);
 }
 function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.me++);
+  if (e.id != null) return formatId(e.id, e.je++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(e, t) {
@@ -819,103 +993,133 @@ function formatId(e, t) {
 }
 function computed(t, n, r) {
   const i = {
-    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,
-    h: undefined,
-    p: null,
-    j: null,
-    fe: null,
-    O: null,
-    ye: null,
-    i: Q,
+    id: r?.id ?? (H?.id != null ? getNextChildId(H) : undefined),
+    Oe: r?.equals != null ? r.equals : isEqual,
+    Ne: !!r?.pureWrite,
+    Ae: r?.unobserved,
     Se: null,
-    ue: null,
-    m: e,
-    re: d,
-    ce: x,
-    te: g,
-    ie: null,
-    oe: null,
-    de: null,
-    X: null
+    pe: H?.pe ?? E,
+    Le: H?.Le ?? w,
+    je: 0,
+    R: t,
+    ye: n,
+    u: 0,
+    A: null,
+    S: undefined,
+    h: null,
+    N: null,
+    be: null,
+    P: null,
+    ke: null,
+    o: H,
+    We: null,
+    _e: null,
+    _: e,
+    ge: a,
+    fe: O,
+    J: y,
+    we: null,
+    me: null,
+    xe: null,
+    B: null
   };
-  i.p = i;
-  const s = Q?.t ? Q.u : Q;
-  if (Q) {
-    const e = Q.ue;
+  i.h = i;
+  const s = H?.i ? H.l : H;
+  if (H) {
+    const e = H._e;
     if (e === null) {
-      Q.ue = i;
+      H._e = i;
     } else {
-      i.Se = e;
-      Q.ue = i;
+      i.We = e;
+      H._e = i;
     }
   }
-  if (s) i.o = s.o + 1;
+  if (s) i.u = s.u + 1;
   !r?.lazy && recompute(i, true);
   return i;
 }
 function signal(e, t, n = null) {
   const r = {
-    ae: t?.equals != null ? t.equals : isEqual,
-    be: !!t?.pureWrite,
-    ge: t?.unobserved,
-    ne: e,
-    O: null,
-    ye: null,
-    ce: x,
-    I: n,
-    A: n?.k || null,
-    te: g
+    Oe: t?.equals != null ? t.equals : isEqual,
+    Ne: !!t?.pureWrite,
+    Ae: t?.unobserved,
+    ye: e,
+    P: null,
+    ke: null,
+    fe: O,
+    H: n,
+    W: n?.A || null,
+    J: y
   };
-  n && (n.k = r);
+  n && (n.A = r);
   return r;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.le = true;
+  n.U = true;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const r = computed(e, t, n);
-  r.le = true;
+  r.U = true;
   return r;
 }
 function getPendingSignal(e) {
-  if (!e.Oe) {
-    e.Oe = optimisticSignal(false, { pureWrite: true });
-    if (computePendingState(e)) setSignal(e.Oe, true);
+  if (!e.Qe) {
+    e.Qe = optimisticSignal(false, { pureWrite: true });
+    if (e.T) {
+      e.Qe.T = e;
+    }
+    if (computePendingState(e)) setSignal(e.Qe, true);
   }
-  return e.Oe;
+  return e.Qe;
 }
 function computePendingState(e) {
-  if (e.te !== g) return true;
   const t = e;
-  return !!(t.re & c && !(t.re & d));
+  if (e.U && e.J !== y) {
+    if (t.ge & l && !(t.ge & a)) return true;
+    if (e.T) {
+      const t = e.M ? findLane(e.M) : null;
+      return !!(t && t.q.size > 0);
+    }
+    return true;
+  }
+  if (e.J !== y && !(t.ge & a)) return true;
+  return !!(t.ge & l && !(t.ge & a));
 }
 function getPendingValueComputed(e) {
-  if (!e.xe) {
+  if (!e.ve) {
     const t = I;
     I = false;
-    const n = Q;
-    Q = null;
-    e.xe = optimisticComputed(() => read(e));
-    Q = n;
+    const n = L;
+    L = false;
+    const r = H;
+    H = null;
+    e.ve = optimisticComputed(() => read(e));
+    e.ve.T = e;
+    H = r;
+    L = n;
     I = t;
   }
-  return e.xe;
+  return e.ve;
 }
 function updatePendingSignal(e) {
-  if (e.Oe) setSignal(e.Oe, computePendingState(e));
+  if (e.Qe) {
+    const t = computePendingState(e);
+    const n = e.Qe;
+    setSignal(n, t);
+    if (!t && n.M) {
+      const t = resolveLane(e);
+      if (t && t.q.size > 0) {
+        const e = findLane(n.M);
+        if (e !== t) {
+          mergeLanes(t, e);
+        }
+      }
+      clearLaneEntry(n);
+      n.M = undefined;
+    }
+  }
 }
 function isEqual(e, t) {
   return e === t;
@@ -930,129 +1134,157 @@ function untrack(e) {
   }
 }
 function read(e) {
-  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;
+    if (t.ge & l) return e.ye;
+    if (j && A && t.M) {
+      const n = findLane(t.M);
+      const r = findLane(A);
+      if (n !== r && n.q.size > 0) {
+        return e.ye;
+      }
+    }
     return r;
   }
-  let t = Q;
-  if (t?.t) t = t.u;
+  if (L) {
+    const t = e.H || e;
+    const n = getPendingSignal(t);
+    const r = L;
+    L = false;
+    if (read(n)) {
+      Q = true;
+    }
+    L = r;
+    return e.ye;
+  }
+  let t = H;
+  if (t?.i) t = t.l;
   if (N && e.R) recompute(e);
   if (t && W) {
-    if (e.R && e.m & u) recompute(e);
+    if (e.R && e._ & u) recompute(e);
     link(e, t);
-    const n = e.I || e;
+    const n = e.H || e;
     if (n.R) {
-      const r = e.m & o;
-      if (n.o >= (r ? O.W : _.W)) {
+      const r = e._ & o;
+      if (n.u >= (r ? b.j : _.j)) {
         markNode(t);
-        markHeap(r ? O : _);
+        markHeap(r ? b : _);
         updateIfNecessary(n);
       }
-      const i = n.o;
-      if (i >= t.o && e.i !== t) {
-        t.o = i + 1;
+      const i = n.u;
+      if (i >= t.u && e.o !== t) {
+        t.u = i + 1;
       }
     }
   }
-  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) {
+  const n = e.H || e;
+  if (t && n.ge & l && !(j && n.B && x !== n.B)) {
+    if (A) {
+      const r = n.M;
+      const i = findLane(A);
+      if (r && findLane(r) === i && !hasActiveOverride(n)) {
+        if (!W) link(e, t);
+        throw n.oe;
+      }
+    } else {
+      if (!W) link(e, t);
+      throw n.oe;
+    }
+  }
+  if (e.R && e.ge & c) {
+    if (e.fe < O) {
       recompute(e, true);
       return read(e);
-    } else throw e.J;
+    } else throw e.oe;
   }
-  return !t || C || e.te === g || (j && e.X && v !== e.X) ? e.ne : e.te;
+  return !t || A !== null || e.J === y || (j && e.B && x !== e.B) ? e.ye : e.J;
 }
 function setSignal(e, 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 (e.B && x !== e.B) E.initTransition(e.B);
+  const n = e.U && !P;
+  const r = n ? e.ye : e.J === y ? e.ye : e.J;
   if (typeof t === "function") t = t(r);
-  const i = !e.ae || !e.ae(r, t);
-  if (!i) return t;
+  const i = !e.Oe || !e.Oe(r, t);
+  if (!i) {
+    if (n && e.J !== y && e.R) {
+      insertSubs(e, true);
+      schedule();
+    }
+    return t;
+  }
   if (n) {
-    const n = A.B.includes(e);
-    if (e.X && n) {
-      A.initTransition(e.X);
+    const n = E.ee.includes(e);
+    if (e.B && n) {
+      E.initTransition(e.B);
     }
-    if (e.te === g) {
-      e.te = e.ne;
+    if (e.J === y) {
+      e.J = e.ye;
     }
     if (!n) {
-      A.B.push(e);
+      E.ee.push(e);
     }
-    e.ne = t;
+    e.K = (e.K || 0) + 1;
+    const r = getOrCreateLane(e);
+    e.M = r;
+    e.ye = t;
   } else {
-    if (e.te === g) A.D.push(e);
-    e.te = t;
+    if (e.J === y) E.$.push(e);
+    e.J = t;
   }
   updatePendingSignal(e);
-  if (e.xe) {
-    setSignal(e.xe, t);
+  if (e.ve) {
+    setSignal(e.ve, t);
   }
-  e.ce = x;
+  e.fe = O;
   insertSubs(e, n);
   schedule();
   return t;
 }
 const R = {};
 function getObserver() {
-  if (E || I) return R;
-  return W ? Q : null;
+  if (L || I) return R;
+  return W ? H : null;
 }
 function getOwner() {
-  return Q;
+  return H;
 }
 function onCleanup(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];
+  if (!H) return e;
+  if (!H.Se) H.Se = e;
+  else if (Array.isArray(H.Se)) H.Se.push(e);
+  else H.Se = [H.Se, e];
   return e;
 }
 function createOwner(e) {
-  const t = Q;
+  const t = H;
   const n = {
     id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
-    t: true,
-    u: t?.t ? t.u : t,
-    ue: null,
+    i: true,
+    l: t?.i ? t.l : t,
+    _e: null,
+    We: null,
     Se: null,
-    se: null,
-    $: t?.$ ?? A,
-    _e: t?._e || S,
-    me: 0,
-    ie: null,
-    oe: null,
-    i: t,
+    pe: t?.pe ?? E,
+    Le: t?.Le || w,
+    je: 0,
+    we: null,
+    me: null,
+    o: t,
     dispose(e = true) {
       disposeChildren(n, e);
     }
   };
   if (t) {
-    const e = t.ue;
+    const e = t._e;
     if (e === null) {
-      t.ue = n;
+      t._e = n;
     } else {
-      n.Se = e;
-      t.ue = n;
+      n.We = e;
+      t._e = n;
     }
   }
   return n;
@@ -1062,14 +1294,14 @@ function createRoot(e, t) {
   return runWithOwner(n, () => e(n.dispose));
 }
 function runWithOwner(e, t) {
-  const n = Q;
+  const n = H;
   const r = W;
-  Q = e;
+  H = e;
   W = false;
   try {
     return t();
   } finally {
-    Q = n;
+    H = n;
     W = r;
   }
 }
@@ -1092,16 +1324,18 @@ function pending(e) {
   }
 }
 function isPending(e) {
-  const t = E;
-  const n = H;
-  E = true;
-  H = false;
+  const t = L;
+  const n = Q;
+  L = true;
+  Q = false;
   try {
     e();
-    return H;
+    return Q;
+  } catch {
+    return Q;
   } finally {
-    E = t;
-    H = n;
+    L = t;
+    Q = n;
   }
 }
 function refresh(e) {
@@ -1109,7 +1343,7 @@ function refresh(e) {
   N = true;
   try {
     if (typeof e !== "function") {
-      recompute(e[m]);
+      recompute(e[S]);
       return e;
     }
     return untrack(e);
@@ -1130,7 +1364,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t._e[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.Le[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -1140,10 +1374,10 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n._e = { ...n._e, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.Le = { ...n.Le, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?._e[e.id]);
+  return !isUndefined(t?.Le[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
@@ -1153,78 +1387,80 @@ function effect(e, t, n, r, i) {
   const o = computed(i?.render ? t => staleValues(() => e(t)) : e, r, {
     ...i,
     equals: () => {
-      o.Z = !o.J;
-      if (s) o.$.enqueue(o.Y, runEffect.bind(o));
+      o.de = !o.oe;
+      if (s) o.pe.enqueue(o.ae, 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) {
+  o.Ie = r;
+  o.He = t;
+  o.Re = n;
+  o.Te = undefined;
+  o.ae = i?.render ? d : p;
+  o.Pe = (e, t) => {
+    const n = e !== undefined ? e : o.ge;
+    const r = t !== undefined ? t : o.oe;
+    if (n & c) {
+      let e = r;
+      o.pe.notify(o, l, 0);
+      if (o.ae === p) {
         try {
-          return o.Ce
-            ? o.Ce(e, () => {
-                o.ke?.();
-                o.ke = undefined;
+          return o.Re
+            ? o.Re(e, () => {
+                o.Te?.();
+                o.Te = 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);
+      if (!o.pe.notify(o, c, c)) throw e;
+    } else if (o.ae === d) o.pe.notify(o, l | c, n, r);
   };
   recompute(o, true);
-  !i?.defer && (o.Y === h ? o.$.enqueue(o.Y, runEffect.bind(o)) : runEffect.call(o));
+  !i?.defer && (o.ae === p ? o.pe.enqueue(o.ae, runEffect.bind(o)) : runEffect.call(o));
   s = true;
-  onCleanup(() => o.ke?.());
+  onCleanup(() => o.Te?.());
 }
 function runEffect() {
-  if (!this.Z || this.m & u) return;
-  this.ke?.();
-  this.ke = undefined;
+  if (!this.de || this._ & u) return;
+  this.Te?.();
+  this.Te = undefined;
   try {
-    this.ke = this.Pe(this.ne, this.ve);
+    this.Te = this.He(this.ye, this.Ie);
   } catch (e) {
-    if (!this.$.notify(this, a, a)) throw e;
+    if (!this.pe.notify(this, c, c)) throw e;
   } finally {
-    this.ve = this.ne;
-    this.Z = false;
+    this.Ie = this.ye;
+    this.de = false;
   }
 }
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.Z || n.m & u) return;
-    n.Z = false;
+    if (!n.de || n._ & u) return;
+    n.de = false;
     recompute(n);
   };
   const n = computed(
     () => {
       try {
-        n.ke?.();
-        n.ke = undefined;
-        n.ke = staleValues(e) || undefined;
+        n.Te?.();
+        n.Te = undefined;
+        n.Te = 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?.());
+  n.Te = undefined;
+  n.de = true;
+  n.ae = h;
+  n.he = run;
+  n.pe.enqueue(p, run);
+  onCleanup(() => n.Te?.());
 }
 function createSignal(e, t, n) {
   if (typeof e === "function") {
@@ -1289,13 +1525,13 @@ function createOptimistic(e, t, n) {
 function onSettled(e) {
   getOwner()
     ? createTrackedEffect(() => untrack(e))
-    : A.enqueue(h, () => {
+    : E.enqueue(p, () => {
         const t = e();
         t?.();
       });
 }
 function unwrap(e) {
-  return e?.[V]?.[U] ?? e;
+  return e?.[F]?.[U] ?? e;
 }
 function getOverrideValue(e, t, n, r) {
   return t && r in t ? t[r] : e[r];
@@ -1306,22 +1542,22 @@ function getAllKeys(e, t, n) {
   return Array.from(new Set([...r, ...i]));
 }
 function applyState(e, t, n, r) {
-  const i = t?.[V];
+  const i = t?.[F];
   if (!i) return;
   const s = i[G];
   const o = i[K];
   let u = i[U];
   if (e === s && !o) return;
-  (i[X] || $).set(e, i[M]);
+  (i[Y] || ee).set(e, i[V]);
   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, p, h, y, g;
+    const f = getOverrideValue(s, o, u, "length");
+    if (e.length && f && e[0] && n(e[0]) != null) {
+      let l, c, a, d, p, h, y, g;
       for (
-        a = 0, d = Math.min(l, e.length);
+        a = 0, d = Math.min(f, e.length);
         a < d && ((h = getOverrideValue(s, o, u, a)) === e[a] || (h && e[a] && n(h) === n(e[a])));
         a++
       ) {
@@ -1330,7 +1566,7 @@ function applyState(e, t, n, r) {
       const w = new Array(e.length),
         S = new Map();
       for (
-        d = l - 1, p = e.length - 1;
+        d = f - 1, p = e.length - 1;
         d >= a &&
         p >= a &&
         ((h = getOverrideValue(s, o, u, d)) === e[p] || (h && e[p] && n(h) === n(e[p])));
@@ -1349,20 +1585,20 @@ function applyState(e, t, n, r) {
           i[U][c] && setSignal(i[U][c], s);
           applyState(e[c], s, n, r);
         }
-        t && i[U][q] && setSignal(i[U][q], void 0);
-        l !== e.length && i[U].length && setSignal(i[U].length, e.length);
+        t && i[U][M] && setSignal(i[U][M], void 0);
+        f !== e.length && i[U].length && setSignal(i[U].length, e.length);
         return;
       }
       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;
+        l = S.get(g);
+        y[c] = l === undefined ? -1 : l;
         S.set(g, c);
       }
-      for (f = a; f <= d; f++) {
-        h = getOverrideValue(s, o, u, f);
+      for (l = a; l <= d; l++) {
+        h = getOverrideValue(s, o, u, l);
         g = h ? n(h) : h;
         c = S.get(g);
         if (c !== undefined && c !== -1) {
@@ -1380,23 +1616,23 @@ function applyState(e, t, n, r) {
       }
       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[U][t] && setSignal(i[U][t], e[t]);
+      for (let t = 0, f = e.length; t < f; t++) {
+        const f = getOverrideValue(s, o, u, t);
+        isWrappable(f) ? applyState(e[t], wrap(f, i), n, r) : i[U][t] && setSignal(i[U][t], e[t]);
       }
     }
-    if (l !== e.length) {
+    if (f !== e.length) {
       t = true;
       i[U].length && setSignal(i[U].length, e.length);
     }
-    t && i[U][q] && setSignal(i[U][q], void 0);
+    t && i[U][M] && setSignal(i[U][M], void 0);
     return;
   }
   if (u) {
-    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 t = u[M];
+    const f = t || r ? getAllKeys(s, o, e) : Object.keys(u);
+    for (let l = 0, c = f.length; l < c; l++) {
+      const c = f[l];
       const a = u[c];
       const d = unwrap(getOverrideValue(s, o, u, c));
       let p = unwrap(e[c]);
@@ -1407,7 +1643,7 @@ function applyState(e, t, n, r) {
       } else applyState(p, wrap(d, i), n, r);
     }
   }
-  if ((u = i[L])) {
+  if ((u = i[J])) {
     const t = Object.keys(u);
     for (let n = 0, r = t.length; n < r; n++) {
       const r = t[n];
@@ -1429,9 +1665,9 @@ function createProjectionInternal(e, t = {}, n) {
   let r;
   const i = new WeakMap();
   const wrapper = e => {
-    e[J] = wrapProjection;
-    e[X] = i;
-    Object.defineProperty(e, Y, {
+    e[X] = wrapProjection;
+    e[Y] = i;
+    Object.defineProperty(e, Z, {
       get() {
         return r;
       },
@@ -1440,8 +1676,8 @@ function createProjectionInternal(e, t = {}, n) {
   };
   const wrapProjection = e => {
     if (i.has(e)) return i.get(e);
-    if (e[V]?.[J] === wrapProjection) return e;
-    const t = createStoreProxy(e, ne, wrapper);
+    if (e[F]?.[X] === wrapProjection) return e;
+    const t = createStoreProxy(e, re, wrapper);
     i.set(e, t);
     return t;
   };
@@ -1456,7 +1692,7 @@ function createProjectionInternal(e, t = {}, n) {
       i !== r && i !== undefined && reconcile(i, n?.key || "id", n?.all)(s);
     });
   });
-  r.we = true;
+  r.Ee = true;
   return { store: s, node: r };
 }
 function createProjection(e, t = {}, n) {
@@ -1498,46 +1734,46 @@ const T = {
     return true;
   }
 };
-const q = Symbol(0),
+const M = Symbol(0),
+  q = Symbol(0),
   F = Symbol(0),
   V = Symbol(0),
-  M = Symbol(0),
-  D = Symbol(0);
-const B = new WeakMap();
+  B = Symbol(0);
+const D = 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) {
+  J = "h",
+  X = "w",
+  Y = "l",
+  Z = "f",
+  $ = "p";
+function createStoreProxy(e, t = re, n) {
   let r;
   if (Array.isArray(e)) {
     r = [];
     r.v = e;
   } else r = { v: e };
   n && n(r);
-  return (r[M] = new Proxy(r, t));
+  return (r[V] = new Proxy(r, t));
 }
-const $ = new WeakMap();
+const ee = new WeakMap();
 function wrap(e, t) {
-  if (t?.[J]) return t[J](e, t);
-  let n = e[M] || $.get(e);
-  if (!n) $.set(e, (n = createStoreProxy(e)));
+  if (t?.[X]) return t[X](e, t);
+  let n = e[V] || ee.get(e);
+  if (!n) ee.set(e, (n = createStoreProxy(e)));
   return n;
 }
 function isWrappable(e) {
   return e != null && typeof e === "object" && !Object.isFrozen(e);
 }
-let ee = false;
+let te = false;
 function setWriteOverride(e) {
-  ee = e;
+  te = e;
 }
 function writeOnly(e) {
-  return ee || !!te?.has(e);
+  return te || !!ne?.has(e);
 }
 function getNodes(e, t) {
   let n = e[t];
@@ -1556,11 +1792,11 @@ function getNode(e, t, n, r, i = isEqual, s) {
     },
     r
   );
-  if (s) o.le = true;
+  if (s) o.U = true;
   return (e[t] = o);
 }
-function trackSelf(e, t = q) {
-  getObserver() && read(getNode(getNodes(e, U), t, undefined, e[Y], false, e[Z]));
+function trackSelf(e, t = M) {
+  getObserver() && read(getNode(getNodes(e, U), t, undefined, e[Z], false, e[$]));
 }
 function getKeys(e, t, n = true) {
   const r = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -1568,7 +1804,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] !== D) i.add(e);
+    if (t[e] !== B) i.add(e);
     else i.delete(e);
   }
   return Array.from(i);
@@ -1576,18 +1812,18 @@ function getKeys(e, t, n = true) {
 function getPropertyDescriptor(e, t, n) {
   let r = e;
   if (t && n in t) {
-    if (r[n] === D) return void 0;
+    if (r[n] === B) return void 0;
     if (!(n in r)) r = t;
   }
   return Reflect.getOwnPropertyDescriptor(r, n);
 }
-let te = null;
-const ne = {
+let ne = null;
+const re = {
   get(e, t, n) {
-    if (t === V) return e;
-    if (t === M) return n;
-    if (t === m) return e[Y];
-    if (t === q || t === F) {
+    if (t === F) return e;
+    if (t === V) return n;
+    if (t === S) return e[Z];
+    if (t === M || t === q) {
       trackSelf(e, t);
       return n;
     }
@@ -1595,105 +1831,105 @@ const ne = {
     const i = r[t];
     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];
+    const u = !!e[G][F];
+    const f = s ? e[z] : e[K] && t in e[K] ? e[K] : e[G];
     if (!i) {
-      const e = Object.getOwnPropertyDescriptor(l, t);
+      const e = Object.getOwnPropertyDescriptor(f, t);
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = i && (o || !u) ? (i.te !== g ? (i.le ? i.ne : i.te) : i.ne) : l[t];
-      n === D && (n = undefined);
+      let n = i && (o || !u) ? (i.J !== y ? (i.U ? i.ye : i.J) : i.ye) : f[t];
+      n === B && (n = undefined);
       if (!isWrappable(n)) return n;
       const r = wrap(n, e);
-      te?.add(r);
+      ne?.add(r);
       return r;
     }
-    let f = i ? (o || !u ? read(r[t]) : (read(r[t]), l[t])) : l[t];
-    f === D && (f = undefined);
+    let l = i ? (o || !u ? read(r[t]) : (read(r[t]), f[t])) : f[t];
+    l === B && (l = undefined);
     if (!i) {
-      if (!o && typeof f === "function" && !l.hasOwnProperty(t)) {
+      if (!o && typeof l === "function" && !f.hasOwnProperty(t)) {
         let t;
         return !Array.isArray(e[G]) && (t = Object.getPrototypeOf(e[G])) && t !== Object.prototype
-          ? f.bind(l)
-          : f;
+          ? l.bind(f)
+          : l;
       } else if (getObserver()) {
-        return read(getNode(r, t, isWrappable(f) ? wrap(f, e) : f, e[Y], isEqual, e[Z]));
+        return read(getNode(r, t, isWrappable(l) ? wrap(l, e) : l, e[Z], isEqual, e[$]));
       }
     }
-    return isWrappable(f) ? wrap(f, e) : f;
+    return isWrappable(l) ? wrap(l, e) : l;
   },
   has(e, t) {
-    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]));
+    if (t === V || t === M || t === "__proto__") return true;
+    const n = e[z] && t in e[z] ? e[z][t] !== B : e[K] && t in e[K] ? e[K][t] !== B : t in e[G];
+    getObserver() && read(getNode(getNodes(e, J), t, n, e[Z], isEqual, e[$]));
     return n;
   },
   set(e, t, n) {
-    const r = e[M];
+    const r = e[V];
     if (writeOnly(r)) {
-      if (e[Z]) {
-        const t = e[Y];
-        if (t?.X) {
-          A.initTransition(t.X);
+      if (e[$]) {
+        const t = e[Z];
+        if (t?.B) {
+          E.initTransition(t.B);
         }
       }
       untrack(() => {
         const i = e[G];
         const s = i[t];
-        const o = e[Z] && !k;
+        const o = e[$] && !P;
         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 f = e[z] && t in e[z] ? e[z][t] : e[K] && t in e[K] ? e[K][t] : s;
+        const l = n?.[F]?.[G] ?? n;
+        if (f === l) 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 (l !== undefined && l === s) delete e[u][t];
+        else (e[u] || (e[u] = Object.create(null)))[t] = l;
+        const a = isWrappable(l);
+        if (isWrappable(f)) {
+          const e = D.get(f);
+          e && (e instanceof Set ? e.delete(r) : D.delete(f));
         }
-        if (recursivelyNotify(r, $) && a) recursivelyAddParent(f, r);
-        e[L]?.[t] && setSignal(e[L][t], true);
+        if (recursivelyNotify(r, ee) && a) recursivelyAddParent(l, r);
+        e[J]?.[t] && setSignal(e[J][t], true);
         const d = getNodes(e, U);
-        d[t] && setSignal(d[t], () => (a ? wrap(f, e) : f));
+        d[t] && setSignal(d[t], () => (a ? wrap(l, e) : l));
         if (Array.isArray(i)) {
           if (t === "length") {
-            d.length && setSignal(d.length, f);
+            d.length && setSignal(d.length, l);
           } else {
             const e = parseInt(t) + 1;
             if (e > c) d.length && setSignal(d.length, e);
           }
         }
-        d[q] && setSignal(d[q], undefined);
+        d[M] && setSignal(d[M], undefined);
       });
     }
     return true;
   },
   deleteProperty(e, t) {
-    const n = e[z]?.[t] === D;
-    const r = e[K]?.[t] === D;
-    if (writeOnly(e[M]) && !n && !r) {
+    const n = e[z]?.[t] === B;
+    const r = e[K]?.[t] === B;
+    if (writeOnly(e[V]) && !n && !r) {
       untrack(() => {
-        const n = e[Z] && !k;
+        const n = e[$] && !P;
         const r = n ? z : K;
-        if (n) trackOptimisticStore(e[M]);
+        if (n) trackOptimisticStore(e[V]);
         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;
+          (e[r] || (e[r] = Object.create(null)))[t] = B;
         } else if (e[r] && t in e[r]) {
           delete e[r][t];
         } else return true;
         if (isWrappable(i)) {
-          const t = B.get(i);
-          t && (t instanceof Set ? t.delete(e) : B.delete(i));
+          const t = D.get(i);
+          t && (t instanceof Set ? t.delete(e) : D.delete(i));
         }
-        if (e[L]?.[t]) setSignal(e[L][t], false);
+        if (e[J]?.[t]) setSignal(e[J][t], false);
         const s = getNodes(e, U);
         s[t] && setSignal(s[t], undefined);
-        s[q] && setSignal(s[q], undefined);
+        s[M] && setSignal(s[M], undefined);
       });
     }
     return true;
@@ -1704,7 +1940,7 @@ const ne = {
     if (e[z]) {
       const n = new Set(t);
       for (const t of Reflect.ownKeys(e[z])) {
-        if (e[z][t] !== D) n.add(t);
+        if (e[z][t] !== B) n.add(t);
         else n.delete(t);
       }
       t = Array.from(n);
@@ -1712,9 +1948,9 @@ const ne = {
     return t;
   },
   getOwnPropertyDescriptor(e, t) {
-    if (t === M) return { value: e[M], writable: true, configurable: true };
+    if (t === V) return { value: e[V], writable: true, configurable: true };
     if (e[z] && t in e[z]) {
-      if (e[z][t] === D) return undefined;
+      if (e[z][t] === B) return undefined;
       const n = getPropertyDescriptor(e[G], e[K], t);
       if (n) {
         return { ...n, value: e[z][t] };
@@ -1728,9 +1964,9 @@ const ne = {
   }
 };
 function storeSetter(e, t) {
-  const n = te;
-  te = new Set();
-  te.add(e);
+  const n = ne;
+  ne = new Set();
+  ne.add(e);
   try {
     const n = t(e);
     if (n !== e && n !== undefined) {
@@ -1746,8 +1982,8 @@ function storeSetter(e, t) {
       }
     }
   } finally {
-    te.clear();
-    te = n;
+    ne.clear();
+    ne = n;
   }
 }
 function createStore(e, t, n) {
@@ -1756,17 +1992,17 @@ function createStore(e, t, n) {
   return [i, e => storeSetter(i, e)];
 }
 function recursivelyNotify(e, t) {
-  let n = e[V] || t?.get(e)?.[V];
+  let n = e[F] || t?.get(e)?.[F];
   let r = false;
   if (n) {
-    const e = getNodes(n, U)[F];
+    const e = getNodes(n, U)[q];
     if (e) {
       setSignal(e, undefined);
       r = true;
     }
-    t = n[X] || t;
+    t = n[Y] || t;
   }
-  const i = B.get(n?.[G] || e);
+  const i = D.get(n?.[G] || e);
   if (!i) return r;
   if (i instanceof Set) {
     for (let e of i) r = recursivelyNotify(e, t) || r;
@@ -1775,16 +2011,16 @@ function recursivelyNotify(e, t) {
 }
 function recursivelyAddParent(e, t) {
   let n;
-  const r = e[V];
+  const r = e[F];
   if (r) {
     n = r[K];
     e = r[G];
   }
   if (t) {
-    let n = B.get(e);
-    if (!n) B.set(e, t);
+    let n = D.get(e);
+    if (!n) D.set(e, t);
     else if (n !== t) {
-      if (!(n instanceof Set)) B.set(e, (n = new Set([n])));
+      if (!(n instanceof Set)) D.set(e, (n = new Set([n])));
       else if (n.has(t)) return;
       n.add(t);
     } else return;
@@ -1806,10 +2042,10 @@ function recursivelyAddParent(e, t) {
 }
 function deep(e) {
   recursivelyAddParent(e);
-  return e[F];
+  return e[q];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.L ||= clearOptimisticStore;
+  GlobalQueue.ie ||= clearOptimisticStore;
   const r = typeof e === "function";
   const i = (r ? t : e) ?? {};
   const s = r ? e : undefined;
@@ -1817,19 +2053,28 @@ function createOptimisticStore(e, t, n) {
   return [o, e => storeSetter(o, e)];
 }
 function clearOptimisticStore(e) {
-  const t = e[V];
+  const t = e[F];
   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);
+  setProjectionWriteActive(true);
+  try {
+    if (r) {
+      for (const e of Reflect.ownKeys(n)) {
+        if (r[e]) {
+          r[e].M = undefined;
+          const n = t[K] && e in t[K] ? t[K][e] : t[G][e];
+          const i = n === B ? undefined : n;
+          setSignal(r[e], isWrappable(i) ? wrap(i, t) : i);
+        }
+      }
+      if (r[M]) {
+        r[M].M = undefined;
+        setSignal(r[M], undefined);
       }
     }
-    r[q] && setSignal(r[q], undefined);
+  } finally {
+    setProjectionWriteActive(false);
   }
   delete t[z];
 }
@@ -1837,10 +2082,10 @@ 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, {
+    e[X] = wrapProjection;
+    e[Y] = i;
+    e[$] = true;
+    Object.defineProperty(e, Z, {
       get() {
         return r;
       },
@@ -1849,8 +2094,8 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
   };
   const wrapProjection = e => {
     if (i.has(e)) return i.get(e);
-    if (e[V]?.[J] === wrapProjection) return e;
-    const t = createStoreProxy(e, ne, wrapper);
+    if (e[F]?.[X] === wrapProjection) return e;
+    const t = createStoreProxy(e, re, wrapper);
     i.set(e, t);
     return t;
   };
@@ -1875,21 +2120,21 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
         setProjectionWriteActive(false);
       }
     });
-    r.we = true;
+    r.Ee = true;
   }
   return { store: s, node: r };
 }
 function snapshot(e, t, n) {
-  let r, i, s, o, u, l;
+  let r, i, s, o, u, f;
   if (!isWrappable(e)) return e;
   if (t && t.has(e)) return t.get(e);
   if (!t) t = new Map();
-  if ((r = e[V] || n?.get(e)?.[V])) {
+  if ((r = e[F] || n?.get(e)?.[F])) {
     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 = $;
+    n = ee;
   } else {
     i = Array.isArray(e);
     t.set(e, e);
@@ -1897,26 +2142,26 @@ function snapshot(e, t, n) {
   if (i) {
     const r = s?.length || e.length;
     for (let i = 0; i < r; i++) {
-      l = s && i in s ? s[i] : e[i];
-      if (l === D) continue;
-      if ((u = snapshot(l, t, n)) !== l || o) {
+      f = s && i in s ? s[i] : e[i];
+      if (f === B) continue;
+      if ((u = snapshot(f, t, n)) !== f || o) {
         if (!o) t.set(e, (o = [...e]));
         o[i] = u;
       }
     }
   } else {
     const r = getKeys(e, s);
-    for (let i = 0, f = r.length; i < f; i++) {
-      let f = r[i];
-      const c = getPropertyDescriptor(e, s, f);
+    for (let i = 0, l = r.length; i < l; i++) {
+      let l = r[i];
+      const c = getPropertyDescriptor(e, s, l);
       if (c.get) continue;
-      l = s && f in s ? s[f] : e[f];
-      if ((u = snapshot(l, t, n)) !== e[f] || o) {
+      f = s && l in s ? s[l] : e[l];
+      if ((u = snapshot(f, t, n)) !== e[l] || o) {
         if (!o) {
           o = Object.create(Object.getPrototypeOf(e));
           Object.assign(o, e);
         }
-        o[f] = u;
+        o[l] = u;
       }
     }
   }
@@ -1925,13 +2170,13 @@ function snapshot(e, t, n) {
 function trueFn() {
   return true;
 }
-const re = {
+const ie = {
   get(e, t, n) {
-    if (t === M) return n;
+    if (t === V) return n;
     return e.get(t);
   },
   has(e, t) {
-    if (t === M) return true;
+    if (t === V) return true;
     return e.has(t);
   },
   set: trueFn,
@@ -1954,23 +2199,23 @@ const re = {
 function resolveSource(e) {
   return !(e = typeof e === "function" ? e() : e) ? {} : e;
 }
-const ie = Symbol(0);
+const se = 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 && M in i);
-    const s = !!i && i[ie];
+    t = t || (!!i && V in i);
+    const s = !!i && i[se];
     if (s) n.push(...s);
     else n.push(typeof i === "function" ? ((t = true), createMemo(i)) : i);
   }
-  if (w && t) {
+  if (g && t) {
     return new Proxy(
       {
         get(e) {
-          if (e === ie) return n;
+          if (e === se) return n;
           for (let t = n.length - 1; t >= 0; t--) {
             const r = resolveSource(n[t]);
             if (e in r) return r[e];
@@ -1988,7 +2233,7 @@ function merge(...e) {
           return [...new Set(e)];
         }
       },
-      re
+      ie
     );
   }
   const r = Object.create(null);
@@ -2020,12 +2265,12 @@ function merge(...e) {
     if (n.get) Object.defineProperty(o, t, n);
     else o[t] = n.value;
   }
-  o[ie] = n;
+  o[se] = n;
   return o;
 }
 function omit(e, ...t) {
   const n = new Set(t);
-  if (w && M in e) {
+  if (g && V in e) {
     return new Proxy(
       {
         get(t) {
@@ -2038,7 +2283,7 @@ function omit(e, ...t) {
           return Object.keys(e).filter(e => !n.has(e));
         }
       },
-      re
+      ie
     );
   }
   const r = {};
@@ -2056,313 +2301,321 @@ function mapArray(e, t, n) {
   const r = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      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
+      Me: createOwner(),
+      qe: 0,
+      Fe: e,
+      Ve: [],
+      Be: t,
+      De: [],
+      Ge: [],
+      Ke: r,
+      ze: r || n?.keyed === false ? [] : undefined,
+      Ue: t.length > 1 ? [] : undefined,
+      Je: n?.fallback
     })
   );
 }
-const se = { pureWrite: true };
+const oe = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.je() || [],
+  const e = this.Fe() || [],
     t = e.length;
-  e[q];
-  runWithOwner(this.Ae, () => {
+  e[M];
+  runWithOwner(this.Me, () => {
     let n,
       r,
-      i = this.Re
+      i = this.ze
         ? () => {
-            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.ze[r] = signal(e[r], oe);
+            this.Ue && (this.Ue[r] = signal(r, oe));
+            return this.Be(
+              read.bind(null, this.ze[r]),
+              this.Ue ? read.bind(null, this.Ue[r]) : undefined
             );
           }
-        : this.Te
+        : this.Ue
           ? () => {
               const t = e[r];
-              this.Te[r] = signal(r, se);
-              return this.Ee(() => t, read.bind(null, this.Te[r]));
+              this.Ue[r] = signal(r, oe);
+              return this.Be(() => t, read.bind(null, this.Ue[r]));
             }
           : () => {
               const t = e[r];
-              return this.Ee(() => t);
+              return this.Be(() => t);
             };
     if (t === 0) {
-      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.qe && !this.He[0]) {
-        this.He[0] = runWithOwner((this.Ie[0] = createOwner()), this.qe);
-      }
-    } else if (this.We === 0) {
-      if (this.Ie[0]) this.Ie[0].dispose();
-      this.He = new Array(t);
+      if (this.qe !== 0) {
+        this.Me.dispose(false);
+        this.Ge = [];
+        this.Ve = [];
+        this.De = [];
+        this.qe = 0;
+        this.ze && (this.ze = []);
+        this.Ue && (this.Ue = []);
+      }
+      if (this.Je && !this.De[0]) {
+        this.De[0] = runWithOwner((this.Ge[0] = createOwner()), this.Je);
+      }
+    } else if (this.qe === 0) {
+      if (this.Ge[0]) this.Ge[0].dispose();
+      this.De = new Array(t);
       for (r = 0; r < t; r++) {
-        this.Ne[r] = e[r];
-        this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
+        this.Ve[r] = e[r];
+        this.De[r] = runWithOwner((this.Ge[r] = createOwner()), i);
       }
-      this.We = t;
+      this.qe = t;
     } else {
       let s,
         o,
         u,
-        l,
         f,
+        l,
         c,
         a,
         d = new Array(t),
         p = new Array(t),
-        h = this.Re ? new Array(t) : undefined,
-        y = this.Te ? new Array(t) : undefined;
+        h = this.ze ? new Array(t) : undefined,
+        y = this.Ue ? new Array(t) : undefined;
       for (
-        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 = 0, o = Math.min(this.qe, t);
+        s < o && (this.Ve[s] === e[s] || (this.ze && compare(this.Ke, this.Ve[s], e[s])));
         s++
       ) {
-        if (this.Re) setSignal(this.Re[s], e[s]);
+        if (this.ze) setSignal(this.ze[s], e[s]);
       }
       for (
-        o = this.We - 1, u = t - 1;
+        o = this.qe - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.Ne[o] === e[u] || (this.Re && compare(this.Qe, this.Ne[o], e[u])));
+        (this.Ve[o] === e[u] || (this.ze && compare(this.Ke, this.Ve[o], e[u])));
         o--, u--
       ) {
-        d[u] = this.He[o];
-        p[u] = this.Ie[o];
-        h && (h[u] = this.Re[o]);
-        y && (y[u] = this.Te[o]);
+        d[u] = this.De[o];
+        p[u] = this.Ge[o];
+        h && (h[u] = this.ze[o]);
+        y && (y[u] = this.Ue[o]);
       }
       c = new Map();
       a = new Array(u + 1);
       for (r = u; r >= s; r--) {
-        l = e[r];
-        f = this.Qe ? this.Qe(l) : l;
-        n = c.get(f);
+        f = e[r];
+        l = this.Ke ? this.Ke(f) : f;
+        n = c.get(l);
         a[r] = n === undefined ? -1 : n;
-        c.set(f, r);
+        c.set(l, r);
       }
       for (n = s; n <= o; n++) {
-        l = this.Ne[n];
-        f = this.Qe ? this.Qe(l) : l;
-        r = c.get(f);
+        f = this.Ve[n];
+        l = this.Ke ? this.Ke(f) : f;
+        r = c.get(l);
         if (r !== undefined && r !== -1) {
-          d[r] = this.He[n];
-          p[r] = this.Ie[n];
-          h && (h[r] = this.Re[n]);
-          y && (y[r] = this.Te[n]);
+          d[r] = this.De[n];
+          p[r] = this.Ge[n];
+          h && (h[r] = this.ze[n]);
+          y && (y[r] = this.Ue[n]);
           r = a[r];
-          c.set(f, r);
-        } else this.Ie[n].dispose();
+          c.set(l, r);
+        } else this.Ge[n].dispose();
       }
       for (r = s; r < t; r++) {
         if (r in d) {
-          this.He[r] = d[r];
-          this.Ie[r] = p[r];
+          this.De[r] = d[r];
+          this.Ge[r] = p[r];
           if (h) {
-            this.Re[r] = h[r];
-            setSignal(this.Re[r], e[r]);
+            this.ze[r] = h[r];
+            setSignal(this.ze[r], e[r]);
           }
           if (y) {
-            this.Te[r] = y[r];
-            setSignal(this.Te[r], r);
+            this.Ue[r] = y[r];
+            setSignal(this.Ue[r], r);
           }
         } else {
-          this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
+          this.De[r] = runWithOwner((this.Ge[r] = createOwner()), i);
         }
       }
-      this.He = this.He.slice(0, (this.We = t));
-      this.Ne = e.slice(0);
+      this.De = this.De.slice(0, (this.qe = t));
+      this.Ve = e.slice(0);
     }
   });
-  return this.He;
+  return this.De;
 }
 function repeat(e, t, n) {
   return updateRepeat.bind({
-    Ae: createOwner(),
-    We: 0,
-    Fe: 0,
-    Ve: e,
-    Ee: t,
-    Ie: [],
-    He: [],
-    Me: n?.from,
-    qe: n?.fallback
+    Me: createOwner(),
+    qe: 0,
+    Xe: 0,
+    Ye: e,
+    Be: t,
+    Ge: [],
+    De: [],
+    Ze: n?.from,
+    Je: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.Ve();
-  const t = this.Me?.() || 0;
-  runWithOwner(this.Ae, () => {
+  const e = this.Ye();
+  const t = this.Ze?.() || 0;
+  runWithOwner(this.Me, () => {
     if (e === 0) {
-      if (this.We !== 0) {
-        this.Ae.dispose(false);
-        this.Ie = [];
-        this.He = [];
-        this.We = 0;
+      if (this.qe !== 0) {
+        this.Me.dispose(false);
+        this.Ge = [];
+        this.De = [];
+        this.qe = 0;
       }
-      if (this.qe && !this.He[0]) {
-        this.He[0] = runWithOwner((this.Ie[0] = createOwner()), this.qe);
+      if (this.Je && !this.De[0]) {
+        this.De[0] = runWithOwner((this.Ge[0] = createOwner()), this.Je);
       }
       return;
     }
     const n = t + 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;
+    const r = this.Xe + this.qe;
+    if (this.qe === 0 && this.Ge[0]) this.Ge[0].dispose();
+    for (let e = n; e < r; e++) this.Ge[e - this.Xe].dispose();
+    if (this.Xe < t) {
+      let e = this.Xe;
+      while (e < t && e < this.qe) this.Ge[e++].dispose();
+      this.Ge.splice(0, t - this.Xe);
+      this.De.splice(0, t - this.Xe);
+    } else if (this.Xe > t) {
+      let n = r - this.Xe - 1;
+      let i = this.Xe - t;
+      this.Ge.length = this.De.length = e;
       while (n >= i) {
-        this.Ie[n] = this.Ie[n - i];
-        this.He[n] = this.He[n - i];
+        this.Ge[n] = this.Ge[n - i];
+        this.De[n] = this.De[n - i];
         n--;
       }
       for (let e = 0; e < i; e++) {
-        this.He[e] = runWithOwner((this.Ie[e] = createOwner()), () => this.Ee(e + t));
+        this.De[e] = runWithOwner((this.Ge[e] = createOwner()), () => this.Be(e + t));
       }
     }
     for (let e = r; e < n; e++) {
-      this.He[e - t] = runWithOwner((this.Ie[e - t] = createOwner()), () => this.Ee(e));
+      this.De[e - t] = runWithOwner((this.Ge[e - t] = createOwner()), () => this.Be(e));
     }
-    this.He = this.He.slice(0, e);
-    this.Fe = t;
-    this.We = e;
+    this.De = this.De.slice(0, e);
+    this.Xe = t;
+    this.qe = e;
   });
-  return this.He;
+  return this.De;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, { lazy: true });
-  n.pe = () => {
-    const e = n.re;
-    n.re &= ~n.De;
-    n.$.notify(n, n.De, e);
+  n.Pe = (e, t) => {
+    const r = e !== undefined ? e : n.ge;
+    const i = t !== undefined ? t : n.oe;
+    n.ge &= ~n.$e;
+    n.pe.notify(n, n.$e, r, i);
   };
-  n.De = t;
-  n.we = true;
+  n.$e = t;
+  n.Ee = true;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, r) {
-  const i = e.$;
-  i.addChild((e.$ = n));
-  onCleanup(() => i.removeChild(e.$));
+  const i = e.pe;
+  i.addChild((e.pe = n));
+  onCleanup(() => i.removeChild(e.pe));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), r);
   });
 }
 class ConditionalQueue extends Queue {
-  Be;
-  Ge = new Set();
-  D = new Set();
+  et;
+  tt = new Set();
+  $ = new Set();
   constructor(e) {
     super();
-    this.Be = e;
+    this.et = e;
   }
   run(e) {
-    if (!e || read(this.Be)) return;
+    if (!e || read(this.et)) return;
     return super.run(e);
   }
-  notify(e, t, n) {
-    if (read(this.Be)) {
+  notify(e, t, n, r) {
+    if (read(this.et)) {
+      if (t & l) {
+        if (n & l) {
+          this.$.add(e);
+          t &= ~l;
+        } else if (this.$.delete(e)) t &= ~l;
+      }
       if (t & c) {
         if (n & c) {
-          this.D.add(e);
+          this.tt.add(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;
+        } else if (this.tt.delete(e)) t &= ~c;
       }
     }
-    return t ? super.notify(e, t, n) : true;
+    return t ? super.notify(e, t, n, r ?? e.oe) : true;
   }
 }
 class CollectionQueue extends Queue {
-  Ke;
-  Ie = new Set();
-  Be = signal(false, { pureWrite: true });
-  ze = false;
+  nt;
+  rt = new Set();
+  et = signal(false, { pureWrite: true });
+  it = false;
   constructor(e) {
     super();
-    this.Ke = e;
+    this.nt = e;
   }
   run(e) {
-    if (!e || read(this.Be)) return;
+    if (!e || read(this.et)) return;
     return super.run(e);
   }
-  notify(e, t, n) {
-    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);
+  notify(e, t, n, r) {
+    if (!(t & this.nt) || (this.nt & l && this.it)) return super.notify(e, t, n, r);
+    if (n & this.nt) {
+      const t = r?.t || e.oe?.t;
+      if (t) {
+        const e = this.rt.size === 0;
+        this.rt.add(t);
+        if (e) setSignal(this.et, true);
+      }
+    }
+    t &= ~this.nt;
+    return t ? super.notify(e, t, n, r) : true;
+  }
+  checkSources() {
+    for (const e of this.rt) {
+      if (!(e.ge & this.nt)) this.rt.delete(e);
     }
-    t &= ~this.Ke;
-    return t ? super.notify(e, t, n) : true;
+    if (!this.rt.size) setSignal(this.et, false);
   }
 }
-var oe;
+var ue;
 (function (e) {
   e["VISIBLE"] = "visible";
   e["HIDDEN"] = "hidden";
-})(oe || (oe = {}));
+})(ue || (ue = {}));
 function createBoundary(e, t) {
   const n = createOwner();
-  const r = new ConditionalQueue(computed(() => t() === oe.HIDDEN));
+  const r = new ConditionalQueue(computed(() => t() === ue.HIDDEN));
   const i = createBoundChildren(n, e, r, 0);
   computed(() => {
-    const e = read(r.Be);
-    i.De = e ? a | c : 0;
+    const e = read(r.et);
+    i.$e = e ? c | l : 0;
     if (!e) {
-      r.D.forEach(e => r.notify(e, c, c));
-      r.Ge.forEach(e => r.notify(e, a, a));
-      r.D.clear();
-      r.Ge.clear();
+      r.$.forEach(e => r.notify(e, l, l, e.oe));
+      r.tt.forEach(e => r.notify(e, c, c, e.oe));
+      r.$.clear();
+      r.tt.clear();
     }
   });
-  return () => (read(r.Be) ? undefined : read(i));
+  return () => (read(r.et) ? 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.Be)) {
+    if (!read(i.et)) {
       const e = read(s);
-      if (!untrack(() => read(i.Be))) {
-        i.ze = true;
+      if (!untrack(() => read(i.et))) {
+        i.it = true;
         return e;
       }
     }
@@ -2371,28 +2624,14 @@ function createCollectionBoundary(e, t, n) {
   return read.bind(null, o);
 }
 function createLoadBoundary(e, t) {
-  return createCollectionBoundary(c, e, () => t());
-}
-function collectErrorSources(e, t) {
-  let n = true;
-  let r = e.j;
-  while (r !== null) {
-    const e = r.H;
-    if (e.j && e.re & a) {
-      n = false;
-      collectErrorSources(e, t);
-    }
-    r = r.N;
-  }
-  n && t.push(e);
+  return createCollectionBoundary(l, e, () => t());
 }
 function createErrorBoundary(e, t) {
-  return createCollectionBoundary(a, e, e => {
-    let n = e.Ie.values().next().value;
-    return t(n.J, () => {
-      const t = [];
-      for (const n of e.Ie) collectErrorSources(n, t);
-      for (const e of t) recompute(e);
+  return createCollectionBoundary(c, e, e => {
+    let n = e.rt.values().next().value;
+    const r = n.oe?.cause ?? n.oe;
+    return t(r, () => {
+      for (const t of e.rt) recompute(t);
       schedule();
     });
   });
@@ -2446,13 +2685,13 @@ function flattenArray(e, t = [], n) {
   if (r) throw r;
   return i;
 }
-exports.$PROXY = M;
-exports.$TARGET = V;
-exports.$TRACK = q;
+exports.$PROXY = V;
+exports.$TARGET = F;
+exports.$TRACK = M;
 exports.ContextNotFoundError = ContextNotFoundError;
 exports.NoOwnerError = NoOwnerError;
 exports.NotReadyError = NotReadyError;
-exports.SUPPORTS_PROXY = w;
+exports.SUPPORTS_PROXY = g;
 exports.action = action;
 exports.createBoundary = createBoundary;
 exports.createContext = createContext;