@solidjs/signals 0.9.7 → 0.9.9

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,322 @@ 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);
+  }
+  t = { t: e, T: new Set(), M: [[], []], q: null, F: x };
+  C.set(e, t);
+  k.add(t);
+  e.V = e.B || 0;
+  return t;
+}
+function findLane(e) {
+  while (e.q) e = e.q;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.q = e;
+  for (const n of t.T) e.T.add(n);
+  e.M[0].push(...t.M[0]);
+  e.M[1].push(...t.M[1]);
+  return e;
+}
+function clearLaneEntry(e) {
+  C.delete(e);
+}
+function resolveLane(e) {
+  const t = e.D;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (k.has(n)) return n;
+  e.D = undefined;
+  return undefined;
+}
+function hasActiveOverride(e) {
+  return !!(e.G && e.K !== y);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const r = e.D;
+  if (r) {
+    if (r.q) {
+      e.D = t;
+      return;
+    }
+    const i = findLane(r);
+    if (k.has(i)) {
+      if (i !== n && !hasActiveOverride(e)) {
+        mergeLanes(n, i);
+      }
+      return;
+    }
+  }
+  e.D = t;
+}
+function runLaneEffects(e) {
+  for (const t of k) {
+    if (t.q || t.T.size > 0) continue;
+    const n = t.M[e - 1];
+    if (n.length) {
+      t.M[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.U) queueMicrotask(flush);
 }
 class Queue {
-  i = null;
-  q = [[], []];
-  F = [[], []];
-  V = [];
-  created = x;
+  o = null;
+  J = [[], []];
+  X = [];
+  created = O;
   addChild(e) {
-    this.V.push(e);
-    e.i = this;
+    this.X.push(e);
+    e.o = this;
   }
   removeChild(e) {
-    const t = this.V.indexOf(e);
+    const t = this.X.indexOf(e);
     if (t >= 0) {
-      this.V.splice(t, 1);
-      e.i = null;
+      this.X.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.J[e - 1].length) {
+      const t = this.J[e - 1];
+      this.J[e - 1] = [];
+      runQueue(t, e);
+    }
+    for (let t = 0; t < this.X.length; t++) this.X[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.M[e - 1].push(t);
+      } else {
+        this.J[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.J[0].push(...this.J[0]);
+    e.J[1].push(...this.J[1]);
+    this.J = [[], []];
+    for (let t = 0; t < this.X.length; t++) {
+      let n = this.X[t];
+      let r = e.X[t];
       if (!r) {
-        r = { q: [[], []], V: [] };
-        e.V[t] = r;
+        r = { J: [[], []], X: [] };
+        e.X[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.J[0].push(...e.J[0]);
+    this.J[1].push(...e.J[1]);
+    for (let t = 0; t < e.X.length; t++) {
+      const n = e.X[t];
+      let r = this.X[t];
       if (r) r.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  T = false;
-  D = [];
-  B = [];
-  G = new Set();
-  static K;
-  static U;
-  static L = null;
+  U = false;
+  Y = [];
+  Z = [];
+  $ = new Set();
+  static ee;
+  static te;
+  static ne = null;
   flush() {
-    if (this.T) return;
-    this.T = true;
+    if (this.U) return;
+    this.U = true;
     try {
-      runHeap(_, GlobalQueue.K);
-      if (v) {
-        const e = transitionComplete(v);
+      runHeap(_, GlobalQueue.ee);
+      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.ee);
+          this.Y = [];
+          this.Z = [];
+          this.$ = new Set();
+          runLaneEffects(d);
+          runLaneEffects(p);
+          this.stashQueues(x.re);
+          O++;
+          v = _.m >= _.j;
+          reassignPendingTransition(x.Y);
+          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.Y !== x.Y && this.Y.push(...x.Y);
+        this.restoreQueues(x.re);
+        m.delete(x);
+        const t = x;
+        x = null;
+        reassignPendingTransition(this.Y);
         finalizePureQueue(t);
       } else {
-        if (b.size) runHeap(O, GlobalQueue.K);
+        if (m.size) runHeap(b, GlobalQueue.ee);
         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.U = 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.ie;
+        if (x && t && !x.se.includes(t.t)) {
+          x.se.push(t.t);
           schedule();
         }
       }
@@ -285,147 +356,183 @@ 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.oe === O) return;
+    if (!x) {
+      x = e ?? {
+        oe: O,
+        Y: [],
+        se: [],
+        Z: [],
+        $: new Set(),
+        ue: [],
+        re: { J: [[], []], X: [] },
+        fe: false
       };
     } else if (e) {
-      v.done = e;
-      e.actions.push(...v.actions);
-      b.delete(v);
-      v = e;
+      const t = x;
+      t.fe = e;
+      e.ue.push(...t.ue);
+      for (const n of k) {
+        if (n.F === t) n.F = e;
+      }
+      e.Z.push(...t.Z);
+      for (const n of t.$) {
+        e.$.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.oe = O;
+    for (let e = 0; e < this.Y.length; e++) {
+      const t = this.Y[e];
+      t.F = x;
+      x.Y.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.Y = x.Y;
+    for (let e = 0; e < this.Z.length; e++) {
+      const t = this.Z[e];
+      t.F = x;
+      x.Z.push(t);
     }
-    this.B = v.optimisticNodes;
-    for (const e of this.G) {
-      v.optimisticStores.add(e);
+    this.Z = x.Z;
+    for (const e of k) {
+      if (!e.F) e.F = x;
     }
-    this.G = v.optimisticStores;
+    for (const e of this.$) x.$.add(e);
+    this.$ = x.$;
   }
 }
 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.D || 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.D = undefined;
+    }
+    const e = r.k;
+    if (e.le === h) {
+      if (!e.ce) {
+        e.ce = true;
+        e.ae.enqueue(p, e.de);
       }
       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) {
-    n = true;
-    runHeap(_, GlobalQueue.K);
-  }
+  if (!t) checkBoundaryChildren(E);
+  if (_.m >= _.j) runHeap(_, GlobalQueue.ee);
   if (n) {
-    const t = A.D;
+    const t = E.Y;
     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.K !== y) {
+        n.pe = n.K;
+        n.K = y;
+        if (n.le && n.le !== h) n.ce = true;
       }
-      if (n.R) GlobalQueue.U(n, false, true);
+      n.he &= ~a;
+      if (n.R) GlobalQueue.te(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.optimisticNodes : A.B;
+    const n = e ? e.Z : E.Z;
     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.K;
+      t.D = undefined;
+      if (r !== y && t.pe !== r) {
+        t.pe = r;
         insertSubs(t, true);
       }
-      t.te = g;
-      t.X = null;
+      t.K = y;
+      t.F = null;
     }
     n.length = 0;
-    const r = e ? e.optimisticStores : A.G;
-    if (GlobalQueue.L && r.size) {
+    const r = e ? e.$ : E.$;
+    if (GlobalQueue.ne && r.size) {
       for (const e of r) {
-        GlobalQueue.L(e);
+        GlobalQueue.ne(e);
       }
       r.clear();
       schedule();
     }
+    for (const t of k) {
+      const n = e ? t.F === e : !t.F;
+      if (!n) continue;
+      if (!t.q) {
+        if (t.M[0].length) runQueue(t.M[0], d);
+        if (t.M[1].length) runQueue(t.M[1], p);
+      }
+      if (t.t.D === t) t.t.D = undefined;
+      t.T.clear();
+      t.M[0].length = 0;
+      t.M[1].length = 0;
+      k.delete(t);
+      C.delete(t.t);
+    }
+  }
+}
+function checkBoundaryChildren(e) {
+  for (const t of e.X) {
+    t.checkSources?.();
+    checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  A.G.add(e);
+  E.$.add(e);
   schedule();
 }
-function runTransitionPending(e) {
+function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].X = v;
+    e[t].F = 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.fe) return true;
+  if (e.ue.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.se.length; n++) {
+    if (e.se[n].he & l) {
       t = false;
       break;
     }
   }
-  t && (e.done = true);
+  t && (e.fe = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.done && typeof e.done === "object") e = e.done;
+  while (e.fe && typeof e.fe === "object") e = e.fe;
   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;
@@ -434,14 +541,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.ue.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.ue.indexOf(i);
+        if (o >= 0) s.ue.splice(o, 1);
+        x = s;
         schedule();
         t ? r(t) : n(e);
       };
@@ -468,124 +575,164 @@ function action(e) {
       step();
     });
 }
-GlobalQueue.K = recompute;
-GlobalQueue.U = disposeChildren;
+GlobalQueue.ee = recompute;
+GlobalQueue.te = 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.le;
   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.F && (!i || x) && x !== t.F) E.initTransition(t.F);
+    deleteFromHeap(t, t._ & o ? b : _);
+    if (t.F || 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.ye = t.ge;
+      t.we = t.Se;
+      t.ge = null;
+      t.Se = null;
+    }
+  }
+  const s = !!(t._ & f);
+  const u = hasActiveOverride(t);
+  const a = !!(t.he & l);
+  const d = H;
+  H = t;
+  t.me = null;
+  t._ = r;
+  t.oe = O;
+  let p = t.K === y ? t.pe : t.K;
+  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.T.delete(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.T.add(t);
+        t.D = e;
+      }
+    }
+    notifyStatus(
+      t,
+      e instanceof NotReadyError ? l : c,
+      e,
+      undefined,
+      e instanceof NotReadyError ? t.D : 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.ie) {
+    const e = t.me;
+    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.pe : t.K === y ? t.pe : t.K;
+    const l = !t._e || !t._e(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.pe : undefined;
+      if (n || (i && x !== t.F) || s) t.pe = p;
+      else t.K = p;
+      if (u && !s && a) {
+        const e = t.B || 0;
+        const n = t.V || 0;
+        if (e <= n) t.pe = p;
+      }
+      if (!u || s || t.pe !== e) {
+        insertSubs(t, s || u);
+      }
+    } else if (u) {
+      t.K = 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 && A.D.push(t);
-  t.X && i && v !== t.X && runInTransition(t.X, () => recompute(t));
+  setCurrentOptimisticLane(S);
+  (!n || t.he & l) && !t.F && !(x && t.G) && E.Y.push(t);
+  t.F && i && x !== t.F && runInTransition(t.F, () => 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.be = null;
     return t;
   }
-  e.de = t;
-  let o;
+  e.be = 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.be !== t) return;
+    E.initTransition(e.F);
+    notifyStatus(e, n instanceof NotReadyError ? l : c, n);
+    e.oe = O;
   };
-  const asyncWrite = (r, i) => {
-    if (e.de !== t) return;
-    A.initTransition(e.X);
+  const asyncWrite = (i, s) => {
+    if (e.be !== t) return;
+    if (e._ & (n | f)) return;
+    E.initTransition(e.F);
     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.T.delete(e);
+    if (r) r(i);
+    else if (e.G) {
+      const t = e.K !== y;
+      if (e.R) e.K = i;
       if (!t) {
-        e.ne = r;
+        e.pe = i;
         insertSubs(e);
       }
-      e.ce = x;
-      schedule();
-    } else setSignal(e, () => r);
+      e.oe = O;
+    } else if (o) {
+      const t = e.pe;
+      const n = e._e;
+      if (!n || !n(i, t)) {
+        e.pe = i;
+        e.oe = O;
+        if (e.Oe) {
+          setSignal(e.Oe, 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);
       },
@@ -595,11 +742,11 @@ function handleAsync(e, t, n) {
     );
     r = false;
     if (!n) {
-      A.initTransition(e.X);
-      throw new NotReadyError(Q);
+      E.initTransition(e.F);
+      throw new NotReadyError(H);
     }
   }
-  if (i) {
+  if (s) {
     const n = t[Symbol.asyncIterator]();
     let r = false;
     const iterate = () => {
@@ -619,7 +766,7 @@ function handleAsync(e, t, n) {
       );
       i = false;
       if (t && !e.done) {
-        o = e.value;
+        u = e.value;
         r = true;
         return iterate();
       }
@@ -627,177 +774,191 @@ function handleAsync(e, t, n) {
     };
     const i = iterate();
     if (!r && !i) {
-      A.initTransition(e.X);
-      throw new NotReadyError(Q);
+      E.initTransition(e.F);
+      throw new NotReadyError(H);
     }
   }
-  return o;
+  return u;
 }
 function clearStatus(e) {
-  e.re = f;
-  e.J = null;
+  e.he = e.he & a;
+  e.ie = 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.xe?.();
+}
+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.G && !s;
+  const u = o && hasActiveOverride(e);
+  if (!r) {
+    e.he = t | (t !== c ? e.he & a : 0);
+    e.ie = n;
+    updatePendingSignal(e);
+  }
+  if (i && !r) {
+    assignOrMergeLane(e, i);
+  }
+  if (u && x && n instanceof NotReadyError) {
+    const e = n.t;
+    if (!x.se.includes(e)) {
+      x.se.push(e);
+    }
+  }
+  const f = r || u;
+  const d = r || o ? undefined : i;
+  if (e.xe) {
+    if (f) {
+      e.xe(t, n);
+    } else {
+      e.xe();
     }
-    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.oe = O;
+    if (r.k.ie !== n) {
+      !r.k.F && E.Y.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.oe = O;
+      if (e.k.ie !== n) {
+        !e.k.F && E.Y.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.ie && r.oe < 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.ve;
+  if (r !== null) r.ve = i;
+  else t.Pe = 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.Ce?.();
+      t.R && !t.ke && 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.me;
+  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.me = 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.Pe;
+  if (o !== null && o.k === t && (!s || isValidLink(o, t))) return;
+  const u = (t.me = e.Pe = { I: e, k: t, L: i, ve: 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.me;
   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.Se;
   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.Ae;
   }
 }
 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.me = 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.we : e.Se;
   while (r) {
-    const e = r.Se;
-    if (r.j) {
+    const e = r.Ae;
+    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.me = null;
     }
     disposeChildren(r, true);
     r = e;
   }
   if (n) {
-    e.oe = null;
+    e.we = null;
   } else {
-    e.ue = null;
     e.Se = null;
+    e.Ae = null;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.ie : e.se;
+  let n = t ? e.ye : e.ge;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -807,10 +968,10 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.ie = null) : (e.se = null);
+  t ? (e.ye = null) : (e.ge = null);
 }
 function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.me++);
+  if (e.id != null) return formatId(e.id, e.Ee++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(e, t) {
@@ -820,103 +981,118 @@ 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,
+    id: r?.id ?? (H?.id != null ? getNextChildId(H) : undefined),
+    _e: r?.equals != null ? r.equals : isEqual,
+    We: !!r?.pureWrite,
+    Ce: r?.unobserved,
+    ge: null,
+    ae: H?.ae ?? E,
+    je: H?.je ?? w,
+    Ee: 0,
     R: t,
-    ne: n,
-    o: 0,
-    k: null,
-    h: undefined,
-    p: null,
-    j: null,
-    fe: null,
-    O: null,
-    ye: null,
-    i: Q,
+    pe: n,
+    u: 0,
+    A: null,
+    S: undefined,
+    h: null,
+    N: null,
+    me: null,
+    P: null,
+    Pe: null,
+    o: H,
+    Ae: null,
     Se: null,
-    ue: null,
-    m: e,
-    re: d,
-    ce: x,
-    te: g,
-    ie: null,
-    oe: null,
-    de: null,
-    X: null
+    _: e,
+    he: a,
+    oe: O,
+    K: y,
+    ye: null,
+    we: null,
+    be: null,
+    F: 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.Se;
     if (e === null) {
-      Q.ue = i;
+      H.Se = i;
     } else {
-      i.Se = e;
-      Q.ue = i;
+      i.Ae = e;
+      H.Se = 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
+    _e: t?.equals != null ? t.equals : isEqual,
+    We: !!t?.pureWrite,
+    Ce: t?.unobserved,
+    pe: e,
+    P: null,
+    Pe: null,
+    oe: O,
+    H: n,
+    W: n?.A || null,
+    K: y
   };
-  n && (n.k = r);
+  n && (n.A = r);
   return r;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.le = true;
+  n.G = true;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const r = computed(e, t, n);
-  r.le = true;
+  r.G = true;
   return r;
 }
 function getPendingSignal(e) {
-  if (!e.Oe) {
-    e.Oe = optimisticSignal(false, { pureWrite: true });
-    if (computePendingState(e)) setSignal(e.Oe, true);
+  if (!e.Ne) {
+    e.Ne = optimisticSignal(false, { pureWrite: true });
+    if (computePendingState(e)) setSignal(e.Ne, true);
   }
-  return e.Oe;
+  return e.Ne;
 }
 function computePendingState(e) {
-  if (e.te !== g) return true;
   const t = e;
-  return !!(t.re & c && !(t.re & d));
+  if (e.K !== y && !(t.he & a)) return true;
+  return !!(t.he & l && !(t.he & a));
 }
 function getPendingValueComputed(e) {
-  if (!e.xe) {
+  if (!e.Oe) {
     const t = I;
     I = false;
-    const n = Q;
-    Q = null;
-    e.xe = optimisticComputed(() => read(e));
-    Q = n;
+    const n = H;
+    H = null;
+    e.Oe = optimisticComputed(() => read(e));
+    H = n;
     I = t;
   }
-  return e.xe;
+  return e.Oe;
 }
 function updatePendingSignal(e) {
-  if (e.Oe) setSignal(e.Oe, computePendingState(e));
+  if (e.Ne) {
+    const t = computePendingState(e);
+    const n = e.Ne;
+    setSignal(n, t);
+    if (!t && n.D) {
+      const t = resolveLane(e);
+      if (t && t.T.size > 0) {
+        const e = findLane(n.D);
+        if (e !== t) {
+          mergeLanes(t, e);
+        }
+      }
+      clearLaneEntry(n);
+      n.D = undefined;
+    }
+  }
 }
 function isEqual(e, t) {
   return e === t;
@@ -931,16 +1107,16 @@ function untrack(e) {
   }
 }
 function read(e) {
-  if (E) {
-    const t = e.I || e;
+  if (L) {
+    const t = e.H || e;
     const n = getPendingSignal(t);
-    const r = E;
-    E = false;
+    const r = L;
+    L = false;
     if (read(n)) {
-      H = true;
+      Q = true;
     }
-    E = r;
-    return e.ne;
+    L = r;
+    return e.pe;
   }
   if (I) {
     const t = getPendingValueComputed(e);
@@ -948,110 +1124,133 @@ function read(e) {
     I = false;
     const r = read(t);
     I = n;
-    if (t.re & c) return e.ne;
+    if (t.he & l) return e.pe;
     return r;
   }
-  let t = Q;
-  if (t?.t) t = t.u;
+  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.he & l && !(j && n.F && x !== n.F)) {
+    if (A) {
+      const r = n.D;
+      const i = findLane(A);
+      if (r && findLane(r) === i && !hasActiveOverride(n)) {
+        if (!W) link(e, t);
+        throw n.ie;
+      }
+    } else {
+      if (!W) link(e, t);
+      throw n.ie;
+    }
+  }
+  if (e.R && e.he & c) {
+    if (e.oe < O) {
       recompute(e, true);
       return read(e);
-    } else throw e.J;
+    } else throw e.ie;
   }
-  return !t || C || e.te === g || (j && e.X && v !== e.X) ? e.ne : e.te;
+  return !t || A !== null || e.K === y || (j && e.F && x !== e.F) ? e.pe : e.K;
 }
 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.F && x !== e.F) E.initTransition(e.F);
+  const n = e.G && !P;
+  const r = n ? e.pe : e.K === y ? e.pe : e.K;
   if (typeof t === "function") t = t(r);
-  const i = !e.ae || !e.ae(r, t);
-  if (!i) return t;
+  const i = !e._e || !e._e(r, t);
+  if (!i) {
+    if (n && e.K !== y && e.R) {
+      insertSubs(e, true);
+      schedule();
+    }
+    return t;
+  }
   if (n) {
-    const n = e.te === g;
-    if (e.X && !n) {
-      A.initTransition(e.X);
+    const n = E.Z.includes(e);
+    if (e.F && n) {
+      E.initTransition(e.F);
+    }
+    if (e.K === y) {
+      e.K = e.pe;
     }
-    if (n) {
-      e.te = e.ne;
-      A.B.push(e);
+    if (!n) {
+      E.Z.push(e);
     }
-    e.ne = t;
+    e.B = (e.B || 0) + 1;
+    const r = getOrCreateLane(e);
+    e.D = r;
+    e.pe = t;
   } else {
-    if (e.te === g) A.D.push(e);
-    e.te = t;
+    if (e.K === y) E.Y.push(e);
+    e.K = t;
   }
   updatePendingSignal(e);
-  if (e.xe) {
-    setSignal(e.xe, t);
+  if (e.Oe) {
+    setSignal(e.Oe, t);
   }
-  e.ce = x;
+  e.oe = 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.ge) H.ge = e;
+  else if (Array.isArray(H.ge)) H.ge.push(e);
+  else H.ge = [H.ge, 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,
     Se: null,
-    se: null,
-    $: t?.$ ?? A,
-    _e: t?._e || S,
-    me: 0,
-    ie: null,
-    oe: null,
-    i: t,
+    Ae: null,
+    ge: null,
+    ae: t?.ae ?? E,
+    je: t?.je || w,
+    Ee: 0,
+    ye: null,
+    we: null,
+    o: t,
     dispose(e = true) {
       disposeChildren(n, e);
     }
   };
   if (t) {
-    const e = t.ue;
+    const e = t.Se;
     if (e === null) {
-      t.ue = n;
+      t.Se = n;
     } else {
-      n.Se = e;
-      t.ue = n;
+      n.Ae = e;
+      t.Se = n;
     }
   }
   return n;
@@ -1061,14 +1260,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;
   }
 }
@@ -1091,16 +1290,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) {
@@ -1108,7 +1309,7 @@ function refresh(e) {
   N = true;
   try {
     if (typeof e !== "function") {
-      recompute(e[m]);
+      recompute(e[S]);
       return e;
     }
     return untrack(e);
@@ -1129,7 +1330,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.je[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -1139,10 +1340,10 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n._e = { ...n._e, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.je = { ...n.je, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?._e[e.id]);
+  return !isUndefined(t?.je[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
@@ -1152,78 +1353,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.ce = !o.ie;
+      if (s) o.ae.enqueue(o.le, 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.Le = r;
+  o.Qe = t;
+  o.Ie = n;
+  o.He = undefined;
+  o.le = i?.render ? d : p;
+  o.xe = (e, t) => {
+    const n = e !== undefined ? e : o.he;
+    const r = t !== undefined ? t : o.ie;
+    if (n & c) {
+      let e = r;
+      o.ae.notify(o, l, 0);
+      if (o.le === p) {
         try {
-          return o.Ce
-            ? o.Ce(e, () => {
-                o.ke?.();
-                o.ke = undefined;
+          return o.Ie
+            ? o.Ie(e, () => {
+                o.He?.();
+                o.He = 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.ae.notify(o, c, c)) throw e;
+    } else if (o.le === d) o.ae.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.le === p ? o.ae.enqueue(o.le, runEffect.bind(o)) : runEffect.call(o));
   s = true;
-  onCleanup(() => o.ke?.());
+  onCleanup(() => o.He?.());
 }
 function runEffect() {
-  if (!this.Z || this.m & u) return;
-  this.ke?.();
-  this.ke = undefined;
+  if (!this.ce || this._ & u) return;
+  this.He?.();
+  this.He = undefined;
   try {
-    this.ke = this.Pe(this.ne, this.ve);
+    this.He = this.Qe(this.pe, this.Le);
   } catch (e) {
-    if (!this.$.notify(this, a, a)) throw e;
+    if (!this.ae.notify(this, c, c)) throw e;
   } finally {
-    this.ve = this.ne;
-    this.Z = false;
+    this.Le = this.pe;
+    this.ce = false;
   }
 }
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.Z || n.m & u) return;
-    n.Z = false;
+    if (!n.ce || n._ & u) return;
+    n.ce = false;
     recompute(n);
   };
   const n = computed(
     () => {
       try {
-        n.ke?.();
-        n.ke = undefined;
-        n.ke = staleValues(e) || undefined;
+        n.He?.();
+        n.He = undefined;
+        n.He = 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.He = undefined;
+  n.ce = true;
+  n.le = h;
+  n.de = run;
+  n.ae.enqueue(p, run);
+  onCleanup(() => n.He?.());
 }
 function createSignal(e, t, n) {
   if (typeof e === "function") {
@@ -1288,13 +1491,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];
@@ -1305,22 +1508,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++
       ) {
@@ -1329,7 +1532,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])));
@@ -1348,20 +1551,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) {
@@ -1379,23 +1582,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]);
@@ -1406,7 +1609,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];
@@ -1428,9 +1631,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;
       },
@@ -1439,8 +1642,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;
   };
@@ -1455,7 +1658,7 @@ function createProjectionInternal(e, t = {}, n) {
       i !== r && i !== undefined && reconcile(i, n?.key || "id", n?.all)(s);
     });
   });
-  r.we = true;
+  r.ke = true;
   return { store: s, node: r };
 }
 function createProjection(e, t = {}, n) {
@@ -1497,46 +1700,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];
@@ -1555,11 +1758,11 @@ function getNode(e, t, n, r, i = isEqual, s) {
     },
     r
   );
-  if (s) o.le = true;
+  if (s) o.G = 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)));
@@ -1567,7 +1770,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);
@@ -1575,18 +1778,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;
     }
@@ -1594,105 +1797,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.K !== y ? (i.G ? i.pe : i.K) : i.pe) : 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?.F) {
+          E.initTransition(t.F);
         }
       }
       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;
@@ -1703,7 +1906,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);
@@ -1711,9 +1914,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] };
@@ -1727,9 +1930,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) {
@@ -1745,8 +1948,8 @@ function storeSetter(e, t) {
       }
     }
   } finally {
-    te.clear();
-    te = n;
+    ne.clear();
+    ne = n;
   }
 }
 function createStore(e, t, n) {
@@ -1755,17 +1958,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;
@@ -1774,16 +1977,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;
@@ -1805,10 +2008,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.ne ||= clearOptimisticStore;
   const r = typeof e === "function";
   const i = (r ? t : e) ?? {};
   const s = r ? e : undefined;
@@ -1816,19 +2019,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].D = 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].D = undefined;
+        setSignal(r[M], undefined);
       }
     }
-    r[q] && setSignal(r[q], undefined);
+  } finally {
+    setProjectionWriteActive(false);
   }
   delete t[z];
 }
@@ -1836,10 +2048,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;
       },
@@ -1848,8 +2060,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;
   };
@@ -1874,21 +2086,21 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
         setProjectionWriteActive(false);
       }
     });
-    r.we = true;
+    r.ke = 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);
@@ -1896,26 +2108,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;
       }
     }
   }
@@ -1924,13 +2136,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,
@@ -1953,23 +2165,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];
@@ -1987,7 +2199,7 @@ function merge(...e) {
           return [...new Set(e)];
         }
       },
-      re
+      ie
     );
   }
   const r = Object.create(null);
@@ -2019,12 +2231,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) {
@@ -2037,7 +2249,7 @@ function omit(e, ...t) {
           return Object.keys(e).filter(e => !n.has(e));
         }
       },
-      re
+      ie
     );
   }
   const r = {};
@@ -2055,313 +2267,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
+      Re: createOwner(),
+      Te: 0,
+      Me: e,
+      qe: [],
+      Fe: t,
+      Ve: [],
+      Be: [],
+      De: r,
+      Ge: r || n?.keyed === false ? [] : undefined,
+      Ke: t.length > 1 ? [] : undefined,
+      ze: n?.fallback
     })
   );
 }
-const se = { pureWrite: true };
+const oe = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.je() || [],
+  const e = this.Me() || [],
     t = e.length;
-  e[q];
-  runWithOwner(this.Ae, () => {
+  e[M];
+  runWithOwner(this.Re, () => {
     let n,
       r,
-      i = this.Re
+      i = this.Ge
         ? () => {
-            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.Ge[r] = signal(e[r], oe);
+            this.Ke && (this.Ke[r] = signal(r, oe));
+            return this.Fe(
+              read.bind(null, this.Ge[r]),
+              this.Ke ? read.bind(null, this.Ke[r]) : undefined
             );
           }
-        : this.Te
+        : this.Ke
           ? () => {
               const t = e[r];
-              this.Te[r] = signal(r, se);
-              return this.Ee(() => t, read.bind(null, this.Te[r]));
+              this.Ke[r] = signal(r, oe);
+              return this.Fe(() => t, read.bind(null, this.Ke[r]));
             }
           : () => {
               const t = e[r];
-              return this.Ee(() => t);
+              return this.Fe(() => 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.Te !== 0) {
+        this.Re.dispose(false);
+        this.Be = [];
+        this.qe = [];
+        this.Ve = [];
+        this.Te = 0;
+        this.Ge && (this.Ge = []);
+        this.Ke && (this.Ke = []);
+      }
+      if (this.ze && !this.Ve[0]) {
+        this.Ve[0] = runWithOwner((this.Be[0] = createOwner()), this.ze);
+      }
+    } else if (this.Te === 0) {
+      if (this.Be[0]) this.Be[0].dispose();
+      this.Ve = new Array(t);
       for (r = 0; r < t; r++) {
-        this.Ne[r] = e[r];
-        this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
+        this.qe[r] = e[r];
+        this.Ve[r] = runWithOwner((this.Be[r] = createOwner()), i);
       }
-      this.We = t;
+      this.Te = 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.Ge ? new Array(t) : undefined,
+        y = this.Ke ? 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.Te, t);
+        s < o && (this.qe[s] === e[s] || (this.Ge && compare(this.De, this.qe[s], e[s])));
         s++
       ) {
-        if (this.Re) setSignal(this.Re[s], e[s]);
+        if (this.Ge) setSignal(this.Ge[s], e[s]);
       }
       for (
-        o = this.We - 1, u = t - 1;
+        o = this.Te - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.Ne[o] === e[u] || (this.Re && compare(this.Qe, this.Ne[o], e[u])));
+        (this.qe[o] === e[u] || (this.Ge && compare(this.De, this.qe[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.Ve[o];
+        p[u] = this.Be[o];
+        h && (h[u] = this.Ge[o]);
+        y && (y[u] = this.Ke[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.De ? this.De(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.qe[n];
+        l = this.De ? this.De(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.Ve[n];
+          p[r] = this.Be[n];
+          h && (h[r] = this.Ge[n]);
+          y && (y[r] = this.Ke[n]);
           r = a[r];
-          c.set(f, r);
-        } else this.Ie[n].dispose();
+          c.set(l, r);
+        } else this.Be[n].dispose();
       }
       for (r = s; r < t; r++) {
         if (r in d) {
-          this.He[r] = d[r];
-          this.Ie[r] = p[r];
+          this.Ve[r] = d[r];
+          this.Be[r] = p[r];
           if (h) {
-            this.Re[r] = h[r];
-            setSignal(this.Re[r], e[r]);
+            this.Ge[r] = h[r];
+            setSignal(this.Ge[r], e[r]);
           }
           if (y) {
-            this.Te[r] = y[r];
-            setSignal(this.Te[r], r);
+            this.Ke[r] = y[r];
+            setSignal(this.Ke[r], r);
           }
         } else {
-          this.He[r] = runWithOwner((this.Ie[r] = createOwner()), i);
+          this.Ve[r] = runWithOwner((this.Be[r] = createOwner()), i);
         }
       }
-      this.He = this.He.slice(0, (this.We = t));
-      this.Ne = e.slice(0);
+      this.Ve = this.Ve.slice(0, (this.Te = t));
+      this.qe = e.slice(0);
     }
   });
-  return this.He;
+  return this.Ve;
 }
 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
+    Re: createOwner(),
+    Te: 0,
+    Ue: 0,
+    Je: e,
+    Fe: t,
+    Be: [],
+    Ve: [],
+    Xe: n?.from,
+    ze: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.Ve();
-  const t = this.Me?.() || 0;
-  runWithOwner(this.Ae, () => {
+  const e = this.Je();
+  const t = this.Xe?.() || 0;
+  runWithOwner(this.Re, () => {
     if (e === 0) {
-      if (this.We !== 0) {
-        this.Ae.dispose(false);
-        this.Ie = [];
-        this.He = [];
-        this.We = 0;
+      if (this.Te !== 0) {
+        this.Re.dispose(false);
+        this.Be = [];
+        this.Ve = [];
+        this.Te = 0;
       }
-      if (this.qe && !this.He[0]) {
-        this.He[0] = runWithOwner((this.Ie[0] = createOwner()), this.qe);
+      if (this.ze && !this.Ve[0]) {
+        this.Ve[0] = runWithOwner((this.Be[0] = createOwner()), this.ze);
       }
       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.Ue + this.Te;
+    if (this.Te === 0 && this.Be[0]) this.Be[0].dispose();
+    for (let e = n; e < r; e++) this.Be[e - this.Ue].dispose();
+    if (this.Ue < t) {
+      let e = this.Ue;
+      while (e < t && e < this.Te) this.Be[e++].dispose();
+      this.Be.splice(0, t - this.Ue);
+      this.Ve.splice(0, t - this.Ue);
+    } else if (this.Ue > t) {
+      let n = r - this.Ue - 1;
+      let i = this.Ue - t;
+      this.Be.length = this.Ve.length = e;
       while (n >= i) {
-        this.Ie[n] = this.Ie[n - i];
-        this.He[n] = this.He[n - i];
+        this.Be[n] = this.Be[n - i];
+        this.Ve[n] = this.Ve[n - i];
         n--;
       }
       for (let e = 0; e < i; e++) {
-        this.He[e] = runWithOwner((this.Ie[e] = createOwner()), () => this.Ee(e + t));
+        this.Ve[e] = runWithOwner((this.Be[e] = createOwner()), () => this.Fe(e + t));
       }
     }
     for (let e = r; e < n; e++) {
-      this.He[e - t] = runWithOwner((this.Ie[e - t] = createOwner()), () => this.Ee(e));
+      this.Ve[e - t] = runWithOwner((this.Be[e - t] = createOwner()), () => this.Fe(e));
     }
-    this.He = this.He.slice(0, e);
-    this.Fe = t;
-    this.We = e;
+    this.Ve = this.Ve.slice(0, e);
+    this.Ue = t;
+    this.Te = e;
   });
-  return this.He;
+  return this.Ve;
 }
 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.xe = (e, t) => {
+    const r = e !== undefined ? e : n.he;
+    const i = t !== undefined ? t : n.ie;
+    n.he &= ~n.Ye;
+    n.ae.notify(n, n.Ye, r, i);
   };
-  n.De = t;
-  n.we = true;
+  n.Ye = t;
+  n.ke = 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.ae;
+  i.addChild((e.ae = n));
+  onCleanup(() => i.removeChild(e.ae));
   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();
+  Ze;
+  $e = new Set();
+  Y = new Set();
   constructor(e) {
     super();
-    this.Be = e;
+    this.Ze = e;
   }
   run(e) {
-    if (!e || read(this.Be)) return;
+    if (!e || read(this.Ze)) return;
     return super.run(e);
   }
-  notify(e, t, n) {
-    if (read(this.Be)) {
+  notify(e, t, n, r) {
+    if (read(this.Ze)) {
+      if (t & l) {
+        if (n & l) {
+          this.Y.add(e);
+          t &= ~l;
+        } else if (this.Y.delete(e)) t &= ~l;
+      }
       if (t & c) {
         if (n & c) {
-          this.D.add(e);
+          this.$e.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.$e.delete(e)) t &= ~c;
       }
     }
-    return t ? super.notify(e, t, n) : true;
+    return t ? super.notify(e, t, n, r ?? e.ie) : true;
   }
 }
 class CollectionQueue extends Queue {
-  Ke;
-  Ie = new Set();
-  Be = signal(false, { pureWrite: true });
-  ze = false;
+  et;
+  tt = new Set();
+  Ze = signal(false, { pureWrite: true });
+  nt = false;
   constructor(e) {
     super();
-    this.Ke = e;
+    this.et = e;
   }
   run(e) {
-    if (!e || read(this.Be)) return;
+    if (!e || read(this.Ze)) 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.et) || (this.et & l && this.nt)) return super.notify(e, t, n, r);
+    if (n & this.et) {
+      const t = r?.t || e.ie?.t;
+      if (t) {
+        const e = this.tt.size === 0;
+        this.tt.add(t);
+        if (e) setSignal(this.Ze, true);
+      }
+    }
+    t &= ~this.et;
+    return t ? super.notify(e, t, n, r) : true;
+  }
+  checkSources() {
+    for (const e of this.tt) {
+      if (!(e.he & this.et)) this.tt.delete(e);
     }
-    t &= ~this.Ke;
-    return t ? super.notify(e, t, n) : true;
+    if (!this.tt.size) setSignal(this.Ze, 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.Ze);
+    i.Ye = 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.Y.forEach(e => r.notify(e, l, l, e.ie));
+      r.$e.forEach(e => r.notify(e, c, c, e.ie));
+      r.Y.clear();
+      r.$e.clear();
     }
   });
-  return () => (read(r.Be) ? undefined : read(i));
+  return () => (read(r.Ze) ? 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.Ze)) {
       const e = read(s);
-      if (!untrack(() => read(i.Be))) {
-        i.ze = true;
+      if (!untrack(() => read(i.Ze))) {
+        i.nt = true;
         return e;
       }
     }
@@ -2370,28 +2590,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.tt.values().next().value;
+    const r = n.ie?.cause ?? n.ie;
+    return t(r, () => {
+      for (const t of e.tt) recompute(t);
       schedule();
     });
   });
@@ -2445,13 +2651,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;