@solidjs/signals 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/node.cjs

@@ -31,27 +31,39 @@ const i = 1 << 3;
 const s = 1 << 4;
 const o = 1 << 5;
 const u = 1 << 6;
-const f = 1 << 7;
-const l = 1 << 8;
+const l = 1 << 7;
+const f = 1 << 8;
 const c = 1 << 9;
-const a = 1 << 0;
-const d = 1 << 1;
-const p = 1 << 2;
-const h = 1 << 3;
-const y = 1 << 4;
-const g = 1 << 5;
-const S = 1 << 0;
-const w = 1 << 1;
-const m = 1 << 2;
-const b = 1;
-const _ = 2;
-const O = 3;
-const v = {};
+const a = 1 << 10;
+const d = 1 << 0;
+const p = 1 << 1;
+const h = 1 << 2;
+const g = 1 << 3;
+const S = 1 << 4;
+const y = 1 << 5;
+const w = 1 << 6;
+const m = 1 << 0;
+const _ = 1 << 1;
+const b = 1 << 2;
+const O = 1;
+const v = 2;
+const P = 3;
 const x = {};
-const P = "sp";
-const k = typeof Proxy === "function";
 const C = {};
-const E = Symbol("refresh");
+const N = "sp";
+const E = typeof Proxy === "function";
+const k = {};
+const j = Symbol("refresh");
+const W = new Set();
+const R = new Set();
+let A = 0;
+const I = undefined;
+function emitDiagnostic(e) {
+  const t = { sequence: ++A, ...e };
+  for (const e of W) e(t);
+  for (const e of R) e.push(t);
+  return t;
+}
 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;
@@ -68,7 +80,7 @@ function actualInsertIntoHeap(e, t) {
 }
 function insertIntoHeap(e, o) {
   let u = e.m;
-  if (u & (i | r)) return;
+  if (u & (i | r | a)) return;
   if (u & t) {
     e.m = (u & -4) | n | i;
   } else e.m = u | i;
@@ -76,7 +88,7 @@ function insertIntoHeap(e, o) {
 }
 function insertIntoHeapHeight(e, t) {
   let n = e.m;
-  if (n & (i | r | s)) return;
+  if (n & (i | r | s | a)) return;
   e.m = n | s;
   actualInsertIntoHeap(e, t);
 }
@@ -111,24 +123,24 @@ function markNode(e, r = n) {
   if ((i & (t | n)) >= r) return;
   e.m = (i & -4) | r;
   for (let n = e.O; n !== null; n = n.P) {
-    markNode(n.k, t);
+    markNode(n.C, t);
   }
-  if (e.C !== null) {
-    for (let n = e.C; n !== null; n = n.j) {
+  if (e.N !== null) {
+    for (let n = e.N; n !== null; n = n.k) {
       for (let e = n.O; e !== null; e = e.P) {
-        markNode(e.k, t);
+        markNode(e.C, t);
       }
     }
   }
 }
 function runHeap(e, t) {
   e._ = false;
-  for (e.N = 0; e.N <= e.S; e.N++) {
-    let n = e.l[e.N];
+  for (e.j = 0; e.j <= e.S; e.j++) {
+    let n = e.l[e.j];
     while (n !== undefined) {
       if (n.m & i) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.N];
+      n = e.l[e.j];
     }
   }
   e.S = 0;
@@ -138,137 +150,211 @@ function adjustHeight(e, t) {
   let n = e.o;
   for (let t = e.W; t; t = t.R) {
     const e = t.A;
-    const r = e.L || e;
-    if (r.I && r.o >= n) n = r.o + 1;
+    const r = e.I || e;
+    if (r.L && r.o >= n) n = r.o + 1;
   }
   if (e.o !== n) {
     e.o = n;
     for (let n = e.O; n !== null; n = n.P) {
-      insertIntoHeapHeight(n.k, t);
+      insertIntoHeapHeight(n.C, t);
     }
   }
 }
-const j = undefined;
-const N = new Set();
-const W = { l: new Array(2e3).fill(undefined), _: false, N: 0, S: 0 };
-const R = { l: new Array(2e3).fill(undefined), _: false, N: 0, S: 0 };
-let A = 0;
-let L = null;
-let I = false;
-let T = false;
-let H = null;
-const Q = new Set();
+const L = new WeakMap();
+const T = new Set();
+function getOrCreateLane(e) {
+  let t = L.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.T;
+  const r = n?.H ? findLane(n.H) : null;
+  t = { q: e, F: new Set(), M: [[], []], D: null, V: M, K: r };
+  L.set(e, t);
+  T.add(t);
+  e.B = false;
+  return t;
+}
+function findLane(e) {
+  while (e.D) e = e.D;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.D = e;
+  for (const n of t.F) e.F.add(n);
+  e.M[0].push(...t.M[0]);
+  e.M[1].push(...t.M[1]);
+  return e;
+}
+function resolveLane(e) {
+  const t = e.H;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (T.has(n)) return n;
+  e.H = undefined;
+  return undefined;
+}
+function resolveTransition(e) {
+  return resolveLane(e)?.V ?? e.V;
+}
+function hasActiveOverride(e) {
+  return !!(e.G !== undefined && e.G !== x);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const r = e.H;
+  if (r) {
+    if (r.D) {
+      e.H = t;
+      return;
+    }
+    const i = findLane(r);
+    if (T.has(i)) {
+      if (i !== n && !hasActiveOverride(e)) {
+        if (n.K && findLane(n.K) === i) {
+          e.H = t;
+        } else if (i.K && findLane(i.K) === n);
+        else mergeLanes(n, i);
+      }
+      return;
+    }
+  }
+  e.H = t;
+}
+const H = new Set();
+const q = { l: new Array(2e3).fill(undefined), _: false, j: 0, S: 0 };
+const Q = { l: new Array(2e3).fill(undefined), _: false, j: 0, S: 0 };
+let F = 0;
+let M = null;
+let D = false;
+let V = 0;
+let K = false;
+let B = null;
+const G = new Set();
 function registerTransientStoreNode(e) {
-  Q.add(e);
+  G.add(e);
+}
+function canUseSimpleSyncFlush(e) {
+  return (
+    H.size === 0 &&
+    T.size === 0 &&
+    e.U.length === 0 &&
+    e.J.length === 0 &&
+    e.X.size === 0 &&
+    G.size === 0
+  );
 }
 function sweepTransientStoreNodes() {
-  if (Q.size === 0) return;
-  for (const e of Q) {
+  if (G.size === 0) return;
+  for (const e of G) {
     if (e.O !== null) {
-      Q.delete(e);
+      G.delete(e);
       continue;
     }
-    if (e.T !== v) continue;
-    if (e.H !== undefined && e.H !== v) continue;
-    Q.delete(e);
-    e.q?.();
+    if (e.Y !== x) continue;
+    if (e.G !== undefined && e.G !== x) continue;
+    G.delete(e);
+    e.Z?.();
   }
 }
 function enforceLoadingBoundary(e) {}
 function shouldReadStashedOptimisticValue(e) {
-  return !!H?.has(e);
+  return !!B?.has(e);
 }
 function runLaneEffects(e) {
-  for (const t of V) {
-    if (t.M || t.V.size > 0) continue;
-    const n = t.D[e - 1];
+  for (const t of T) {
+    if (t.D || t.F.size > 0) continue;
+    const n = t.M[e - 1];
     if (n.length) {
-      t.D[e - 1] = [];
+      t.M[e - 1] = [];
       runQueue(n, e);
     }
   }
 }
 function queueStashedOptimisticEffects(e) {
   for (let t = e.O; t !== null; t = t.P) {
-    const e = t.k;
-    if (!e.F) continue;
-    if (e.F === O) {
-      if (!e.B) {
-        e.B = true;
-        e.K.enqueue(_, e.G);
+    const e = t.C;
+    if (!e.$) continue;
+    if (e.$ === P) {
+      if (!e.ee) {
+        e.ee = true;
+        e.te.enqueue(v, e.ne);
       }
       continue;
     }
-    const n = e.m & o ? R : W;
-    if (n.N > e.o) n.N = e.o;
+    const n = e.m & o ? Q : q;
+    if (n.j > e.o) n.j = e.o;
     insertIntoHeap(e, n);
   }
 }
 function setProjectionWriteActive(e) {
-  T = e;
+  K = e;
 }
 function mergeTransitionState(e, t) {
-  t.U = e;
+  t.re = e;
+  e.ie.push(...t.ie);
+  for (const n of T) if (n.V === t) n.V = e;
   e.J.push(...t.J);
-  for (const n of V) if (n.X === t) n.X = e;
-  e.Y.push(...t.Y);
-  for (const n of t.Z) e.Z.add(n);
-  for (const [n, r] of t.$) {
-    let t = e.$.get(n);
-    if (!t) e.$.set(n, (t = new Set()));
+  for (const n of t.X) e.X.add(n);
+  for (const [n, r] of t.se) {
+    let t = e.se.get(n);
+    if (!t) e.se.set(n, (t = new Set()));
     for (const e of r) t.add(e);
   }
-  for (const n of t.ee) e.ee.add(n);
+  for (const n of t.oe) e.oe.add(n);
 }
 function resolveOptimisticNodes(e) {
   for (let t = 0; t < e.length; t++) {
     const n = e[t];
-    n.te = undefined;
-    if (n.T !== v) {
-      n.ne = n.T;
-      n.T = v;
+    n.H = undefined;
+    if (n.Y !== x) {
+      n.ue = n.Y;
+      n.Y = x;
     }
-    const r = n.H;
-    n.H = v;
-    if (r !== v && n.ne !== r) insertSubs(n, true);
-    n.X = null;
+    const r = n.G;
+    n.G = x;
+    if (r !== x && n.ue !== r) insertSubs(n, true);
+    n.V = null;
   }
   e.length = 0;
 }
 function cleanupCompletedLanes(e) {
-  for (const t of V) {
-    const n = e ? t.X === e : !t.X;
+  for (const t of T) {
+    const n = e ? t.V === e : !t.V;
     if (!n) continue;
-    if (!t.M) {
-      if (t.D[0].length) runQueue(t.D[0], b);
-      if (t.D[1].length) runQueue(t.D[1], _);
+    if (!t.D) {
+      if (t.M[0].length) runQueue(t.M[0], O);
+      if (t.M[1].length) runQueue(t.M[1], v);
     }
-    if (t.re.te === t) t.re.te = undefined;
-    t.V.clear();
-    t.D[0].length = 0;
-    t.D[1].length = 0;
-    V.delete(t);
-    M.delete(t.re);
+    if (t.q.H === t) t.q.H = undefined;
+    t.F.clear();
+    t.M[0].length = 0;
+    t.M[1].length = 0;
+    T.delete(t);
+    L.delete(t.q);
   }
 }
 function schedule() {
-  if (I) return;
-  I = true;
-  if (!q.ie && !T) queueMicrotask(flush);
+  if (D) return;
+  D = true;
+  if (!V && !z.le && !K) queueMicrotask(flush);
 }
 class Queue {
   i = null;
-  se = [[], []];
-  oe = [];
-  created = A;
+  fe = [[], []];
+  U = [];
+  created = F;
   addChild(e) {
-    this.oe.push(e);
+    this.U.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.oe.indexOf(e);
+    const t = this.U.indexOf(e);
     if (t >= 0) {
-      this.oe.splice(t, 1);
+      this.U.splice(t, 1);
       e.i = null;
     }
   }
@@ -277,122 +363,133 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.se[e - 1].length) {
-      const t = this.se[e - 1];
-      this.se[e - 1] = [];
+    if (this.fe[e - 1].length) {
+      const t = this.fe[e - 1];
+      this.fe[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.oe.length; t++) this.oe[t].run?.(e);
+    for (let t = 0; t < this.U.length; t++) this.U[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
-      if (Y) {
-        const n = findLane(Y);
-        n.D[e - 1].push(t);
+      if (re) {
+        const n = findLane(re);
+        n.M[e - 1].push(t);
       } else {
-        this.se[e - 1].push(t);
+        this.fe[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.se[0].push(...this.se[0]);
-    e.se[1].push(...this.se[1]);
-    this.se = [[], []];
-    for (let t = 0; t < this.oe.length; t++) {
-      let n = this.oe[t];
-      let r = e.oe[t];
+    e.fe[0].push(...this.fe[0]);
+    e.fe[1].push(...this.fe[1]);
+    this.fe = [[], []];
+    for (let t = 0; t < this.U.length; t++) {
+      let n = this.U[t];
+      let r = e.U[t];
       if (!r) {
-        r = { se: [[], []], oe: [] };
-        e.oe[t] = r;
+        r = { fe: [[], []], U: [] };
+        e.U[t] = r;
       }
       n.stashQueues(r);
     }
   }
   restoreQueues(e) {
-    this.se[0].push(...e.se[0]);
-    this.se[1].push(...e.se[1]);
-    for (let t = 0; t < e.oe.length; t++) {
-      const n = e.oe[t];
-      let r = this.oe[t];
+    this.fe[0].push(...e.fe[0]);
+    this.fe[1].push(...e.fe[1]);
+    for (let t = 0; t < e.U.length; t++) {
+      const n = e.U[t];
+      let r = this.U[t];
       if (r) r.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  ie = false;
-  ue = [];
-  Y = [];
-  Z = new Set();
-  static fe;
-  static le;
-  static ce = null;
+  le = false;
+  ce = null;
+  ae = [];
+  J = [];
+  X = new Set();
+  static de;
+  static pe;
+  static he;
+  static ge = null;
   flush() {
-    if (this.ie) return;
-    this.ie = true;
+    if (this.le) return;
+    this.le = true;
     try {
-      runHeap(W, GlobalQueue.fe);
-      if (L) {
-        const e = transitionComplete(L);
+      runHeap(q, GlobalQueue.de);
+      if (M) {
+        const e = transitionComplete(M);
         if (!e) {
-          const e = L;
-          runHeap(R, GlobalQueue.fe);
-          this.ue = [];
-          this.Y = [];
-          this.Z = new Set();
-          runLaneEffects(b);
-          runLaneEffects(_);
-          this.stashQueues(e.ae);
-          A++;
-          I = W.S >= W.N;
-          reassignPendingTransition(e.ue);
-          L = null;
-          if (!e.J.length && !e.$.size && e.Y.length) {
-            H = new Set();
-            for (let t = 0; t < e.Y.length; t++) {
-              const n = e.Y[t];
-              if (n.I || n.de & a) continue;
-              H.add(n);
+          const e = M;
+          runHeap(Q, GlobalQueue.de);
+          this.ce = null;
+          this.ae = [];
+          this.J = [];
+          this.X = new Set();
+          runLaneEffects(O);
+          runLaneEffects(v);
+          this.stashQueues(e.Se);
+          F++;
+          D = q.S >= q.j;
+          reassignPendingTransition(e.ae);
+          M = null;
+          if (!e.ie.length && !e.se.size && e.J.length) {
+            B = new Set();
+            for (let t = 0; t < e.J.length; t++) {
+              const n = e.J[t];
+              if (n.L || n.ye & d) continue;
+              B.add(n);
               queueStashedOptimisticEffects(n);
             }
           }
           try {
             finalizePureQueue(null, true);
           } finally {
-            H = null;
+            B = null;
           }
           return;
         }
-        this.ue !== L.ue && this.ue.push(...L.ue);
-        this.restoreQueues(L.ae);
-        N.delete(L);
-        const t = L;
-        L = null;
-        reassignPendingTransition(this.ue);
+        this.ae !== M.ae && this.ae.push(...M.ae);
+        this.restoreQueues(M.Se);
+        H.delete(M);
+        const t = M;
+        M = null;
+        reassignPendingTransition(this.ae);
         finalizePureQueue(t);
       } else {
-        if (N.size) runHeap(R, GlobalQueue.fe);
-        finalizePureQueue();
-      }
-      A++;
-      I = W.S >= W.N;
-      runLaneEffects(b);
-      this.run(b);
-      runLaneEffects(_);
-      this.run(_);
+        if (canUseSimpleSyncFlush(this)) {
+          commitPendingNodes();
+          if (q.S >= q.j) {
+            runHeap(q, GlobalQueue.de);
+            commitPendingNodes();
+          }
+        } else {
+          if (H.size) runHeap(Q, GlobalQueue.de);
+          finalizePureQueue();
+        }
+      }
+      F++;
+      D = q.S >= q.j;
+      T.size && runLaneEffects(O);
+      this.run(O);
+      T.size && runLaneEffects(v);
+      this.run(v);
       if (false);
     } finally {
-      this.ie = false;
+      this.le = false;
     }
   }
   notify(e, t, n, r) {
-    if (t & S) {
-      if (n & S) {
-        const t = r !== undefined ? r : e.pe;
-        if (L && t) {
+    if (t & m) {
+      if (n & m) {
+        const t = r !== undefined ? r : e.we;
+        if (M && t) {
           const n = t.source;
-          let r = L.$.get(n);
-          if (!r) L.$.set(n, (r = new Set()));
+          let r = M.se.get(n);
+          if (!r) M.se.set(n, (r = new Set()));
           const i = r.size;
           r.add(e);
           if (r.size !== i) schedule();
@@ -404,123 +501,159 @@ class GlobalQueue extends Queue {
   }
   initTransition(e) {
     if (e) e = currentTransition(e);
-    if (e && e === L) return;
-    if (!e && L && L.he === A) return;
-    if (!L) {
-      L = e ?? {
-        he: A,
-        ue: [],
-        $: new Map(),
-        Y: [],
-        Z: new Set(),
+    if (e && e === M) return;
+    if (!e && M && M.me === F) return;
+    if (!M) {
+      M = e ?? {
+        me: F,
+        ae: [],
+        se: new Map(),
         J: [],
-        ae: { se: [[], []], oe: [] },
-        U: false,
-        ee: new Set()
+        X: new Set(),
+        ie: [],
+        Se: { fe: [[], []], U: [] },
+        re: false,
+        oe: new Set()
       };
     } else if (e) {
-      const t = L;
+      const t = M;
       mergeTransitionState(e, t);
-      N.delete(t);
-      L = e;
+      H.delete(t);
+      M = e;
+    }
+    H.add(M);
+    M.me = F;
+    if (this.ce !== null) {
+      this.ce.V = M;
+      M.ae.push(this.ce);
+      this.ce = null;
     }
-    N.add(L);
-    L.he = A;
-    if (this.ue !== L.ue) {
-      for (let e = 0; e < this.ue.length; e++) {
-        const t = this.ue[e];
-        t.X = L;
-        L.ue.push(t);
+    if (this.ae !== M.ae) {
+      for (let e = 0; e < this.ae.length; e++) {
+        const t = this.ae[e];
+        t.V = M;
+        M.ae.push(t);
       }
-      this.ue = L.ue;
+      this.ae = M.ae;
     }
-    if (this.Y !== L.Y) {
-      for (let e = 0; e < this.Y.length; e++) {
-        const t = this.Y[e];
-        t.X = L;
-        L.Y.push(t);
+    if (this.J !== M.J) {
+      for (let e = 0; e < this.J.length; e++) {
+        const t = this.J[e];
+        t.V = M;
+        M.J.push(t);
       }
-      this.Y = L.Y;
+      this.J = M.J;
     }
-    for (const e of V) {
-      if (!e.X) e.X = L;
+    for (const e of T) {
+      if (!e.V) e.V = M;
     }
-    if (this.Z !== L.Z) {
-      for (const e of this.Z) L.Z.add(e);
-      this.Z = L.Z;
+    if (this.X !== M.X) {
+      for (const e of this.X) M.X.add(e);
+      this.X = M.X;
     }
   }
 }
+function queuePendingNode(e) {
+  if (M) {
+    z.ae.push(e);
+    return;
+  }
+  if (z.ce === null && z.ae.length === 0) {
+    z.ce = e;
+    return;
+  }
+  if (z.ce !== null) {
+    z.ae.push(z.ce);
+    z.ce = null;
+  }
+  z.ae.push(e);
+}
 function insertSubs(e, t = false) {
-  const n = e.te || Y;
-  const r = e.ye !== undefined;
+  const n = e.H || re;
+  const r = e._e !== undefined;
   for (let i = e.O; i !== null; i = i.P) {
-    if (r && i.k.de & h) {
-      i.k.m |= l;
+    if (r && i.C.ye & g) {
+      i.C.m |= f;
       continue;
     }
     if (t && n) {
-      i.k.m |= f;
-      assignOrMergeLane(i.k, n);
+      i.C.m |= l;
+      assignOrMergeLane(i.C, n);
     } else if (t) {
-      i.k.m |= f;
-      i.k.te = undefined;
+      i.C.m |= l;
+      i.C.H = undefined;
     }
-    const e = i.k;
-    if (e.F === O) {
-      if (!e.B) {
-        e.B = true;
-        e.K.enqueue(_, e.G);
+    const e = i.C;
+    if (e.$ === P) {
+      if (!e.ee) {
+        e.ee = true;
+        e.te.enqueue(v, e.ne);
       }
       continue;
     }
-    const s = i.k.m & o ? R : W;
-    if (s.N > i.k.o) s.N = i.k.o;
-    insertIntoHeap(i.k, s);
+    const s = i.C.m & o ? Q : q;
+    if (s.j > i.C.o) s.j = i.C.o;
+    insertIntoHeap(i.C, s);
   }
 }
+function commitPendingNode(e) {
+  const t = e;
+  if (!t.L) {
+    if (e.Y !== x) {
+      e.ue = e.Y;
+      e.Y = x;
+    }
+    return;
+  }
+  if (e.Y !== x) {
+    e.ue = e.Y;
+    e.Y = x;
+    if (e.$ && e.$ !== P) e.ee = true;
+  }
+  t.m &= ~a;
+  if (!(t.be & m)) t.be &= ~b;
+  if (t.Oe !== null || t.ve !== null) GlobalQueue.pe(t, false, true);
+}
 function commitPendingNodes() {
-  const e = q.ue;
+  if (z.ce !== null) {
+    commitPendingNode(z.ce);
+    z.ce = null;
+  }
+  const e = z.ae;
   for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    if (n.T !== v) {
-      n.ne = n.T;
-      n.T = v;
-      if (n.F && n.F !== O) n.B = true;
-    }
-    if (!(n.ge & S)) n.ge &= ~m;
-    if (n.I) GlobalQueue.le(n, false, true);
+    commitPendingNode(e[t]);
   }
   e.length = 0;
 }
 function finalizePureQueue(e = null, t = false) {
   const n = !t;
   if (n) commitPendingNodes();
-  if (!t) checkBoundaryChildren(q);
-  if (W.S >= W.N) runHeap(W, GlobalQueue.fe);
+  if (!t && z.U.length) checkBoundaryChildren(z);
+  const r = q.S >= q.j;
+  if (r) runHeap(q, GlobalQueue.de);
   if (n) {
-    commitPendingNodes();
-    resolveOptimisticNodes(e ? e.Y : q.Y);
-    if (e && e.ee.size) {
-      for (const t of e.ee) {
+    if (r) commitPendingNodes();
+    resolveOptimisticNodes(e ? e.J : z.J);
+    if (e && e.oe.size) {
+      for (const t of e.oe) {
         if (t.m & u) continue;
-        if (t.F === O) {
-          if (!t.B) {
-            t.B = true;
-            t.K.enqueue(_, t.G);
+        if (t.$ === P) {
+          if (!t.ee) {
+            t.ee = true;
+            t.te.enqueue(v, t.ne);
           }
           continue;
         }
-        const e = t.m & o ? R : W;
-        if (e.N > t.o) e.N = t.o;
+        const e = t.m & o ? Q : q;
+        if (e.j > t.o) e.j = t.o;
         insertIntoHeap(t, e);
       }
-      e.ee.clear();
+      e.oe.clear();
     }
-    const t = e ? e.Z : q.Z;
-    if (GlobalQueue.ce && t.size) {
+    const t = e ? e.X : z.X;
+    if (GlobalQueue.ge && t.size) {
       for (const e of t) {
-        GlobalQueue.ce(e);
+        GlobalQueue.ge(e);
       }
       t.clear();
       schedule();
@@ -530,27 +663,36 @@ function finalizePureQueue(e = null, t = false) {
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.oe) {
+  for (const t of e.U) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  q.Z.add(e);
+  z.X.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].X = L;
+    e[t].V = M;
   }
 }
-const q = new GlobalQueue();
-function flush() {
-  if (q.ie) {
+const z = new GlobalQueue();
+function flush(e) {
+  if (e) {
+    V++;
+    try {
+      return e();
+    } finally {
+      flush();
+      V--;
+    }
+  }
+  if (z.le) {
     return;
   }
-  while (I || L) {
-    q.flush();
+  while (D || M) {
+    z.flush();
   }
 }
 function runQueue(e, t) {
@@ -558,21 +700,21 @@ function runQueue(e, t) {
 }
 function reporterBlocksSource(e, t) {
   if (e.m & (o | u)) return false;
-  if (e.Se === t || e.we?.has(t)) return true;
+  if (e.Pe === t || e.xe?.has(t)) return true;
   for (let n = e.W; n; n = n.R) {
     let e = n.A;
     while (e) {
-      if (e === t || e.L === t) return true;
-      e = e.me;
+      if (e === t || e.I === t) return true;
+      e = e.T;
     }
   }
-  return !!(e.ge & S && e.pe instanceof NotReadyError && e.pe.source === t);
+  return !!(e.be & m && e.we instanceof NotReadyError && e.we.source === t);
 }
 function transitionComplete(e) {
-  if (e.U) return true;
-  if (e.J.length) return false;
+  if (e.re) return true;
+  if (e.ie.length) return false;
   let t = true;
-  for (const [n, r] of e.$) {
+  for (const [n, r] of e.se) {
     let i = false;
     for (const e of r) {
       if (reporterBlocksSource(e, n)) {
@@ -581,181 +723,57 @@ function transitionComplete(e) {
       }
       r.delete(e);
     }
-    if (!i) e.$.delete(n);
-    else if (n.ge & S && n.pe?.source === n) {
+    if (!i) e.se.delete(n);
+    else if (n.be & m && n.we?.source === n) {
       t = false;
       break;
     }
   }
   if (t) {
-    for (let n = 0; n < e.Y.length; n++) {
-      const r = e.Y[n];
+    for (let n = 0; n < e.J.length; n++) {
+      const r = e.J[n];
       if (
         hasActiveOverride(r) &&
-        "ge" in r &&
-        r.ge & S &&
-        r.pe instanceof NotReadyError &&
-        r.pe.source !== r
+        "be" in r &&
+        r.be & m &&
+        r.we instanceof NotReadyError &&
+        r.we.source !== r
       ) {
         t = false;
         break;
       }
     }
   }
-  t && (e.U = true);
+  t && (e.re = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.U && typeof e.U === "object") e = e.U;
+  while (e.re && typeof e.re === "object") e = e.re;
   return e;
 }
 function setActiveTransition(e) {
-  L = e;
+  M = e;
 }
 function runInTransition(e, t) {
-  const n = L;
+  const n = M;
   try {
-    L = currentTransition(e);
+    M = currentTransition(e);
     return t();
   } finally {
-    L = n;
+    M = n;
   }
 }
-const M = new WeakMap();
-const V = new Set();
-function getOrCreateLane(e) {
-  let t = M.get(e);
-  if (t) {
-    return findLane(t);
-  }
-  const n = e.me;
-  const r = n?.te ? findLane(n.te) : null;
-  t = { re: e, V: new Set(), D: [[], []], M: null, X: L, be: r };
-  M.set(e, t);
-  V.add(t);
-  e._e = false;
-  return t;
-}
-function findLane(e) {
-  while (e.M) e = e.M;
-  return e;
-}
-function mergeLanes(e, t) {
-  e = findLane(e);
-  t = findLane(t);
-  if (e === t) return e;
-  t.M = e;
-  for (const n of t.V) e.V.add(n);
-  e.D[0].push(...t.D[0]);
-  e.D[1].push(...t.D[1]);
-  return e;
-}
-function resolveLane(e) {
-  const t = e.te;
-  if (!t) return undefined;
-  const n = findLane(t);
-  if (V.has(n)) return n;
-  e.te = undefined;
-  return undefined;
-}
-function resolveTransition(e) {
-  return resolveLane(e)?.X ?? e.X;
-}
-function hasActiveOverride(e) {
-  return !!(e.H !== undefined && e.H !== v);
-}
-function assignOrMergeLane(e, t) {
-  const n = findLane(t);
-  const r = e.te;
-  if (r) {
-    if (r.M) {
-      e.te = t;
-      return;
-    }
-    const i = findLane(r);
-    if (V.has(i)) {
-      if (i !== n && !hasActiveOverride(e)) {
-        if (n.be && findLane(n.be) === i) {
-          e.te = t;
-        } else if (i.be && findLane(i.be) === n);
-        else mergeLanes(n, i);
-      }
-      return;
-    }
-  }
-  e.te = t;
-}
-function unlinkSubs(e) {
-  const t = e.A;
-  const n = e.R;
-  const r = e.P;
-  const i = e.Oe;
-  if (r !== null) r.Oe = i;
-  else t.ve = i;
-  if (i !== null) i.P = r;
-  else {
-    t.O = r;
-    if (r === null) {
-      t.q?.();
-      const e = t;
-      e.I && e.de & g && !(e.m & o) && unobserved(e);
-    }
-  }
-  return n;
-}
-function unobserved(e) {
-  deleteFromHeap(e, e.m & o ? R : W);
-  let t = e.W;
-  while (t !== null) {
-    t = unlinkSubs(t);
-  }
-  e.W = null;
-  e.xe = null;
-  disposeChildren(e, true);
-}
-function link(e, t) {
-  const n = t.xe;
-  if (n !== null && n.A === e) return;
-  let i = null;
-  const s = t.m & r;
-  if (s) {
-    i = n !== null ? n.R : t.W;
-    if (i !== null && i.A === e) {
-      t.xe = i;
-      return;
-    }
-  }
-  const o = e.ve;
-  if (o !== null && o.k === t && (!s || isValidLink(o, t))) return;
-  const u = (t.xe = e.ve = { A: e, k: t, R: i, Oe: o, P: null });
-  if (n !== null) n.R = u;
-  else t.W = u;
-  if (o !== null) o.P = u;
-  else e.O = u;
-}
-function isValidLink(e, t) {
-  const n = t.xe;
-  if (n !== null) {
-    let r = t.W;
-    do {
-      if (r === e) return true;
-      if (r === n) break;
-      r = r.R;
-    } while (r !== null);
-  }
-  return false;
-}
-const D = {};
+const U = {};
 function markDisposal(e) {
-  let t = e.Pe;
+  let t = e.Ce;
   while (t) {
     t.m |= o;
     if (t.m & i) {
-      deleteFromHeap(t, W);
-      insertIntoHeap(t, R);
+      deleteFromHeap(t, q);
+      insertIntoHeap(t, Q);
     }
     markDisposal(t);
-    t = t.ke;
+    t = t.Ne;
   }
 }
 function dispose(e) {
@@ -764,39 +782,48 @@ function dispose(e) {
     t = unlinkSubs(t);
   } while (t !== null);
   e.W = null;
-  e.xe = null;
+  e.Ee = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e.m & u) return;
-  if (t) e.m = u;
-  if (t && e.I) e.Ce = null;
-  let r = n ? e.Ee : e.Pe;
-  while (r) {
-    const e = r.ke;
-    if (r.W) {
-      const e = r;
-      deleteFromHeap(e, e.m & o ? R : W);
+  const r = e.m;
+  if (r & u) return;
+  if (t) e.m = r | u;
+  if (t && e.L) e.ke = null;
+  let i = n ? e.Oe : e.Ce;
+  while (i) {
+    const e = i.Ne;
+    if (i.W) {
+      const e = i;
+      deleteFromHeap(e, e.m & o ? Q : q);
       let t = e.W;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
       e.W = null;
-      e.xe = null;
+      e.Ee = null;
     }
-    disposeChildren(r, true);
-    r = e;
+    disposeChildren(i, true);
+    i = e;
   }
   if (n) {
-    e.Ee = null;
+    e.Oe = null;
   } else {
-    e.Pe = null;
+    e.Ce = null;
     e.je = 0;
   }
+  if (t && !n && !(r & o) && e.i !== null && !(e.i.m & u)) {
+    const t = e.We;
+    const n = e.Ne;
+    if (t !== null) t.Ne = n;
+    else e.i.Ce = n;
+    if (n !== null) n.We = t;
+    e.We = null;
+  }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.Ne : e.We;
+  let n = t ? e.ve : e.Re;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -806,11 +833,11 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.Ne = null) : (e.We = null);
+  t ? (e.ve = null) : (e.Re = null);
 }
 function childId(e, t) {
   let n = e;
-  while (n.de & p && n.i) n = n.i;
+  while (n.ye & h && n.i) n = n.i;
   if (n.id != null) return formatId(n.id, t ? n.je++ : n.je);
   throw new Error("Cannot get child id from owner without an id");
 }
@@ -826,110 +853,184 @@ function formatId(e, t) {
   return e + (r ? String.fromCharCode(64 + r) : "") + n;
 }
 function getObserver() {
-  if (z || J) return D;
-  return B ? X : null;
+  if ($ || te) return U;
+  return X ? ne : null;
 }
 function getOwner() {
-  return X;
+  return ne;
 }
 function cleanup(e) {
-  if (!X) return e;
-  if (!X.We) X.We = e;
-  else if (Array.isArray(X.We)) X.We.push(e);
-  else X.We = [X.We, e];
+  if (!ne) return e;
+  if (!ne.Re) ne.Re = e;
+  else if (Array.isArray(ne.Re)) ne.Re.push(e);
+  else ne.Re = [ne.Re, e];
   return e;
 }
 function isDisposed(e) {
   return !!(e.m & (u | o));
 }
+function disposeRootSelf(e = true) {
+  disposeChildren(this, e);
+}
 function createOwner(e) {
-  const t = X;
+  const t = ne;
   const n = e?.transparent ?? false;
   const r = {
     id: e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined),
-    de: n ? p : 0,
+    ye: n ? h : 0,
     t: true,
     u: t?.t ? t.u : t,
-    Pe: null,
-    ke: null,
+    Ce: null,
+    Ne: null,
     We: null,
-    K: t?.K ?? q,
-    Re: t?.Re || C,
+    Re: null,
+    te: t?.te ?? z,
+    Ae: t?.Ae || k,
     je: 0,
-    Ne: null,
-    Ee: null,
+    ve: null,
+    Oe: null,
     i: t,
-    dispose(e = true) {
-      disposeChildren(r, e);
-    }
+    dispose: disposeRootSelf
   };
   if (t) {
-    const e = t.Pe;
+    const e = t.Ce;
     if (e === null) {
-      t.Pe = r;
+      t.Ce = r;
     } else {
-      r.ke = e;
-      t.Pe = r;
+      r.Ne = e;
+      e.We = r;
+      t.Ce = r;
     }
   }
   return r;
 }
 function createRoot(e, t) {
   const n = createOwner(t);
-  return runWithOwner(n, () => e(n.dispose));
+  return runWithOwner(n, () => e(() => n.dispose()));
+}
+function unlinkSubs(e) {
+  const t = e.A;
+  const n = e.R;
+  const r = e.P;
+  const i = e.Ie;
+  if (r !== null) r.Ie = i;
+  else t.Le = i;
+  if (i !== null) i.P = r;
+  else {
+    t.O = r;
+    if (r === null) {
+      t.Z?.();
+      const e = t;
+      e.L && e.ye & y && !(e.m & o) && unobserved(e);
+    }
+  }
+  return n;
+}
+function trimStaleDeps(e) {
+  const t = e.Ee;
+  let n = t !== null ? t.R : e.W;
+  if (n !== null) {
+    do {
+      n = unlinkSubs(n);
+    } while (n !== null);
+    if (t !== null) t.R = null;
+    else e.W = null;
+  }
+}
+function unobserved(e) {
+  deleteFromHeap(e, e.m & o ? Q : q);
+  let t = e.W;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.W = null;
+  e.Ee = null;
+  disposeChildren(e, true);
+}
+function link(e, t) {
+  const n = t.Ee;
+  if (n !== null && n.A === e) return;
+  let i = null;
+  const s = t.m & r;
+  if (s) {
+    i = n !== null ? n.R : t.W;
+    if (i !== null && i.A === e) {
+      t.Ee = i;
+      return;
+    }
+  }
+  const o = e.Le;
+  if (o !== null && o.C === t && (!s || isValidLink(o, t))) return;
+  const u = (t.Ee = e.Le = { A: e, C: t, R: i, Ie: o, P: null });
+  if (n !== null) n.R = u;
+  else t.W = u;
+  if (o !== null) o.P = u;
+  else e.O = u;
+}
+function isValidLink(e, t) {
+  const n = t.Ee;
+  if (n !== null) {
+    let r = t.W;
+    do {
+      if (r === e) return true;
+      if (r === n) break;
+      r = r.R;
+    } while (r !== null);
+  }
+  return false;
 }
 function addPendingSource(e, t) {
-  if (e.Se === t || e.we?.has(t)) return false;
-  if (!e.Se) {
-    e.Se = t;
+  if (e.Pe === t || e.xe?.has(t)) return false;
+  if (!e.Pe) {
+    e.Pe = t;
     return true;
   }
-  if (!e.we) {
-    e.we = new Set([e.Se, t]);
+  if (!e.xe) {
+    e.xe = new Set([e.Pe, t]);
   } else {
-    e.we.add(t);
+    e.xe.add(t);
   }
-  e.Se = undefined;
+  e.Pe = undefined;
   return true;
 }
 function removePendingSource(e, t) {
-  if (e.Se) {
-    if (e.Se !== t) return false;
-    e.Se = undefined;
+  if (e.Pe) {
+    if (e.Pe !== t) return false;
+    e.Pe = undefined;
     return true;
   }
-  if (!e.we?.delete(t)) return false;
-  if (e.we.size === 1) {
-    e.Se = e.we.values().next().value;
-    e.we = undefined;
-  } else if (e.we.size === 0) {
-    e.we = undefined;
+  if (!e.xe?.delete(t)) return false;
+  if (e.xe.size === 1) {
+    e.Pe = e.xe.values().next().value;
+    e.xe = undefined;
+  } else if (e.xe.size === 0) {
+    e.xe = undefined;
   }
   return true;
 }
 function clearPendingSources(e) {
-  e.Se = undefined;
-  e.we?.clear();
-  e.we = undefined;
+  e.Pe = undefined;
+  e.xe?.clear();
+  e.xe = undefined;
 }
 function setPendingError(e, t, n) {
   if (!t) {
-    e.pe = null;
+    e.we = null;
     return;
   }
   if (n instanceof NotReadyError && n.source === t) {
-    e.pe = n;
+    e.we = n;
     return;
   }
-  const r = e.pe;
+  const r = e.we;
   if (!(r instanceof NotReadyError) || r.source !== t) {
-    e.pe = new NotReadyError(t);
+    e.we = new NotReadyError(t);
   }
 }
 function forEachDependent(e, t) {
-  for (let n = e.O; n !== null; n = n.P) t(n.k);
-  for (let n = e.C; n !== null; n = n.j) {
-    for (let e = n.O; e !== null; e = e.P) t(e.k);
+  for (let n = e.O; n !== null; n = n.P) t(n.C);
+  for (let n = e.N; n !== null; n = n.k) {
+    for (let e = n.O; e !== null; e = e.P) t(e.C);
   }
 }
 function settlePendingSource(e) {
@@ -938,30 +1039,30 @@ function settlePendingSource(e) {
   const settle = r => {
     if (n.has(r) || !removePendingSource(r, e)) return;
     n.add(r);
-    r.he = A;
-    const i = r.Se ?? r.we?.values().next().value;
+    r.me = F;
+    const i = r.Pe ?? r.xe?.values().next().value;
     if (i) {
       setPendingError(r, i);
       updatePendingSignal(r);
     } else {
-      r.ge &= ~S;
+      r.be &= ~m;
       setPendingError(r);
       updatePendingSignal(r);
-      if (r.Ae) {
-        if (r.F === O) {
+      if (r.Te) {
+        if (r.$ === P) {
           const e = r;
-          if (!e.B) {
-            e.B = true;
-            e.K.enqueue(_, e.G);
+          if (!e.ee) {
+            e.ee = true;
+            e.te.enqueue(v, e.ne);
           }
         } else {
-          const e = r.m & o ? R : W;
-          if (e.N > r.o) e.N = r.o;
+          const e = r.m & o ? Q : q;
+          if (e.j > r.o) e.j = r.o;
           insertIntoHeap(r, e);
         }
         t = true;
       }
-      r.Ae = false;
+      r.Te = false;
     }
     forEachDependent(r, settle);
   };
@@ -969,46 +1070,52 @@ function settlePendingSource(e) {
   if (t) schedule();
 }
 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.Ce = null;
+  let i = false;
+  let s = false;
+  if (typeof t === "object" && t !== null) {
+    untrack(() => {
+      i = t[Symbol.asyncIterator];
+      s = !i && typeof t.then === "function";
+    });
+  }
+  if (!s && !i) {
+    e.ke = null;
     return t;
   }
-  e.Ce = t;
-  let u;
+  e.ke = t;
+  let o;
   const handleError = n => {
-    if (e.Ce !== t) return;
-    q.initTransition(resolveTransition(e));
-    notifyStatus(e, n instanceof NotReadyError ? S : w, n);
-    e.he = A;
+    if (e.ke !== t) return;
+    z.initTransition(resolveTransition(e));
+    notifyStatus(e, n instanceof NotReadyError ? m : _, n);
+    e.me = F;
   };
   const asyncWrite = (i, s) => {
-    if (e.Ce !== t) return;
-    if (e.m & (n | f)) return;
-    q.initTransition(resolveTransition(e));
-    const o = !!(e.ge & m);
+    if (e.ke !== t) return;
+    if (e.m & (n | l)) return;
+    z.initTransition(resolveTransition(e));
+    const o = !!(e.be & b);
+    trimStaleDeps(e);
     clearStatus(e);
     const u = resolveLane(e);
-    if (u) u.V.delete(e);
+    if (u) u.F.delete(e);
     if (r) r(i);
-    else if (e.H !== undefined) {
-      if (e.H !== undefined && e.H !== v) e.T = i;
+    else if (e.G !== undefined) {
+      if (e.G !== undefined && e.G !== x) e.Y = i;
       else {
-        e.ne = i;
+        e.ue = i;
         insertSubs(e);
       }
-      e.he = A;
+      e.me = F;
     } else if (u) {
-      const t = e.F;
-      const n = e.ne;
-      const r = e.Le;
+      const t = e.$;
+      const n = e.ue;
+      const r = e.He;
       if ((!t && o) || !r || !r(i, n)) {
-        e.ne = i;
-        e.he = A;
-        if (e.Ie) {
-          setSignal(e.Ie, i);
+        e.ue = i;
+        e.me = F;
+        if (e.qe) {
+          setSignal(e.qe, i);
         }
         insertSubs(e, true);
       }
@@ -1020,13 +1127,13 @@ function handleAsync(e, t, r) {
     flush();
     s?.();
   };
-  if (o) {
+  if (s) {
     let n = false,
       r = true;
     t.then(
       e => {
         if (r) {
-          u = e;
+          o = e;
           n = true;
         } else asyncWrite(e);
       },
@@ -1036,11 +1143,11 @@ function handleAsync(e, t, r) {
     );
     r = false;
     if (!n) {
-      q.initTransition(resolveTransition(e));
-      throw new NotReadyError(X);
+      z.initTransition(resolveTransition(e));
+      throw new NotReadyError(ne);
     }
   }
-  if (s) {
+  if (i) {
     const n = t[Symbol.asyncIterator]();
     let r = false;
     let i = false;
@@ -1056,15 +1163,15 @@ function handleAsync(e, t, r) {
     });
     const iterate = () => {
       let s,
-        o = false,
-        f = true;
+        u = false,
+        l = true;
       n.next().then(
         n => {
-          if (f) {
+          if (l) {
             s = n;
-            o = true;
+            u = true;
             if (n.done) i = true;
-          } else if (e.Ce !== t) {
+          } else if (e.ke !== t) {
             return;
           } else if (!n.done) asyncWrite(n.value, iterate);
           else {
@@ -1074,88 +1181,88 @@ function handleAsync(e, t, r) {
           }
         },
         n => {
-          if (!f && e.Ce === t) {
+          if (!l && e.ke === t) {
             i = true;
             handleError(n);
           }
         }
       );
-      f = false;
-      if (o && !s.done) {
-        u = s.value;
+      l = false;
+      if (u && !s.done) {
+        o = s.value;
         r = true;
         return iterate();
       }
-      return o && s.done;
+      return u && s.done;
     };
     const s = iterate();
     if (!r && !s) {
-      q.initTransition(resolveTransition(e));
-      throw new NotReadyError(X);
+      z.initTransition(resolveTransition(e));
+      throw new NotReadyError(ne);
     }
   }
-  return u;
+  return o;
 }
 function clearStatus(e, t = false) {
-  clearPendingSources(e);
-  e.Ae = false;
-  e.ge = t ? 0 : e.ge & m;
-  setPendingError(e);
-  updatePendingSignal(e);
-  e.Te?.();
+  if (e.Pe || e.xe) clearPendingSources(e);
+  if (e.Te) e.Te = false;
+  e.be = t ? 0 : e.be & b;
+  if (e.we) setPendingError(e);
+  if (e.Qe) updatePendingSignal(e);
+  if (e.Fe) e.Fe();
 }
 function notifyStatus(e, t, n, r, i) {
-  if (t === w && !(n instanceof StatusError) && !(n instanceof NotReadyError))
+  if (t === _ && !(n instanceof StatusError) && !(n instanceof NotReadyError))
     n = new StatusError(e, n);
-  const s = t === S && n instanceof NotReadyError ? n.source : undefined;
+  const s = t === m && n instanceof NotReadyError ? n.source : undefined;
   const o = s === e;
-  const u = t === S && e.H !== undefined && !o;
-  const f = u && hasActiveOverride(e);
+  const u = t === m && e.G !== undefined && !o;
+  const l = u && hasActiveOverride(e);
   if (!r) {
-    if (t === S && s) {
+    if (t === m && s) {
       addPendingSource(e, s);
-      e.ge = S | (e.ge & m);
+      e.be = m | (e.be & b);
       setPendingError(e, s, n);
     } else {
       clearPendingSources(e);
-      e.ge = t | (t !== w ? e.ge & m : 0);
-      e.pe = n;
+      e.be = t | (t !== _ ? e.be & b : 0);
+      e.we = n;
     }
     updatePendingSignal(e);
   }
   if (i && !r) {
     assignOrMergeLane(e, i);
   }
-  const l = r || f;
+  const f = r || l;
   const c = r || u ? undefined : i;
-  if (e.Te) {
-    if (r && t === S) {
+  if (e.Fe) {
+    if (r && t === m) {
       return;
     }
-    if (l) {
-      e.Te(t, n);
+    if (f) {
+      e.Fe(t, n);
     } else {
-      e.Te();
+      e.Fe();
     }
     return;
   }
   forEachDependent(e, e => {
-    e.he = A;
+    e.me = F;
     if (
-      (t === S && s && e.Se !== s && !e.we?.has(s)) ||
-      (t !== S && (e.pe !== n || e.Se || e.we))
+      (t === m && s && e.Pe !== s && !e.xe?.has(s)) ||
+      (t !== m && (e.we !== n || e.Pe || e.xe))
     ) {
-      if (!l && !e.X) q.ue.push(e);
-      notifyStatus(e, t, n, l, c);
+      if (!f && !e.V) queuePendingNode(e);
+      notifyStatus(e, t, n, f, c);
     }
   });
 }
-let F = null;
+let J = null;
 function enableExternalSource(e) {
   const { factory: t, untrack: n = e => e() } = e;
-  if (F) {
-    const { factory: e, untrack: r } = F;
-    F = {
+  if (J) {
+    const { factory: e, untrack: r } = J;
+    J = {
       factory: (n, r) => {
         const i = e(n, r);
         const s = t(e => i.track(e), r);
@@ -1170,192 +1277,203 @@ function enableExternalSource(e) {
       untrack: e => r(() => n(e))
     };
   } else {
-    F = { factory: t, untrack: n };
+    J = { factory: t, untrack: n };
   }
 }
-GlobalQueue.fe = recompute;
-GlobalQueue.le = disposeChildren;
-let B = false;
-let K = false;
-let G = false;
-let z = false;
-let U = false;
-let J = false;
-let X = null;
-let Y = null;
+GlobalQueue.de = recompute;
+GlobalQueue.pe = disposeChildren;
+let X = false;
+let Y = false;
 let Z = false;
-let $ = null;
+let $ = false;
+let ee = false;
+let te = false;
+let ne = null;
+let re = null;
+let ie = false;
+let se = null;
 function ownerInSnapshotScope(e) {
   while (e) {
-    if (e.He) return true;
+    if (e.Me) return true;
     e = e.i;
   }
   return false;
 }
 function setSnapshotCapture(e) {
-  Z = e;
-  if (e && !$) $ = new Set();
+  ie = e;
+  if (e && !se) se = new Set();
 }
 function markSnapshotScope(e) {
-  e.He = true;
+  e.Me = true;
 }
 function releaseSnapshotScope(e) {
-  e.He = false;
+  e.Me = false;
   releaseSubtree(e);
   schedule();
 }
 function releaseSubtree(e) {
-  let t = e.Pe;
+  let t = e.Ce;
   while (t) {
-    if (t.He) {
-      t = t.ke;
+    if (t.Me) {
+      t = t.Ne;
       continue;
     }
-    if (t.I) {
+    if (t.L) {
       const e = t;
-      e.de &= ~h;
-      if (e.m & l) {
-        e.m &= ~l;
+      e.ye &= ~g;
+      if (e.m & f) {
+        e.m &= ~f;
         e.m |= n;
-        if (W.N > e.o) W.N = e.o;
-        insertIntoHeap(e, W);
+        if (q.j > e.o) q.j = e.o;
+        insertIntoHeap(e, q);
       }
     }
     releaseSubtree(t);
-    t = t.ke;
+    t = t.Ne;
   }
 }
 function clearSnapshots() {
-  if ($) {
-    for (const e of $) {
-      delete e.ye;
-      delete e[P];
+  if (se) {
+    for (const e of se) {
+      delete e._e;
+      delete e[N];
     }
-    $ = null;
+    se = null;
   }
-  Z = false;
+  ie = false;
 }
 function recompute(t, n = false) {
-  const i = t.F;
+  const i = t.$;
   if (!n) {
-    if (t.X && (!i || L) && L !== t.X) q.initTransition(t.X);
-    deleteFromHeap(t, t.m & o ? R : W);
-    t.Ce = null;
-    if (t.X || i === O) disposeChildren(t);
-    else {
+    if (t.V && (!i || M) && M !== t.V) z.initTransition(t.V);
+    deleteFromHeap(t, t.m & o ? Q : q);
+    t.ke = null;
+    if (t.V || i === P) disposeChildren(t);
+    else if (t.Ce !== null || t.Re !== null) {
       markDisposal(t);
-      t.Ne = t.We;
-      t.Ee = t.Pe;
-      t.We = null;
-      t.Pe = null;
+      t.ve = t.Re;
+      t.Oe = t.Ce;
+      t.Re = null;
+      t.Ce = null;
       t.je = 0;
-    }
-  }
-  let s = !!(t.m & f);
-  const u = t.H !== undefined && t.H !== v;
-  const c = !!(t.ge & S);
-  const a = !!(t.ge & m);
-  const d = X;
-  X = t;
-  t.xe = null;
+    } else;
+  }
+  let s = !!(t.m & l);
+  const u = t.G !== undefined && t.G !== x;
+  const c = !!(t.be & m);
+  const a = !!(t.be & b);
+  const d = ne;
+  ne = t;
+  t.Ee = null;
   t.m = r;
-  t.he = A;
-  let p = t.T === v ? t.ne : t.T;
+  t.me = F;
+  let p = t.Y === x ? t.ue : t.Y;
   let h = t.o;
-  let y = B;
-  let g = Y;
-  B = true;
+  let g = X;
+  let S = re;
+  X = true;
   if (s) {
     const e = resolveLane(t);
-    if (e) Y = e;
-  } else if (L && !n && L.Y.length) {
+    if (e) re = e;
+  } else if (M && !n && M.J.length) {
     for (let e = t.W; e; e = e.R) {
       const n = e.A;
-      if (n.m & f) {
+      if (n.m & l) {
         const e = resolveLane(n);
         if (e) {
           s = true;
-          Y = e;
-          t.m |= f;
+          re = e;
+          t.m |= l;
           assignOrMergeLane(t, e);
           break;
         }
       }
     }
   }
+  const y = i && i !== v;
+  const O = Y;
+  if (y) Y = true;
   try {
-    const e = t.Ce;
-    const r = t.I(p);
-    p = t.Ce !== e ? r : handleAsync(t, r);
+    if (!false && t.ye & w) {
+      p = t.L(p);
+      t.ke = null;
+    } else {
+      const e = t.ke;
+      const n = t.L(p);
+      const r = typeof n === "object" && n !== null;
+      const i = t.ke !== e;
+      p = i || !r ? n : handleAsync(t, n);
+      if (!i && !r) t.ke = null;
+    }
     clearStatus(t, n);
-    const i = resolveLane(t);
-    if (i) {
-      i.V.delete(t);
-      updatePendingSignal(i.re);
+    if (t.H) {
+      const e = resolveLane(t);
+      if (e) {
+        e.F.delete(t);
+        updatePendingSignal(e.q);
+      }
     }
   } catch (e) {
-    if (e instanceof NotReadyError && Y) {
-      const e = findLane(Y);
-      if (e.re !== t) {
-        e.V.add(t);
-        t.te = e;
-        updatePendingSignal(e.re);
+    if (e instanceof NotReadyError && re) {
+      const e = findLane(re);
+      if (e.q !== t) {
+        e.F.add(t);
+        t.H = e;
+        updatePendingSignal(e.q);
       }
     }
-    if (e instanceof NotReadyError) t.Ae = true;
+    if (e instanceof NotReadyError) t.Te = true;
     notifyStatus(
       t,
-      e instanceof NotReadyError ? S : w,
+      e instanceof NotReadyError ? m : _,
       e,
       undefined,
-      e instanceof NotReadyError ? t.te : undefined
+      e instanceof NotReadyError ? t.H : undefined
     );
   } finally {
-    B = y;
-    t.m = e | (n ? t.m & l : 0);
-    X = d;
-  }
-  if (!t.pe) {
-    const e = t.xe;
-    let r = e !== null ? e.R : t.W;
-    if (r !== null) {
-      do {
-        r = unlinkSubs(r);
-      } while (r !== null);
-      if (e !== null) e.R = null;
-      else t.W = null;
-    }
-    const f = u ? t.H : t.T === v ? t.ne : t.T;
-    const l = (!i && a) || !t.Le || !t.Le(f, p);
-    if (l) {
-      const e = u ? t.H : undefined;
-      if (n || (i && L !== t.X) || s) {
-        t.ne = p;
+    X = g;
+    if (y) Y = O;
+    t.m = e | (n ? t.m & f : 0);
+    ne = d;
+  }
+  if (!t.we) {
+    trimStaleDeps(t);
+    const e = u ? t.G : t.Y === x ? t.ue : t.Y;
+    const r = (!i && a) || !t.He || !t.He(e, p);
+    if (i && r) {
+      t.ee = !t.we;
+      if (!n) t.te.enqueue(i, GlobalQueue.he.bind(null, t));
+    }
+    if (r) {
+      const e = u ? t.G : undefined;
+      if (n || (i && M !== t.V) || s) {
+        t.ue = p;
         if (u && s) {
-          t.H = p;
-          t.T = p;
+          t.G = p;
+          t.Y = p;
         }
-      } else t.T = p;
-      if (u && !s && c && !t._e) t.H = p;
-      if (!u || s || t.H !== e) insertSubs(t, s || u);
+      } else t.Y = p;
+      if (u && !s && c && !t.B) t.G = p;
+      if (!u || s || t.G !== e) insertSubs(t, s || u);
     } else if (u) {
-      t.T = p;
+      t.Y = p;
     } else if (t.o != h) {
       for (let e = t.O; e !== null; e = e.P) {
-        insertIntoHeapHeight(e.k, e.k.m & o ? R : W);
+        insertIntoHeapHeight(e.C, e.C.m & o ? Q : q);
       }
     }
   }
-  Y = g;
-  (!n || t.ge & S) && !t.X && !(L && u) && q.ue.push(t);
-  t.X && i && L !== t.X && runInTransition(t.X, () => recompute(t));
+  re = S;
+  const C = t.Y !== x || t.Oe !== null || t.ve !== null || !!(t.be & (m | b));
+  C && (!n || t.be & m) && !t.V && !(M && u) && queuePendingNode(t);
+  t.V && i && M !== t.V && runInTransition(t.V, () => recompute(t));
 }
 function updateIfNecessary(e) {
   if (e.m & t) {
     for (let t = e.W; t; t = t.R) {
       const r = t.A;
-      const i = r.L || r;
-      if (i.I) {
+      const i = r.I || r;
+      if (i.L) {
         updateIfNecessary(i);
       }
       if (e.m & n) {
@@ -1363,175 +1481,230 @@ function updateIfNecessary(e) {
       }
     }
   }
-  if (e.m & (n | f) || (e.pe && e.he < A && !e.Ce)) {
+  if (e.m & (n | l) || (e.we && e.me < F && !e.ke)) {
     recompute(e);
   }
-  e.m = e.m & (l | i | s);
+  e.m = e.m & (f | i | s);
 }
 function computed(t, n) {
   const r = n?.transparent ?? false;
   const i = {
-    id: n?.id ?? (r ? X?.id : X?.id != null ? getNextChildId(X) : undefined),
-    de:
-      (r ? p : 0) |
-      (n?.ownedWrite ? a : 0) |
-      (!X || n?.lazy ? g : 0) |
-      (Z && ownerInSnapshotScope(X) ? h : 0),
-    Le: n?.equals != null ? n.equals : isEqual,
-    q: n?.unobserved,
-    We: null,
-    K: X?.K ?? q,
-    Re: X?.Re ?? C,
+    id: n?.id ?? (r ? ne?.id : ne?.id != null ? getNextChildId(ne) : undefined),
+    ye:
+      (r ? h : 0) |
+      (n?.ownedWrite ? d : 0) |
+      (!ne || n?.lazy ? y : 0) |
+      (n?.sync ? w : 0) |
+      (ie && ownerInSnapshotScope(ne) ? g : 0),
+    He: n?.equals != null ? n.equals : isEqual,
+    Z: n?.unobserved,
+    Re: null,
+    te: ne?.te ?? z,
+    Ae: ne?.Ae ?? k,
     je: 0,
-    I: t,
-    ne: undefined,
+    L: t,
+    ue: undefined,
     o: 0,
-    C: null,
+    N: null,
     h: undefined,
     p: null,
     W: null,
-    xe: null,
+    Ee: null,
     O: null,
+    Le: null,
+    i: ne,
+    Ne: null,
+    We: null,
+    Ce: null,
+    m: n?.lazy ? c : e,
+    be: b,
+    me: F,
+    Y: x,
     ve: null,
-    i: X,
+    Oe: null,
     ke: null,
-    Pe: null,
-    m: n?.lazy ? c : e,
-    ge: m,
-    he: A,
-    T: v,
-    Ne: null,
+    V: null
+  };
+  setupComputedNode(i, n);
+  return i;
+}
+function createEffectNode(e, t, n, r, i, s) {
+  const o = s?.transparent ?? false;
+  const u = {
+    id: s?.id ?? (o ? ne?.id : ne?.id != null ? getNextChildId(ne) : undefined),
+    ye:
+      (o ? h : 0) |
+      (s?.ownedWrite ? d : 0) |
+      (s?.sync ? w : 0) |
+      (ie && ownerInSnapshotScope(ne) ? g : 0),
+    He: false,
+    Z: s?.unobserved,
+    Re: null,
+    te: ne?.te ?? z,
+    Ae: ne?.Ae ?? k,
+    je: 0,
+    L: e,
+    ue: undefined,
+    o: 0,
+    N: null,
+    h: undefined,
+    p: null,
+    W: null,
     Ee: null,
+    O: null,
+    Le: null,
+    i: ne,
+    Ne: null,
+    We: null,
     Ce: null,
-    X: null
+    m: c,
+    be: b,
+    me: F,
+    Y: x,
+    ve: null,
+    Oe: null,
+    ke: null,
+    V: null,
+    ee: false,
+    De: undefined,
+    Ve: t,
+    Ke: n,
+    Be: undefined,
+    Ge: false,
+    $: r,
+    Fe: i
   };
-  i.p = i;
-  const s = X?.t ? X.u : X;
-  if (X) {
-    const e = X.Pe;
-    if (e === null) {
-      X.Pe = i;
+  setupComputedNode(u, oe);
+  return u;
+}
+const oe = { lazy: true };
+function setupComputedNode(e, t) {
+  e.p = e;
+  const n = ne?.t ? ne.u : ne;
+  if (ne) {
+    const t = ne.Ce;
+    if (t === null) {
+      ne.Ce = e;
     } else {
-      i.ke = e;
-      X.Pe = i;
+      e.Ne = t;
+      t.We = e;
+      ne.Ce = e;
     }
   }
-  if (s) i.o = s.o + 1;
-  if (F) {
-    const e = signal(undefined, { equals: false, ownedWrite: true });
-    const t = F.factory(i.I, () => {
-      setSignal(e, undefined);
+  if (n) e.o = n.o + 1;
+  if (J) {
+    const t = signal(undefined, { equals: false, ownedWrite: true });
+    const n = J.factory(e.L, () => {
+      setSignal(t, undefined);
     });
-    cleanup(() => t.dispose());
-    i.I = n => {
-      read(e);
-      return t.track(n);
+    cleanup(() => n.dispose());
+    e.L = e => {
+      read(t);
+      return n.track(e);
     };
   }
-  !n?.lazy && recompute(i, true);
-  if (Z && !n?.lazy) {
-    if (!(i.ge & S)) {
-      i.ye = i.ne === undefined ? x : i.ne;
-      $.add(i);
+  !t?.lazy && recompute(e, true);
+  if (ie && !t?.lazy) {
+    if (!(e.be & m)) {
+      e._e = e.ue === undefined ? C : e.ue;
+      se.add(e);
     }
   }
-  return i;
 }
 function signal(e, t, n = null) {
   const r = {
-    Le: t?.equals != null ? t.equals : isEqual,
-    de: (t?.ownedWrite ? a : 0) | (t?.Qe ? d : 0),
-    q: t?.unobserved,
-    ne: e,
+    He: t?.equals != null ? t.equals : isEqual,
+    ye: (t?.ownedWrite ? d : 0) | (t?.ze ? p : 0),
+    Z: t?.unobserved,
+    ue: e,
     O: null,
-    ve: null,
-    he: A,
-    L: n,
-    j: n?.C || null,
-    T: v
+    Le: null,
+    me: F,
+    I: n,
+    k: n?.N || null,
+    Y: x
   };
-  n && (n.C = r);
-  if (Z && !(r.de & d) && !((n?.ge ?? 0) & S)) {
-    r.ye = e === undefined ? x : e;
-    $.add(r);
+  n && (n.N = r);
+  if (ie && !(r.ye & p) && !((n?.be ?? 0) & m)) {
+    r._e = e === undefined ? C : e;
+    se.add(r);
   }
   return r;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.H = v;
+  n.G = x;
   return n;
 }
 function optimisticComputed(e, t) {
   const n = computed(e, t);
-  n.H = v;
+  n.G = x;
   return n;
 }
 function isEqual(e, t) {
   return e === t;
 }
 function untrack(e, t) {
-  if (!F && !B && true) return e();
-  const n = B;
-  B = false;
+  if (!J && !X && true) return e();
+  const n = X;
+  X = false;
   try {
-    if (F) return F.untrack(e);
+    if (J) return J.untrack(e);
     return e();
   } finally {
-    B = n;
+    X = n;
   }
 }
 function read(e) {
-  if (J) {
+  if (te) {
     const t = getLatestValueComputed(e);
-    const n = J;
-    J = false;
-    const r = e.H !== undefined && e.H !== v ? e.H : e.ne;
+    const n = te;
+    te = false;
+    const r = e.G !== undefined && e.G !== x ? e.G : e.ue;
     let i;
     try {
       i = read(t);
     } catch (e) {
-      if (!X && e instanceof NotReadyError) return r;
+      if (!ne && e instanceof NotReadyError) return r;
       throw e;
     } finally {
-      J = n;
+      te = n;
     }
-    if (t.ge & S) return r;
-    if (K && Y && t.te) {
-      const e = findLane(t.te);
-      const n = findLane(Y);
-      if (e !== n && e.V.size > 0) {
+    if (t.be & m) return r;
+    if (Y && re && t.H) {
+      const e = findLane(t.H);
+      const n = findLane(re);
+      if (e !== n && e.F.size > 0) {
         return r;
       }
     }
     return i;
   }
-  if (z) {
-    const t = e.L;
-    const n = z;
-    z = false;
-    if (t && e.H !== undefined) {
-      if (e.H !== v && (t.Ce || !!(t.ge & S))) {
-        U = true;
-      }
-      let n = X;
+  if ($) {
+    const t = e.I;
+    const n = $;
+    $ = false;
+    if (t && e.G !== undefined) {
+      if (e.G !== x && (t.ke || !!(t.be & m))) {
+        ee = true;
+      }
+      let n = ne;
       if (n?.t) n = n.u;
-      if (n && B) link(e, n);
+      if (n && X) link(e, n);
       read(getPendingSignal(e));
       read(getPendingSignal(t));
     } else {
-      if (read(getPendingSignal(e))) U = true;
-      if (t && read(getPendingSignal(t))) U = true;
+      if (read(getPendingSignal(e))) ee = true;
+      if (t && read(getPendingSignal(t))) ee = true;
     }
-    z = n;
-    return e.ne;
+    $ = n;
+    return e.ue;
   }
-  let t = X;
+  let t = ne;
   if (t?.t) t = t.u;
   const n = e;
-  if (typeof n.I === "function") {
+  if (typeof n.L === "function") {
     const t = e;
-    if (G && !(t.m & u)) recompute(t);
     if (t.m & c) {
       t.m &= ~c;
       recompute(t, true);
@@ -1539,14 +1712,27 @@ function read(e) {
       recompute(t, true);
     }
   }
-  const r = e.L || e;
-  if (t && B) {
+  const r = e.I || e;
+  if (
+    !n.L &&
+    r === e &&
+    e.G === undefined &&
+    e._e === undefined &&
+    M === null &&
+    re === null &&
+    !ie &&
+    true
+  ) {
+    if (t && X) link(e, t);
+    return !t || e.Y === x ? e.ue : e.Y;
+  }
+  if (t && X) {
     link(e, t);
-    if (r.I) {
+    if (r.L) {
       const n = e.m & o;
-      if (r.o >= (n ? R.N : W.N)) {
+      if (r.o >= (n ? Q.j : q.j)) {
         markNode(t);
-        markHeap(n ? R : W);
+        markHeap(n ? Q : q);
         updateIfNecessary(r);
       }
       const i = r.o;
@@ -1555,226 +1741,236 @@ function read(e) {
       }
     }
   }
-  if (r.ge & S) {
-    if (t && !(K && r.X && L !== r.X)) {
-      if (Y) {
-        const n = r.te;
-        const i = findLane(Y);
+  if (r.be & m) {
+    if (t && !(Y && r.V && M !== r.V)) {
+      if (re) {
+        const n = r.H;
+        const i = findLane(re);
         if (n && findLane(n) === i && !hasActiveOverride(r)) {
-          if (!B && e !== t) link(e, t);
-          throw r.pe;
+          if (!X && e !== t) link(e, t);
+          throw r.we;
         }
       } else {
-        if (!B && e !== t) link(e, t);
-        throw r.pe;
+        if (!X && e !== t) link(e, t);
+        throw r.we;
       }
-    } else if (t && r !== e && r.ge & m) {
-      if (!B && e !== t) link(e, t);
-      throw r.pe;
-    } else if (!t && r.ge & m) {
-      throw r.pe;
+    } else if (t && r !== e && r.be & b) {
+      if (!X && e !== t) link(e, t);
+      throw r.we;
+    } else if (!t && r.be & b) {
+      throw r.we;
     }
   }
-  if (e.I && e.ge & w) {
-    if (e.he < A) {
+  if (e.L && e.be & _) {
+    if (e.me < F) {
       recompute(e);
       return read(e);
-    } else throw e.pe;
+    } else throw e.we;
   }
-  if (Z && t && t.de & h) {
-    const n = e.ye;
+  if (ie && t && t.ye & g) {
+    const n = e._e;
     if (n !== undefined) {
-      const r = n === x ? undefined : n;
-      const i = e.T !== v ? e.T : e.ne;
-      if (i !== r) t.m |= l;
+      const r = n === C ? undefined : n;
+      const i = e.Y !== x ? e.Y : e.ue;
+      if (i !== r) t.m |= f;
       return r;
     }
   }
-  if (e.H !== undefined && e.H !== v) {
-    if (t && K && shouldReadStashedOptimisticValue(e)) return e.ne;
-    return e.H;
+  if (e.G !== undefined && e.G !== x) {
+    if (t && Y && shouldReadStashedOptimisticValue(e)) return e.ue;
+    return e.G;
   }
-  if (L !== null && Y !== null && !J && e.T !== v && r === e && !e.I && t) {
-    L.ee.add(t);
-    return e.ne;
+  if (M !== null && re !== null && !te && e.Y !== x && r === e && !e.L && t) {
+    M.oe.add(t);
+    return e.ue;
   }
   const i =
     !t ||
-    (Y !== null && (e.H !== undefined || e.te || (r === e && K) || !!(r.ge & S))) ||
-    e.T === v ||
-    (K && e.X && L !== e.X)
-      ? e.ne
-      : e.T;
-  if (!t && r === e && typeof n.I === "function" && e.de & g && !(r.ge & S) && !e.O) {
+    (re !== null && (e.G !== undefined || e.H || (r === e && Y) || !!(r.be & m))) ||
+    e.Y === x ||
+    (Y && e.V && M !== e.V)
+      ? e.ue
+      : e.Y;
+  if (!t && r === e && typeof n.L === "function" && e.ye & y && !(r.be & m) && !e.O) {
     unobserved(e);
   }
   return i;
 }
 function setSignal(e, t) {
-  if (e.X && L !== e.X) q.initTransition(e.X);
-  const n = e.H !== undefined && !T;
-  const r = e.H !== undefined && e.H !== v;
-  const i = n ? (r ? e.H : e.ne) : e.T === v ? e.ne : e.T;
+  if (e.V && M !== e.V) z.initTransition(e.V);
+  const n = e.G !== undefined && !K;
+  const r = e.G !== undefined && e.G !== x;
+  const i = n ? (r ? e.G : e.ue) : e.Y === x ? e.ue : e.Y;
   if (typeof t === "function") t = t(i);
-  const s = !e.Le || !e.Le(i, t) || !!(e.ge & m);
+  const s = !e.He || !e.He(i, t) || !!(e.be & b);
   if (!s) {
-    if (n && r && e.I) {
+    if (n && r && e.L) {
       insertSubs(e, true);
       schedule();
     }
     return t;
   }
   if (n) {
-    const n = e.H === v;
-    if (!n) q.initTransition(resolveTransition(e));
+    const n = e.G === x;
+    if (!n) z.initTransition(resolveTransition(e));
     if (n) {
-      e.T = e.ne;
-      q.Y.push(e);
+      e.Y = e.ue;
+      z.J.push(e);
     }
-    e._e = true;
+    e.B = true;
     const r = getOrCreateLane(e);
-    e.te = r;
-    e.H = t;
+    e.H = r;
+    e.G = t;
   } else {
-    if (e.T === v) q.ue.push(e);
-    e.T = t;
+    if (e.Y === x) queuePendingNode(e);
+    e.Y = t;
   }
-  updatePendingSignal(e);
-  if (e.Ie) {
-    setSignal(e.Ie, t);
+  if (e.Qe) updatePendingSignal(e);
+  if (e.qe) {
+    setSignal(e.qe, t);
   }
-  e.he = A;
+  e.me = F;
   insertSubs(e, n);
   schedule();
   return t;
 }
+function suppressComputedRecompute(e) {
+  deleteFromHeap(e, e.m & o ? Q : q);
+  if (!(e.m & a) && e.Y === x) queuePendingNode(e);
+  e.m = (e.m & -4) | a;
+}
+function setMemo(e, t) {
+  const n = setSignal(e, t);
+  suppressComputedRecompute(e);
+  return n;
+}
 function runWithOwner(e, t) {
-  const n = X;
-  const r = B;
-  X = e;
-  B = false;
+  const n = ne;
+  const r = X;
+  ne = e;
+  X = false;
   try {
     return t();
   } finally {
-    X = n;
-    B = r;
+    ne = n;
+    X = r;
   }
 }
 function getPendingSignal(e) {
-  if (!e.qe) {
-    e.qe = optimisticSignal(false, { ownedWrite: true });
-    if (e.me) {
-      e.qe.me = e;
+  if (!e.Qe) {
+    e.Qe = optimisticSignal(false, { ownedWrite: true });
+    if (e.T) {
+      e.Qe.T = e;
     }
-    if (computePendingState(e)) setSignal(e.qe, true);
+    if (computePendingState(e)) setSignal(e.Qe, true);
   }
-  return e.qe;
+  return e.Qe;
 }
 function computePendingState(e) {
   const t = e;
-  const n = e.L;
-  if (n && e.T !== v) {
-    return !n.Ce && !(n.ge & S);
+  const n = e.I;
+  if (n && e.Y !== x) {
+    return !n.ke && !(n.be & m);
   }
-  if (e.H !== undefined && e.H !== v) {
-    if (t.ge & S && !(t.ge & m)) return true;
-    if (e.me) {
-      const t = e.te ? findLane(e.te) : null;
-      return !!(t && t.V.size > 0);
+  if (e.G !== undefined && e.G !== x) {
+    if (t.be & m && !(t.be & b)) return true;
+    if (e.T) {
+      const t = e.H ? findLane(e.H) : null;
+      return !!(t && t.F.size > 0);
     }
     return true;
   }
-  if (e.H !== undefined && e.H === v && !e.me) {
+  if (e.G !== undefined && e.G === x && !e.T) {
     return false;
   }
-  if (e.T !== v && !(t.ge & m)) return true;
-  return !!(t.ge & S && !(t.ge & m));
+  if (e.Y !== x && !(t.be & b)) return true;
+  return !!(t.be & m && !(t.be & b));
 }
 function updatePendingSignal(e) {
-  if (e.qe) {
+  if (e.Qe) {
     const t = computePendingState(e);
-    const n = e.qe;
+    const n = e.Qe;
     setSignal(n, t);
-    if (!t && n.te) {
+    if (!t && n.H) {
       const t = resolveLane(e);
-      if (t && t.V.size > 0) {
-        const e = findLane(n.te);
+      if (t && t.F.size > 0) {
+        const e = findLane(n.H);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
-      M.delete(n);
-      n.te = undefined;
+      L.delete(n);
+      n.H = undefined;
     }
   }
 }
 function getLatestValueComputed(e) {
-  if (!e.Ie) {
-    const t = J;
-    J = false;
-    const n = z;
-    z = false;
-    const r = X;
-    X = null;
-    e.Ie = optimisticComputed(() => read(e));
-    e.Ie.me = e;
-    X = r;
-    z = n;
-    J = t;
+  if (!e.qe) {
+    const t = te;
+    te = false;
+    const n = $;
+    $ = false;
+    const r = ne;
+    ne = null;
+    e.qe = optimisticComputed(() => read(e));
+    e.qe.T = e;
+    ne = r;
+    $ = n;
+    te = t;
   }
-  return e.Ie;
+  return e.qe;
 }
 function staleValues(e, t = true) {
-  const n = K;
-  K = t;
+  const n = Y;
+  Y = t;
   try {
     return e();
   } finally {
-    K = n;
+    Y = n;
   }
 }
 function latest(e) {
-  const t = J;
-  J = true;
+  const t = te;
+  te = true;
   try {
     return e();
   } finally {
-    J = t;
+    te = t;
   }
 }
 function isPending(e) {
-  const t = z;
-  const n = U;
-  z = true;
-  U = false;
+  const t = $;
+  const n = ee;
+  $ = true;
+  ee = false;
   try {
     e();
-    return U;
+    return ee;
   } catch {
-    return U;
+    return ee;
   } finally {
-    z = t;
-    U = n;
+    $ = t;
+    ee = n;
   }
 }
 function refresh(e) {
-  let t = G;
-  G = true;
+  let t = Z;
+  Z = true;
   try {
-    if (typeof e !== "function") {
-      recompute(e[E]);
-      return e;
+    const t = e?.[j];
+    if (false && !t);
+    if (t && typeof t.L === "function" && !(t.m & u)) {
+      recompute(t);
     }
-    return untrack(e);
   } finally {
-    G = t;
+    Z = t;
     if (!t) {
       schedule();
     }
   }
 }
 function isRefreshing() {
-  return G;
+  return Z;
 }
 function createContext(e, t) {
   return { id: Symbol(t), defaultValue: e };
@@ -1783,7 +1979,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.Re[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.Ae[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -1793,113 +1989,102 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.Re = { ...n.Re, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.Ae = { ...n.Ae, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.Re[e.id]);
+  return !isUndefined(t?.Ae[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
 }
 function effect(e, t, n, r) {
-  let i = false;
-  const s = !!r?.user;
-  const o = computed(s ? e : t => staleValues(() => e(t)), {
-    ...r,
-    equals: () => {
-      o.B = !o.pe;
-      if (i) o.K.enqueue(o.F, runEffect.bind(o));
-      return false;
-    },
-    lazy: true
-  });
-  o.de &= ~g;
-  o.Me = undefined;
-  o.Ve = t;
-  o.De = n;
-  o.Fe = undefined;
-  o.F = s ? _ : b;
-  o.Te = (e, t) => {
-    const n = e !== undefined ? e : o.ge;
-    const r = t !== undefined ? t : o.pe;
-    if (n & w) {
-      let e = r;
-      o.K.notify(o, S, 0);
-      if (o.F === _) {
-        try {
-          return o.De
-            ? o.De(e, () => {
-                o.Fe?.();
-                o.Fe = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
-        }
+  const i = !!r?.user;
+  const s = createEffectNode(e, t, n, i ? v : O, notifyEffectStatus, r);
+  recompute(s, true);
+  !r?.defer &&
+    (s.$ === v || r?.schedule ? s.te.enqueue(s.$, runEffect.bind(null, s)) : runEffect(s));
+}
+function notifyEffectStatus(e, t) {
+  const n = e !== undefined ? e : this.be;
+  const r = t !== undefined ? t : this.we;
+  if (n & _) {
+    let e = r;
+    this.te.notify(this, m, 0);
+    if (this.$ === v) {
+      try {
+        return this.Ke
+          ? this.Ke(e, () => {
+              this.Be?.();
+              this.Be = undefined;
+            })
+          : console.error(e);
+      } catch (t) {
+        e = t;
       }
-      if (!o.K.notify(o, w, w)) throw e;
-    } else if (o.F === b) {
-      o.K.notify(o, S | w, n, r);
     }
-  };
-  recompute(o, true);
-  !r?.defer && (o.F === _ || r?.schedule ? o.K.enqueue(o.F, runEffect.bind(o)) : runEffect.call(o));
-  i = true;
-  cleanup(() => o.Fe?.());
-}
-function runEffect() {
-  if (!this.B || this.m & u) return;
-  this.Fe?.();
-  this.Fe = undefined;
+    if (!this.te.notify(this, _, _)) throw e;
+  } else if (this.$ === O) {
+    this.te.notify(this, m | _, n, r);
+  }
+}
+function runEffect(e) {
+  if (!e.ee || e.m & u) return;
+  e.Be?.();
+  e.Be = undefined;
   try {
-    const e = this.Ve(this.ne, this.Me);
-    if (false && e !== undefined && typeof e !== "function");
-    this.Fe = e;
-  } catch (e) {
-    this.pe = new StatusError(this, e);
-    this.ge |= w;
-    if (!this.K.notify(this, w, w)) throw e;
+    const t = e.Ve(e.ue, e.De);
+    if (false && t !== undefined && typeof t !== "function");
+    e.Be = t;
+    if (e.Be && !e.Ge) {
+      e.Ge = true;
+      runWithOwner(e.i, () => cleanup(() => e.Be?.()));
+    }
+  } catch (t) {
+    e.we = new StatusError(e, t);
+    e.be |= _;
+    if (!e.te.notify(e, _, _)) throw t;
   } finally {
-    this.Me = this.ne;
-    this.B = false;
+    e.De = e.ue;
+    e.ee = false;
   }
 }
+GlobalQueue.he = runEffect;
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.B || n.m & u) return;
+    if (!n.ee || n.m & u) return;
     try {
-      n.B = false;
+      n.ee = false;
       recompute(n);
     } finally {
     }
   };
   const n = computed(
     () => {
-      n.Fe?.();
-      n.Fe = undefined;
+      n.Be?.();
+      n.Be = undefined;
       const t = staleValues(e);
-      n.Fe = t;
+      n.Be = t;
     },
     { ...t, lazy: true }
   );
-  n.Fe = undefined;
-  n.de = (n.de & ~g) | y;
-  n.B = true;
-  n.F = O;
-  n.Te = (e, t) => {
-    const r = e !== undefined ? e : n.ge;
-    if (r & w) {
-      n.K.notify(n, S, 0);
-      const e = t !== undefined ? t : n.pe;
-      if (!n.K.notify(n, w, w)) throw e;
+  n.Be = undefined;
+  n.ye = (n.ye & ~y) | S;
+  n.ee = true;
+  n.$ = P;
+  n.Fe = (e, t) => {
+    const r = e !== undefined ? e : n.be;
+    if (r & _) {
+      n.te.notify(n, m, 0);
+      const e = t !== undefined ? t : n.we;
+      if (!n.te.notify(n, _, _)) throw e;
     }
   };
-  n.G = run;
-  n.K.enqueue(_, run);
-  cleanup(() => n.Fe?.());
+  n.ne = run;
+  n.te.enqueue(v, run);
+  cleanup(() => n.Be?.());
 }
 function restoreTransition(e, t) {
-  q.initTransition(e);
+  z.initTransition(e);
   const n = t();
   flush();
   return n;
@@ -1908,13 +2093,13 @@ function action(e) {
   return (...t) =>
     new Promise((n, r) => {
       const i = e(...t);
-      q.initTransition();
-      let s = L;
-      s.J.push(i);
+      z.initTransition();
+      let s = M;
+      s.ie.push(i);
       const done = (e, t) => {
         s = currentTransition(s);
-        const o = s.J.indexOf(i);
-        if (o >= 0) s.J.splice(o, 1);
+        const o = s.ie.indexOf(i);
+        if (o >= 0) s.ie.splice(o, 1);
         setActiveTransition(s);
         schedule();
         t ? r(t) : n(e);
@@ -1946,13 +2131,15 @@ function onCleanup(e) {
   return cleanup(e);
 }
 function accessor(e) {
-  return read.bind(null, e);
+  const t = read.bind(null, e);
+  t[j] = e;
+  return t;
 }
 function createSignal(e, t) {
   if (typeof e === "function") {
     const n = computed(e, t);
-    n.de &= ~g;
-    return [accessor(n), setSignal.bind(null, n)];
+    n.ye &= ~y;
+    return [accessor(n), setMemo.bind(null, n)];
   }
   const n = signal(e, t);
   return [accessor(n), setSignal.bind(null, n)];
@@ -2008,7 +2195,7 @@ function resolve(e) {
 function createOptimistic(e, t) {
   if (typeof e === "function") {
     const n = optimisticComputed(e, t);
-    n.de &= ~g;
+    n.ye &= ~y;
     return [accessor(n), setSignal.bind(null, n)];
   }
   const n = optimisticSignal(e, t);
@@ -2016,19 +2203,19 @@ function createOptimistic(e, t) {
 }
 function onSettled(e) {
   const t = getOwner();
-  t && !(t.de & y)
+  t && !(t.ye & S)
     ? createTrackedEffect(() => untrack(e), undefined)
-    : q.enqueue(_, () => {
+    : z.enqueue(v, () => {
         const t = e();
         t?.();
       });
 }
 function unwrap(e) {
-  return e?.[te]?.[ue] ?? e;
+  return e?.[le]?.[he] ?? e;
 }
-function getOverrideValue(e, t, n, r, i) {
-  if (i && r in i) return i[r];
-  return t && r in t ? t[r] : e[r];
+function getOverrideValue(e, t, n, r) {
+  if (r && n in r) return r[n];
+  return t && n in t ? t[n] : e[n];
 }
 function getAllKeys(e, t, n) {
   const r = getKeys(e, t);
@@ -2036,114 +2223,223 @@ function getAllKeys(e, t, n) {
   return Array.from(new Set([...r, ...i]));
 }
 function applyState(e, t, n) {
-  const r = t?.[te];
+  const r = t?.[le];
   if (!r) return;
-  const i = r[ie];
-  const s = r[se];
-  const o = r[oe];
-  let u = r[ue];
-  if (e === i && !s && !o) return;
-  (r[ae] || he).set(e, r[ne]);
-  r[ie] = e;
-  r[se] = undefined;
-  if (Array.isArray(i)) {
-    let t = false;
-    const f = getOverrideValue(i, s, u, "length", o);
-    if (e.length && f && e[0] && n(e[0]) != null) {
-      let l, c, a, d, p, h, y, g;
+  if (r[de] || r[pe]) {
+    applyStateSlow(e, r, n);
+  } else {
+    applyStateFast(e, r, n);
+  }
+}
+function applyStateFast(e, t, n) {
+  const r = t[ae];
+  if (e === r) return;
+  (t[we] || be).set(e, t[fe]);
+  t[ae] = e;
+  if (Array.isArray(r)) {
+    let i = false;
+    const s = r.length;
+    if (e.length && s && e[0] && n(e[0]) != null) {
+      let o, u, l, f, c, a, d, p;
       for (
-        a = 0, d = Math.min(f, e.length);
-        a < d &&
-        ((h = getOverrideValue(i, s, u, a, o)) === e[a] || (h && e[a] && n(h) === n(e[a])));
-        a++
+        l = 0, f = Math.min(s, e.length);
+        l < f && ((a = r[l]) === e[l] || (a && e[l] && n(a) === n(e[l])));
+        l++
       ) {
-        applyState(e[a], wrap(h, r), n);
+        applyState(e[l], wrap(a, t), n);
+      }
+      const h = new Array(e.length),
+        g = new Map();
+      for (
+        f = s - 1, c = e.length - 1;
+        f >= l && c >= l && ((a = r[f]) === e[c] || (a && e[c] && n(a) === n(e[c])));
+        f--, c--
+      ) {
+        h[c] = a;
+      }
+      if (l > c || l > f) {
+        for (u = l; u <= c; u++) {
+          i = true;
+          t[he][u] && setSignal(t[he][u], wrap(e[u], t));
+        }
+        for (; u < e.length; u++) {
+          i = true;
+          const r = wrap(h[u], t);
+          t[he][u] && setSignal(t[he][u], r);
+          applyState(e[u], r, n);
+        }
+        i && t[he][ue] && setSignal(t[he][ue], void 0);
+        s !== e.length && t[he].length && setSignal(t[he].length, e.length);
+        return;
+      }
+      d = new Array(c + 1);
+      for (u = c; u >= l; u--) {
+        a = e[u];
+        p = a ? n(a) : a;
+        o = g.get(p);
+        d[u] = o === undefined ? -1 : o;
+        g.set(p, u);
+      }
+      for (o = l; o <= f; o++) {
+        a = r[o];
+        p = a ? n(a) : a;
+        u = g.get(p);
+        if (u !== undefined && u !== -1) {
+          h[u] = a;
+          u = d[u];
+          g.set(p, u);
+        }
+      }
+      for (u = l; u < e.length; u++) {
+        if (u in h) {
+          const r = wrap(h[u], t);
+          t[he][u] && setSignal(t[he][u], r);
+          applyState(e[u], r, n);
+        } else t[he][u] && setSignal(t[he][u], wrap(e[u], t));
+      }
+      if (l < e.length) i = true;
+    } else if (e.length) {
+      for (let i = 0, s = e.length; i < s; i++) {
+        const s = r[i];
+        isWrappable(s) ? applyState(e[i], wrap(s, t), n) : t[he][i] && setSignal(t[he][i], e[i]);
+      }
+    }
+    if (s !== e.length) {
+      i = true;
+      t[he].length && setSignal(t[he].length, e.length);
+    }
+    i && t[he][ue] && setSignal(t[he][ue], void 0);
+    return;
+  }
+  let i = t[he];
+  if (i) {
+    const s = i[ue];
+    const o = s ? getAllKeys(r, undefined, e) : Object.keys(i);
+    for (let u = 0, l = o.length; u < l; u++) {
+      const l = o[u];
+      const f = i[l];
+      const c = unwrap(r[l]);
+      let a = unwrap(e[l]);
+      if (c === a) continue;
+      if (!c || !isWrappable(c) || !isWrappable(a) || (n(c) != null && n(c) !== n(a))) {
+        s && setSignal(s, void 0);
+        f && setSignal(f, isWrappable(a) ? wrap(a, t) : a);
+      } else applyState(a, wrap(c, t), n);
+    }
+  }
+  if ((i = t[ge])) {
+    const t = Object.keys(i);
+    for (let n = 0, r = t.length; n < r; n++) {
+      const r = t[n];
+      setSignal(i[r], r in e);
+    }
+  }
+}
+function applyStateSlow(e, t, n) {
+  const r = t[ae];
+  const i = t[de];
+  const s = t[pe];
+  let o = t[he];
+  (t[we] || be).set(e, t[fe]);
+  t[ae] = e;
+  t[de] = undefined;
+  if (Array.isArray(r)) {
+    let o = false;
+    const u = getOverrideValue(r, i, "length", s);
+    if (e.length && u && e[0] && n(e[0]) != null) {
+      let l, f, c, a, d, p, h, g;
+      for (
+        c = 0, a = Math.min(u, e.length);
+        c < a && ((p = getOverrideValue(r, i, c, s)) === e[c] || (p && e[c] && n(p) === n(e[c])));
+        c++
+      ) {
+        applyState(e[c], wrap(p, t), n);
       }
       const S = new Array(e.length),
-        w = new Map();
+        y = new Map();
       for (
-        d = f - 1, p = e.length - 1;
-        d >= a &&
-        p >= a &&
-        ((h = getOverrideValue(i, s, u, d, o)) === e[p] || (h && e[p] && n(h) === n(e[p])));
-        d--, p--
+        a = u - 1, d = e.length - 1;
+        a >= c &&
+        d >= c &&
+        ((p = getOverrideValue(r, i, a, s)) === e[d] || (p && e[d] && n(p) === n(e[d])));
+        a--, d--
       ) {
-        S[p] = h;
+        S[d] = p;
       }
-      if (a > p || a > d) {
-        for (c = a; c <= p; c++) {
-          t = true;
-          r[ue][c] && setSignal(r[ue][c], wrap(e[c], r));
+      if (c > d || c > a) {
+        for (f = c; f <= d; f++) {
+          o = true;
+          t[he][f] && setSignal(t[he][f], wrap(e[f], t));
         }
-        for (; c < e.length; c++) {
-          t = true;
-          const i = wrap(S[c], r);
-          r[ue][c] && setSignal(r[ue][c], i);
-          applyState(e[c], i, n);
+        for (; f < e.length; f++) {
+          o = true;
+          const r = wrap(S[f], t);
+          t[he][f] && setSignal(t[he][f], r);
+          applyState(e[f], r, n);
         }
-        t && r[ue][ee] && setSignal(r[ue][ee], void 0);
-        f !== e.length && r[ue].length && setSignal(r[ue].length, e.length);
+        o && t[he][ue] && setSignal(t[he][ue], void 0);
+        u !== e.length && t[he].length && setSignal(t[he].length, e.length);
         return;
       }
-      y = new Array(p + 1);
-      for (c = p; c >= a; c--) {
-        h = e[c];
-        g = h ? n(h) : h;
-        l = w.get(g);
-        y[c] = l === undefined ? -1 : l;
-        w.set(g, c);
-      }
-      for (l = a; l <= d; l++) {
-        h = getOverrideValue(i, s, u, l, o);
-        g = h ? n(h) : h;
-        c = w.get(g);
-        if (c !== undefined && c !== -1) {
-          S[c] = h;
-          c = y[c];
-          w.set(g, c);
+      h = new Array(d + 1);
+      for (f = d; f >= c; f--) {
+        p = e[f];
+        g = p ? n(p) : p;
+        l = y.get(g);
+        h[f] = l === undefined ? -1 : l;
+        y.set(g, f);
+      }
+      for (l = c; l <= a; l++) {
+        p = getOverrideValue(r, i, l, s);
+        g = p ? n(p) : p;
+        f = y.get(g);
+        if (f !== undefined && f !== -1) {
+          S[f] = p;
+          f = h[f];
+          y.set(g, f);
         }
       }
-      for (c = a; c < e.length; c++) {
-        if (c in S) {
-          const t = wrap(S[c], r);
-          r[ue][c] && setSignal(r[ue][c], t);
-          applyState(e[c], t, n);
-        } else r[ue][c] && setSignal(r[ue][c], wrap(e[c], r));
+      for (f = c; f < e.length; f++) {
+        if (f in S) {
+          const r = wrap(S[f], t);
+          t[he][f] && setSignal(t[he][f], r);
+          applyState(e[f], r, n);
+        } else t[he][f] && setSignal(t[he][f], wrap(e[f], t));
       }
-      if (a < e.length) t = true;
+      if (c < e.length) o = true;
     } else if (e.length) {
-      for (let t = 0, f = e.length; t < f; t++) {
-        const f = getOverrideValue(i, s, u, t, o);
-        isWrappable(f) ? applyState(e[t], wrap(f, r), n) : r[ue][t] && setSignal(r[ue][t], e[t]);
+      for (let o = 0, u = e.length; o < u; o++) {
+        const u = getOverrideValue(r, i, o, s);
+        isWrappable(u) ? applyState(e[o], wrap(u, t), n) : t[he][o] && setSignal(t[he][o], e[o]);
       }
     }
-    if (f !== e.length) {
-      t = true;
-      r[ue].length && setSignal(r[ue].length, e.length);
+    if (u !== e.length) {
+      o = true;
+      t[he].length && setSignal(t[he].length, e.length);
     }
-    t && r[ue][ee] && setSignal(r[ue][ee], void 0);
+    o && t[he][ue] && setSignal(t[he][ue], void 0);
     return;
   }
-  if (u) {
-    const t = u[ee];
-    const f = t ? getAllKeys(i, s, 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(i, s, u, c, o));
+  if (o) {
+    const u = o[ue];
+    const l = u ? getAllKeys(r, i, e) : Object.keys(o);
+    for (let f = 0, c = l.length; f < c; f++) {
+      const c = l[f];
+      const a = o[c];
+      const d = unwrap(getOverrideValue(r, i, c, s));
       let p = unwrap(e[c]);
       if (d === p) continue;
       if (!d || !isWrappable(d) || !isWrappable(p) || (n(d) != null && n(d) !== n(p))) {
-        t && setSignal(t, void 0);
-        a && setSignal(a, isWrappable(p) ? wrap(p, r) : p);
-      } else applyState(p, wrap(d, r), n);
+        u && setSignal(u, void 0);
+        a && setSignal(a, isWrappable(p) ? wrap(p, t) : p);
+      } else applyState(p, wrap(d, t), n);
     }
   }
-  if ((u = r[fe])) {
-    const t = Object.keys(u);
+  if ((o = t[ge])) {
+    const t = Object.keys(o);
     for (let n = 0, r = t.length; n < r; n++) {
       const r = t[n];
-      setSignal(u[r], r in e);
+      setSignal(o[r], r in e);
     }
   }
 }
@@ -2161,9 +2457,9 @@ function createProjectionInternal(e, t, n) {
   let r;
   const i = new WeakMap();
   const wrapper = e => {
-    e[ce] = wrapProjection;
-    e[ae] = i;
-    Object.defineProperty(e, de, {
+    e[ye] = wrapProjection;
+    e[we] = i;
+    Object.defineProperty(e, me, {
       get() {
         return r;
       },
@@ -2172,8 +2468,8 @@ function createProjectionInternal(e, t, n) {
   };
   const wrapProjection = e => {
     if (i.has(e)) return i.get(e);
-    if (e[te]?.[ce] === wrapProjection) return e;
-    const t = createStoreProxy(e, Se, wrapper);
+    if (e[le]?.[ye] === wrapProjection) return e;
+    const t = createStoreProxy(e, Pe, wrapper);
     i.set(e, t);
     return t;
   };
@@ -2182,7 +2478,7 @@ function createProjectionInternal(e, t, n) {
     if (!r) r = getOwner();
     runProjectionComputed(s, e, n?.key || "id");
   }, undefined);
-  r.de &= ~g;
+  r.ye &= ~y;
   return { store: s, node: r };
 }
 function createProjection(e, t, n) {
@@ -2194,7 +2490,7 @@ function runProjectionComputed(e, t, n, r) {
   let o;
   const u = new Proxy(
     e,
-    createWriteTraps(() => !s || i.Ce === o)
+    createWriteTraps(() => !s || i.ke === o)
   );
   storeSetter(u, u => {
     o = t(u);
@@ -2261,59 +2557,56 @@ function createWriteTraps(e) {
   };
   return t;
 }
-const ee = Symbol(0),
-  te = Symbol(0),
-  ne = Symbol(0),
-  re = Symbol(0);
-const ie = "v",
-  se = "o",
-  oe = "x",
-  ue = "n",
-  fe = "h",
-  le = "c",
-  ce = "w",
-  ae = "l",
-  de = "f",
-  pe = "p";
-function createStoreProxy(e, t = Se, n) {
+const ue = Symbol(0),
+  le = Symbol(0),
+  fe = Symbol(0),
+  ce = Symbol(0);
+const ae = "v",
+  de = "o",
+  pe = "x",
+  he = "n",
+  ge = "h",
+  Se = "c",
+  ye = "w",
+  we = "l",
+  me = "f",
+  _e = "p";
+function createStoreProxy(e, t = Pe, n) {
   let r;
   if (Array.isArray(e)) {
     r = [];
     r.v = e;
-  } else r = { v: e };
-  r[le] = hasCustomPrototype(unwrapStoreValue(e));
+  } else {
+    r = { v: e };
+    const t = e?.[le]?.[ae] ?? e;
+    const n = Object.getPrototypeOf(t);
+    if (n !== null && n !== Object.prototype) {
+      r[Se] = true;
+    }
+  }
   n && n(r);
-  return (r[ne] = new Proxy(r, t));
+  return (r[fe] = new Proxy(r, t));
 }
-const he = new WeakMap();
+const be = new WeakMap();
 function wrap(e, t) {
-  if (t?.[ce]) return t[ce](e, t);
-  let n = e[ne] || he.get(e);
-  if (!n) he.set(e, (n = createStoreProxy(e)));
+  if (t?.[ye]) return t[ye](e, t);
+  let n = e[fe] || be.get(e);
+  if (!n) be.set(e, (n = createStoreProxy(e)));
   return n;
 }
 function isWrappable(e) {
-  return (
-    e != null &&
-    typeof e === "object" &&
-    !Object.isFrozen(e) &&
-    !(typeof Node !== "undefined" && e instanceof Node)
-  );
+  if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+  return typeof Node === "undefined" || !(e instanceof Node);
 }
-let ye = false;
+let Oe = false;
 function setWriteOverride(e) {
-  ye = e;
+  Oe = e;
 }
 function writeOnly(e) {
-  return ye || !!ge?.has(e);
+  return Oe || !!ve?.has(e);
 }
 function unwrapStoreValue(e) {
-  return e?.[te]?.[ie] ?? e;
-}
-function hasCustomPrototype(e) {
-  if (Array.isArray(e)) return false;
-  const t = Object.getPrototypeOf(e);
-  return t !== null && t !== Object.prototype;
+  return e?.[le]?.[ae] ?? e;
 }
 function hasInheritedAccessor(e, t) {
   let n = Object.getPrototypeOf(e);
@@ -2342,17 +2635,17 @@ function getNode(e, t, n, r, i = isEqual, s, o) {
     r
   );
   if (s) {
-    u.H = v;
+    u.G = x;
   }
   if (o && t in o) {
     const e = o[t];
-    u.ye = e === undefined ? x : e;
-    $?.add(u);
+    u._e = e === undefined ? C : e;
+    se?.add(u);
   }
   return (e[t] = u);
 }
-function trackSelf(e, t = ee) {
-  getObserver() && read(getNode(getNodes(e, ue), t, undefined, e[de], false, e[pe]));
+function trackSelf(e, t = ue) {
+  getObserver() && read(getNode(getNodes(e, he), t, undefined, e[me], false, e[_e]));
 }
 function getKeys(e, t, n = true) {
   const r = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -2360,102 +2653,117 @@ function getKeys(e, t, n = true) {
   const i = new Set(r);
   const s = Reflect.ownKeys(t);
   for (const e of s) {
-    if (t[e] !== re) i.add(e);
+    if (t[e] !== ce) i.add(e);
     else i.delete(e);
   }
   return Array.from(i);
 }
 function getPropertyDescriptor(e, t, n) {
   if (t && n in t) {
-    if (t[n] === re) return void 0;
+    if (t[n] === ce) return void 0;
     const r = Reflect.getOwnPropertyDescriptor(t, n);
     if (r?.get || r?.set || !(n in e)) return r;
   }
   return Reflect.getOwnPropertyDescriptor(e, n);
 }
 function prepareStoreWrite(e, t, n) {
-  if (e[pe]) {
-    const t = e[de];
-    if (t?.X) {
-      q.initTransition(t.X);
+  if (e[_e]) {
+    const t = e[me];
+    if (t?.V) {
+      z.initTransition(t.V);
     }
   }
-  const r = e[ie];
+  const r = e[ae];
   const i = r[n];
-  if (Z && typeof n !== "symbol" && !((e[de]?.ge ?? 0) & S)) {
-    if (!e[P]) {
-      e[P] = Object.create(null);
-      $?.add(e);
+  if (ie && typeof n !== "symbol" && !((e[me]?.be ?? 0) & m)) {
+    if (!e[N]) {
+      e[N] = Object.create(null);
+      se?.add(e);
     }
-    if (!(n in e[P])) {
-      e[P][n] = i;
+    if (!(n in e[N])) {
+      e[N][n] = i;
     }
   }
-  const s = e[pe] && !T;
-  const o = s ? oe : se;
+  const s = e[_e] && !K;
+  const o = s ? pe : de;
   if (s) trackOptimisticStore(t);
   return { base: i, overrideKey: o, state: r };
 }
 function upsertStoreNode(e, t, n, r, i) {
   if (t[n]) return t[n];
   const s = isWrappable(r) ? wrap(r, e) : r;
-  const o = getNode(t, n, s, e[de], isEqual, e[pe], i);
+  const o = getNode(t, n, s, e[me], isEqual, e[_e], i);
   registerTransientStoreNode(o);
   return o;
 }
 function notifyStoreProperty(e, t, n, r, i, s) {
-  const o = T || e[pe];
+  const o = K || e[_e];
   const u = n !== "delete";
-  const f = e[fe]?.[t];
-  if (f) {
-    setSignal(f, u);
+  const l = e[ge]?.[t];
+  if (l) {
+    setSignal(l, u);
   } else if (!o && n !== "invalidate" && s !== u) {
-    const n = upsertStoreNode(e, getNodes(e, fe), t, s);
+    const n = upsertStoreNode(e, getNodes(e, ge), t, s);
     setSignal(n, u);
   }
-  const l = getNodes(e, ue);
+  const f = getNodes(e, he);
   if (n === "set") {
-    if (l[t]) {
-      setSignal(l[t], () => (isWrappable(r) ? wrap(r, e) : r));
+    if (f[t]) {
+      setSignal(f[t], () => (isWrappable(r) ? wrap(r, e) : r));
     } else if (!o) {
-      const n = upsertStoreNode(e, l, t, i, e[P]);
+      const n = upsertStoreNode(e, f, t, i, e[N]);
       setSignal(n, () => (isWrappable(r) ? wrap(r, e) : r));
     }
   } else if (n === "invalidate") {
-    if (l[t]) {
-      setSignal(l[t], {});
-      delete l[t];
+    if (f[t]) {
+      setSignal(f[t], {});
+      delete f[t];
     }
   } else {
-    if (l[t]) {
-      setSignal(l[t], undefined);
+    if (f[t]) {
+      setSignal(f[t], undefined);
     } else if (!o) {
-      const n = upsertStoreNode(e, l, t, i, e[P]);
+      const n = upsertStoreNode(e, f, t, i, e[N]);
       setSignal(n, undefined);
     }
   }
-  l[ee] && setSignal(l[ee], undefined);
+  f[ue] && setSignal(f[ue], undefined);
 }
-let ge = null;
-const Se = {
+let ve = null;
+const Pe = {
   get(e, t, n) {
-    if (t === te) return e;
-    if (t === ne) return n;
-    if (t === E) return e[de];
-    if (t === ee) {
+    if (t === le) return e;
+    if (t === fe) return n;
+    if (t === j) return e[me];
+    if (t === ue) {
       trackSelf(e);
       return n;
     }
-    const r = getNodes(e, ue);
+    const r = getNodes(e, he);
     const i = r[t];
-    const s = e[oe] && t in e[oe];
-    const o = s || (e[se] && t in e[se]);
-    const u = !!e[ie][te];
-    const f = s ? e[oe] : e[se] && t in e[se] ? e[se] : e[ie];
+    const s = e[ae];
+    if (
+      !i &&
+      !e[de] &&
+      !e[pe] &&
+      !e[Se] &&
+      !e[_e] &&
+      !e[N] &&
+      !s[le] &&
+      !(t in s) &&
+      getObserver() &&
+      !writeOnly(n)
+    ) {
+      return read(getNode(r, t, undefined, e[me]));
+    }
+    const o = e[pe] && t in e[pe];
+    const u = o || (e[de] && t in e[de]);
+    const l = !!e[ae][le];
+    const f = o ? e[pe] : e[de] && t in e[de] ? e[de] : e[ae];
     if (!i) {
       const r = Object.getOwnPropertyDescriptor(f, t);
       if (r && r.get) return r.get.call(n);
-      if (!r && !o && e[le]) {
+      if (!r && !u && e[Se]) {
         const e = unwrapStoreValue(f);
         if (hasInheritedAccessor(e, t)) {
           return Reflect.get(f, t, n);
@@ -2464,76 +2772,76 @@ const Se = {
     }
     if (writeOnly(n)) {
       let n =
-        i && (o || !u) ? (i.H !== undefined && i.H !== v ? i.H : i.T !== v ? i.T : i.ne) : f[t];
-      n === re && (n = undefined);
+        i && (u || !l) ? (i.G !== undefined && i.G !== x ? i.G : i.Y !== x ? i.Y : i.ue) : f[t];
+      n === ce && (n = undefined);
       if (!isWrappable(n)) return n;
       const r = wrap(n, e);
-      ge?.add(r);
+      ve?.add(r);
       return r;
     }
-    let l = i ? (o || !u ? read(r[t]) : (read(r[t]), f[t])) : f[t];
-    l === re && (l = undefined);
+    let c = i ? (u || !l ? read(r[t]) : (read(r[t]), f[t])) : f[t];
+    c === ce && (c = undefined);
     if (!i) {
-      if (!o && typeof l === "function" && !f.hasOwnProperty(t)) {
+      if (!u && typeof c === "function" && !f.hasOwnProperty(t)) {
         let t;
-        return !Array.isArray(e[ie]) && (t = Object.getPrototypeOf(e[ie])) && t !== Object.prototype
-          ? l.bind(f)
-          : l;
+        return !Array.isArray(e[ae]) && (t = Object.getPrototypeOf(e[ae])) && t !== Object.prototype
+          ? c.bind(f)
+          : c;
       } else if (getObserver()) {
-        return read(getNode(r, t, isWrappable(l) ? wrap(l, e) : l, e[de], isEqual, e[pe], e[P]));
+        return read(getNode(r, t, isWrappable(c) ? wrap(c, e) : c, e[me], isEqual, e[_e], e[N]));
       }
     }
-    return isWrappable(l) ? wrap(l, e) : l;
+    return isWrappable(c) ? wrap(c, e) : c;
   },
   has(e, t) {
-    if (t === ne || t === ee || t === "__proto__") return true;
+    if (t === fe || t === ue || t === "__proto__") return true;
     const n =
-      e[oe] && t in e[oe] ? e[oe][t] !== re : e[se] && t in e[se] ? e[se][t] !== re : t in e[ie];
-    if (writeOnly(e[ne])) return n;
-    const r = getNodes(e, fe);
+      e[pe] && t in e[pe] ? e[pe][t] !== ce : e[de] && t in e[de] ? e[de][t] !== ce : t in e[ae];
+    if (writeOnly(e[fe])) return n;
+    const r = getNodes(e, ge);
     if (r[t]) return read(r[t]);
     if (getObserver()) {
-      return read(getNode(r, t, n, e[de], isEqual, e[pe]));
+      return read(getNode(r, t, n, e[me], isEqual, e[_e]));
     }
     return n;
   },
   set(e, t, n) {
-    const r = e[ne];
+    const r = e[fe];
     if (writeOnly(r)) {
       untrack(() => {
         const { base: i, overrideKey: s, state: o } = prepareStoreWrite(e, r, t);
-        const u = e[oe] && t in e[oe] ? e[oe][t] : e[se] && t in e[se] ? e[se][t] : i;
-        const f =
-          e[oe] && t in e[oe]
-            ? e[oe][t] !== re
-            : e[se] && t in e[se]
-              ? e[se][t] !== re
-              : t in e[ie];
-        const l = unwrapStoreValue(n);
+        const u = e[pe] && t in e[pe] ? e[pe][t] : e[de] && t in e[de] ? e[de][t] : i;
+        const l =
+          e[pe] && t in e[pe]
+            ? e[pe][t] !== ce
+            : e[de] && t in e[de]
+              ? e[de][t] !== ce
+              : t in e[ae];
+        const f = unwrapStoreValue(n);
         const c = Array.isArray(o) && t !== "length";
         const a = c ? parseInt(t) + 1 : 0;
         const d =
           c &&
-          (e[oe] && "length" in e[oe]
-            ? e[oe].length
-            : e[se] && "length" in e[se]
-              ? e[se].length
+          (e[pe] && "length" in e[pe]
+            ? e[pe].length
+            : e[de] && "length" in e[de]
+              ? e[de].length
               : o.length);
         const p = c && a > d ? a : undefined;
-        if (u === l && p === undefined) return true;
-        if (l !== undefined && l === i && p === undefined) delete e[s]?.[t];
+        if (u === f && p === undefined) return true;
+        if (f !== undefined && f === i && p === undefined) delete e[s]?.[t];
         else {
           const n = e[s] || (e[s] = Object.create(null));
-          n[t] = l;
+          n[t] = f;
           if (p !== undefined) n.length = p;
         }
-        notifyStoreProperty(e, t, "set", l, u, f);
+        notifyStoreProperty(e, t, "set", f, u, l);
         if (Array.isArray(o) && t !== "length" && p !== undefined) {
-          const t = getNodes(e, ue);
+          const t = getNodes(e, he);
           if (t.length) {
             setSignal(t.length, p);
-          } else if (!T && !e[pe]) {
-            const n = upsertStoreNode(e, t, "length", d, e[P]);
+          } else if (!K && !e[_e]) {
+            const n = upsertStoreNode(e, t, "length", d, e[N]);
             setSignal(n, p);
           }
         }
@@ -2543,7 +2851,7 @@ const Se = {
     return true;
   },
   defineProperty(e, t, n) {
-    const r = e[ne];
+    const r = e[fe];
     if (writeOnly(r)) {
       untrack(() => {
         const { base: i, overrideKey: s } = prepareStoreWrite(e, r, t);
@@ -2556,16 +2864,16 @@ const Se = {
     return true;
   },
   deleteProperty(e, t) {
-    const n = e[oe]?.[t] === re;
-    const r = e[se]?.[t] === re;
-    if (writeOnly(e[ne]) && !n && !r) {
+    const n = e[pe]?.[t] === ce;
+    const r = e[de]?.[t] === ce;
+    if (writeOnly(e[fe]) && !n && !r) {
       untrack(() => {
-        const n = e[pe] && !T;
-        const r = n ? oe : se;
-        if (n) trackOptimisticStore(e[ne]);
-        const i = e[oe] && t in e[oe] ? e[oe][t] : e[se] && t in e[se] ? e[se][t] : e[ie][t];
-        if (t in e[ie] || (e[se] && t in e[se])) {
-          (e[r] || (e[r] = Object.create(null)))[t] = re;
+        const n = e[_e] && !K;
+        const r = n ? pe : de;
+        if (n) trackOptimisticStore(e[fe]);
+        const i = e[pe] && t in e[pe] ? e[pe][t] : e[de] && t in e[de] ? e[de][t] : e[ae][t];
+        if (t in e[ae] || (e[de] && t in e[de])) {
+          (e[r] || (e[r] = Object.create(null)))[t] = ce;
         } else if (e[r] && t in e[r]) {
           delete e[r][t];
         } else return true;
@@ -2576,11 +2884,11 @@ const Se = {
   },
   ownKeys(e) {
     trackSelf(e);
-    let t = getKeys(e[ie], e[se], false);
-    if (e[oe]) {
+    let t = getKeys(e[ae], e[de], false);
+    if (e[pe]) {
       const n = new Set(t);
-      for (const t of Reflect.ownKeys(e[oe])) {
-        if (e[oe][t] !== re) n.add(t);
+      for (const t of Reflect.ownKeys(e[pe])) {
+        if (e[pe][t] !== ce) n.add(t);
         else n.delete(t);
       }
       t = Array.from(n);
@@ -2588,27 +2896,27 @@ const Se = {
     return t;
   },
   getOwnPropertyDescriptor(e, t) {
-    if (t === ne) return { value: e[ne], writable: true, configurable: true };
-    if (e[oe] && t in e[oe]) {
-      if (e[oe][t] === re) return undefined;
-      const n = Reflect.getOwnPropertyDescriptor(e[oe], t);
-      if (n?.get || n?.set || !(t in e[ie])) return n;
-      const r = getPropertyDescriptor(e[ie], e[se], t);
+    if (t === fe) return { value: e[fe], writable: true, configurable: true };
+    if (e[pe] && t in e[pe]) {
+      if (e[pe][t] === ce) return undefined;
+      const n = Reflect.getOwnPropertyDescriptor(e[pe], t);
+      if (n?.get || n?.set || !(t in e[ae])) return n;
+      const r = getPropertyDescriptor(e[ae], e[de], t);
       if (r) {
-        return { ...r, value: e[oe][t] };
+        return { ...r, value: e[pe][t] };
       }
-      return { value: e[oe][t], writable: true, enumerable: true, configurable: true };
+      return { value: e[pe][t], writable: true, enumerable: true, configurable: true };
     }
-    return getPropertyDescriptor(e[ie], e[se], t);
+    return getPropertyDescriptor(e[ae], e[de], t);
   },
   getPrototypeOf(e) {
-    return Object.getPrototypeOf(e[ie]);
+    return Object.getPrototypeOf(e[ae]);
   }
 };
 function storeSetter(e, t) {
-  const n = ge;
-  ge = new Set();
-  ge.add(e);
+  const n = ve;
+  ve = new Set();
+  ve.add(e);
   try {
     const n = t(e);
     if (n !== e && n !== undefined) {
@@ -2624,17 +2932,20 @@ function storeSetter(e, t) {
       }
     }
   } finally {
-    ge.clear();
-    ge = n;
+    ve.clear();
+    ve = n;
   }
 }
 function createStore(e, t, n) {
   const r = typeof e === "function",
     i = r ? createProjectionInternal(e, t, n).store : wrap(e);
-  return [i, e => storeSetter(i, e)];
+  return [
+    i,
+    r ? e => (storeSetter(i, e), suppressComputedRecompute(i[j])) : e => storeSetter(i, e)
+  ];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.ce ||= clearOptimisticStore;
+  GlobalQueue.ge ||= clearOptimisticStore;
   const r = typeof e === "function";
   const i = r ? t : e;
   const s = r ? e : undefined;
@@ -2642,39 +2953,39 @@ function createOptimisticStore(e, t, n) {
   return [o, e => storeSetter(o, e)];
 }
 function clearOptimisticStore(e) {
-  const t = e[te];
-  if (!t || !t[oe]) return;
-  const n = t[oe];
-  const r = t[ue];
+  const t = e[le];
+  if (!t || !t[pe]) return;
+  const n = t[pe];
+  const r = t[he];
   setProjectionWriteActive(true);
   try {
     if (r) {
       for (const e of Reflect.ownKeys(n)) {
         if (r[e]) {
-          r[e].te = undefined;
-          const n = t[se] && e in t[se] ? t[se][e] : t[ie][e];
-          const i = n === re ? undefined : n;
+          r[e].H = undefined;
+          const n = t[de] && e in t[de] ? t[de][e] : t[ae][e];
+          const i = n === ce ? undefined : n;
           setSignal(r[e], isWrappable(i) ? wrap(i, t) : i);
         }
       }
-      if (r[ee]) {
-        r[ee].te = undefined;
-        setSignal(r[ee], undefined);
+      if (r[ue]) {
+        r[ue].H = undefined;
+        setSignal(r[ue], undefined);
       }
     }
   } finally {
     setProjectionWriteActive(false);
   }
-  delete t[oe];
+  delete t[pe];
 }
 function createOptimisticProjectionInternal(e, t, n) {
   let r;
   const i = new WeakMap();
   const wrapper = e => {
-    e[ce] = wrapProjection;
-    e[ae] = i;
-    e[pe] = true;
-    Object.defineProperty(e, de, {
+    e[ye] = wrapProjection;
+    e[we] = i;
+    e[_e] = true;
+    Object.defineProperty(e, me, {
       get() {
         return r;
       },
@@ -2683,8 +2994,8 @@ function createOptimisticProjectionInternal(e, t, n) {
   };
   const wrapProjection = e => {
     if (i.has(e)) return i.get(e);
-    if (e[te]?.[ce] === wrapProjection) return e;
-    const t = createStoreProxy(e, Se, wrapper);
+    if (e[le]?.[ye] === wrapProjection) return e;
+    const t = createStoreProxy(e, Pe, wrapper);
     i.set(e, t);
     return t;
   };
@@ -2706,11 +3017,11 @@ function createOptimisticProjectionInternal(e, t, n) {
         setProjectionWriteActive(false);
       }
     }, undefined);
-    r.de &= ~g;
+    r.ye &= ~y;
   }
   return { store: s, node: r };
 }
-const we = Symbol(0);
+const xe = Symbol(0);
 function isPrototypePollutionKey(e) {
   return e === "__proto__" || e === "constructor" || e === "prototype";
 }
@@ -2758,7 +3069,7 @@ function updatePath(e, t, n = 0) {
     if (s === i) return;
   }
   if (r === undefined && s == undefined) return;
-  if (s === we) {
+  if (s === xe) {
     delete e[r];
   } else if (r === undefined || (isWrappable(i) && isWrappable(s) && !Array.isArray(s))) {
     const t = r !== undefined ? e[r] : e;
@@ -2774,26 +3085,26 @@ function updatePath(e, t, n = 0) {
     e[r] = s;
   }
 }
-const me = Object.assign(
+const Ce = Object.assign(
   function storePath(...e) {
     return t => {
       updatePath(t, e);
     };
   },
-  { DELETE: we }
+  { DELETE: xe }
 );
 function snapshotImpl(e, t, n, r) {
-  let i, s, o, u, f, l;
+  let i, s, o, u, l, f;
   if (!isWrappable(e)) return e;
   if (n && n.has(e)) return n.get(e);
   if (!n) n = new Map();
-  if ((i = e[te] || r?.get(e)?.[te])) {
-    if (t) trackSelf(i, ee);
-    o = i[se];
-    s = Array.isArray(i[ie]);
-    n.set(e, o ? (u = s ? [] : Object.create(Object.getPrototypeOf(i[ie]))) : i[ie]);
-    e = i[ie];
-    r = he;
+  if ((i = e[le] || r?.get(e)?.[le])) {
+    if (t) trackSelf(i, ue);
+    o = i[de];
+    s = Array.isArray(i[ae]);
+    n.set(e, o ? (u = s ? [] : Object.create(Object.getPrototypeOf(i[ae]))) : i[ae]);
+    e = i[ae];
+    r = be;
   } else {
     s = Array.isArray(e);
     n.set(e, e);
@@ -2801,12 +3112,12 @@ function snapshotImpl(e, t, n, r) {
   if (s) {
     const s = o?.length || e.length;
     for (let c = 0; c < s; c++) {
-      l = o && c in o ? o[c] : e[c];
-      if (l === re) continue;
-      if (t && isWrappable(l)) wrap(l, i);
-      if ((f = snapshotImpl(l, t, n, r)) !== l || u) {
+      f = o && c in o ? o[c] : e[c];
+      if (f === ce) continue;
+      if (t && isWrappable(f)) wrap(f, i);
+      if ((l = snapshotImpl(f, t, n, r)) !== f || u) {
         if (!u) n.set(e, (u = [...e]));
-        u[c] = f;
+        u[c] = l;
       }
     }
   } else {
@@ -2815,14 +3126,14 @@ function snapshotImpl(e, t, n, r) {
       let a = s[c];
       const d = getPropertyDescriptor(e, o, a);
       if (d.get) continue;
-      l = o && a in o ? o[a] : e[a];
-      if (t && isWrappable(l)) wrap(l, i);
-      if ((f = snapshotImpl(l, t, n, r)) !== e[a] || u) {
+      f = o && a in o ? o[a] : e[a];
+      if (t && isWrappable(f)) wrap(f, i);
+      if ((l = snapshotImpl(f, t, n, r)) !== e[a] || u) {
         if (!u) {
           u = Object.create(Object.getPrototypeOf(e));
           Object.assign(u, e);
         }
-        u[a] = f;
+        u[a] = l;
       }
     }
   }
@@ -2837,13 +3148,13 @@ function deep(e) {
 function trueFn() {
   return true;
 }
-const be = {
+const Ne = {
   get(e, t, n) {
-    if (t === ne) return n;
+    if (t === fe) return n;
     return e.get(t);
   },
   has(e, t) {
-    if (t === ne) return true;
+    if (t === fe) return true;
     return e.has(t);
   },
   set: trueFn,
@@ -2866,23 +3177,24 @@ const be = {
 function resolveSource(e) {
   return !(e = typeof e === "function" ? e() : e) ? {} : e;
 }
-const _e = Symbol(0);
+const Ee = 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 && ne in i);
-    const s = !!i && i[_e];
-    if (s) n.push(...s);
-    else n.push(typeof i === "function" ? ((t = true), createMemo(i)) : i);
+    t = t || (!!i && fe in i);
+    const s = !!i && i[Ee];
+    if (s) {
+      for (let e = 0; e < s.length; e++) n.push(s[e]);
+    } else n.push(typeof i === "function" ? ((t = true), createMemo(i)) : i);
   }
-  if (k && t) {
+  if (E && t) {
     return new Proxy(
       {
         get(e) {
-          if (e === _e) return n;
+          if (e === Ee) return n;
           for (let t = n.length - 1; t >= 0; t--) {
             const r = resolveSource(n[t]);
             if (e in r) return r[e];
@@ -2895,12 +3207,15 @@ function merge(...e) {
           return false;
         },
         keys() {
-          const e = [];
-          for (let t = 0; t < n.length; t++) e.push(...Object.keys(resolveSource(n[t])));
-          return [...new Set(e)];
+          const e = new Set();
+          for (let t = 0; t < n.length; t++) {
+            const r = Object.keys(resolveSource(n[t]));
+            for (let t = 0; t < r.length; t++) e.add(r[t]);
+          }
+          return [...e];
         }
       },
-      be
+      Ne
     );
   }
   const r = Object.create(null);
@@ -2932,325 +3247,332 @@ function merge(...e) {
     if (n.get) Object.defineProperty(o, t, n);
     else o[t] = n.value;
   }
-  o[_e] = n;
+  o[Ee] = n;
   return o;
 }
 function omit(e, ...t) {
-  const n = new Set(t);
-  if (k && ne in e) {
+  if (E && fe in e) {
     return new Proxy(
       {
-        get(t) {
-          return n.has(t) ? undefined : e[t];
+        get(n) {
+          return t.includes(n) ? undefined : e[n];
         },
-        has(t) {
-          return !n.has(t) && t in e;
+        has(n) {
+          return !t.includes(n) && n in e;
         },
         keys() {
-          return Object.keys(e).filter(e => !n.has(e));
+          return Object.keys(e).filter(e => !t.includes(e));
         }
       },
-      be
+      Ne
     );
   }
-  const r = {};
-  for (const t of Object.getOwnPropertyNames(e)) {
-    if (!n.has(t)) {
-      const n = Object.getOwnPropertyDescriptor(e, t);
-      !n.get && !n.set && n.enumerable && n.writable && n.configurable
-        ? (r[t] = n.value)
-        : Object.defineProperty(r, t, n);
+  const n = {};
+  const r = Object.getOwnPropertyNames(e);
+  const i = t.length > 4 && r.length > t.length ? new Set(t) : undefined;
+  for (const s of r) {
+    if (i ? !i.has(s) : !t.includes(s)) {
+      const t = Object.getOwnPropertyDescriptor(e, s);
+      !t.get && !t.set && t.enumerable && t.writable && t.configurable
+        ? (n[s] = t.value)
+        : Object.defineProperty(n, s, t);
     }
   }
-  return r;
+  return n;
 }
 function mapArray(e, t, n) {
   const r = typeof n?.keyed === "function" ? n.keyed : undefined;
   const i = t.length > 1;
   const s = t;
   const o = {
-    Be: createOwner(),
-    Ke: 0,
-    Ge: e,
-    ze: [],
-    Ue: s,
-    Je: [],
-    Xe: [],
-    Ye: r,
-    Ze: r || n?.keyed === false ? [] : undefined,
-    $e: i ? [] : undefined,
-    et: n?.fallback
+    Ue: createOwner(),
+    Je: 0,
+    Xe: e,
+    Ye: [],
+    Ze: s,
+    $e: [],
+    et: [],
+    tt: r,
+    nt: r || n?.keyed === false ? [] : undefined,
+    rt: i && n?.keyed !== false ? [] : undefined,
+    it: n?.keyed === false,
+    st: n?.fallback
   };
   const u = computed(updateKeyedMap.bind(o));
-  o.Be.u = u;
-  u.de &= ~g;
+  o.Ue.u = u;
+  u.ye &= ~y;
   return accessor(u);
 }
-const Oe = { ownedWrite: true };
+const ke = { ownedWrite: true };
 function updateKeyedMap() {
-  const e = this.Ge() || [],
+  const e = this.Xe() || [],
     t = e.length;
-  e[ee];
-  runWithOwner(this.Be, () => {
+  e[ue];
+  runWithOwner(this.Ue, () => {
     let n,
       r,
-      i = this.Ze
-        ? () => {
-            this.Ze[r] = signal(e[r], Oe);
-            this.$e && (this.$e[r] = signal(r, Oe));
-            return this.Ue(accessor(this.Ze[r]), this.$e ? accessor(this.$e[r]) : undefined);
-          }
-        : this.$e
+      i = this.nt
+        ? this.it
+          ? () => {
+              this.nt[r] = signal(e[r], ke);
+              return this.Ze(accessor(this.nt[r]), r);
+            }
+          : () => {
+              this.nt[r] = signal(e[r], ke);
+              this.rt && (this.rt[r] = signal(r, ke));
+              return this.Ze(accessor(this.nt[r]), this.rt ? accessor(this.rt[r]) : undefined);
+            }
+        : this.rt
           ? () => {
               const t = e[r];
-              this.$e[r] = signal(r, Oe);
-              return this.Ue(() => t, accessor(this.$e[r]));
+              this.rt[r] = signal(r, ke);
+              return this.Ze(t, accessor(this.rt[r]));
             }
           : () => {
               const t = e[r];
-              return this.Ue(() => t);
+              return this.Ze(t);
             };
     if (t === 0) {
-      if (this.Ke !== 0) {
-        this.Be.dispose(false);
-        this.Xe = [];
-        this.ze = [];
-        this.Je = [];
-        this.Ke = 0;
-        this.Ze && (this.Ze = []);
-        this.$e && (this.$e = []);
-      }
-      if (this.et && !this.Je[0]) {
-        this.Je[0] = runWithOwner((this.Xe[0] = createOwner()), this.et);
-      }
-    } else if (this.Ke === 0) {
-      if (this.Xe[0]) this.Xe[0].dispose();
-      this.Je = new Array(t);
+      if (this.Je !== 0) {
+        this.Ue.dispose(false);
+        this.et = [];
+        this.Ye = [];
+        this.$e = [];
+        this.Je = 0;
+        this.nt && (this.nt = []);
+        this.rt && (this.rt = []);
+      }
+      if (this.st && !this.$e[0]) {
+        this.$e[0] = runWithOwner((this.et[0] = createOwner()), this.st);
+      }
+    } else if (this.Je === 0) {
+      if (this.et[0]) this.et[0].dispose();
+      this.$e = new Array(t);
       for (r = 0; r < t; r++) {
-        this.ze[r] = e[r];
-        this.Je[r] = runWithOwner((this.Xe[r] = createOwner()), i);
+        this.Ye[r] = e[r];
+        this.$e[r] = runWithOwner((this.et[r] = createOwner()), i);
       }
-      this.Ke = t;
+      this.Je = t;
     } else {
       let s,
         o,
         u,
-        f,
         l,
+        f,
         c,
         a,
         d = new Array(t),
         p = new Array(t),
-        h = this.Ze ? new Array(t) : undefined,
-        y = this.$e ? new Array(t) : undefined;
+        h = this.nt ? new Array(t) : undefined,
+        g = this.rt ? new Array(t) : undefined;
       for (
-        s = 0, o = Math.min(this.Ke, t);
-        s < o && (this.ze[s] === e[s] || (this.Ze && compare(this.Ye, this.ze[s], e[s])));
+        s = 0, o = Math.min(this.Je, t);
+        s < o && (this.Ye[s] === e[s] || (this.nt && compare(this.tt, this.Ye[s], e[s])));
         s++
       ) {
-        if (this.Ze) setSignal(this.Ze[s], e[s]);
+        if (this.nt) setSignal(this.nt[s], e[s]);
       }
       for (
-        o = this.Ke - 1, u = t - 1;
+        o = this.Je - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.ze[o] === e[u] || (this.Ze && compare(this.Ye, this.ze[o], e[u])));
+        (this.Ye[o] === e[u] || (this.nt && compare(this.tt, this.Ye[o], e[u])));
         o--, u--
       ) {
-        d[u] = this.Je[o];
-        p[u] = this.Xe[o];
-        h && (h[u] = this.Ze[o]);
-        y && (y[u] = this.$e[o]);
+        d[u] = this.$e[o];
+        p[u] = this.et[o];
+        h && (h[u] = this.nt[o]);
+        g && (g[u] = this.rt[o]);
       }
       c = new Map();
       a = new Array(u + 1);
       for (r = u; r >= s; r--) {
-        f = e[r];
-        l = this.Ye ? this.Ye(f) : f;
-        n = c.get(l);
+        l = e[r];
+        f = this.tt ? this.tt(l) : l;
+        n = c.get(f);
         a[r] = n === undefined ? -1 : n;
-        c.set(l, r);
+        c.set(f, r);
       }
       for (n = s; n <= o; n++) {
-        f = this.ze[n];
-        l = this.Ye ? this.Ye(f) : f;
-        r = c.get(l);
+        l = this.Ye[n];
+        f = this.tt ? this.tt(l) : l;
+        r = c.get(f);
         if (r !== undefined && r !== -1) {
-          d[r] = this.Je[n];
-          p[r] = this.Xe[n];
-          h && (h[r] = this.Ze[n]);
-          y && (y[r] = this.$e[n]);
+          d[r] = this.$e[n];
+          p[r] = this.et[n];
+          h && (h[r] = this.nt[n]);
+          g && (g[r] = this.rt[n]);
           r = a[r];
-          c.set(l, r);
-        } else this.Xe[n].dispose();
+          c.set(f, r);
+        } else this.et[n].dispose();
       }
       for (r = s; r < t; r++) {
         if (r in d) {
-          this.Je[r] = d[r];
-          this.Xe[r] = p[r];
+          this.$e[r] = d[r];
+          this.et[r] = p[r];
           if (h) {
-            this.Ze[r] = h[r];
-            setSignal(this.Ze[r], e[r]);
+            this.nt[r] = h[r];
+            setSignal(this.nt[r], e[r]);
           }
-          if (y) {
-            this.$e[r] = y[r];
-            setSignal(this.$e[r], r);
+          if (g) {
+            this.rt[r] = g[r];
+            setSignal(this.rt[r], r);
           }
         } else {
-          this.Je[r] = runWithOwner((this.Xe[r] = createOwner()), i);
+          this.$e[r] = runWithOwner((this.et[r] = createOwner()), i);
         }
       }
-      this.Je = this.Je.slice(0, (this.Ke = t));
-      this.ze = e.slice(0);
+      this.$e = this.$e.slice(0, (this.Je = t));
+      this.Ye = e.slice(0);
     }
   });
-  return this.Je;
+  return this.$e;
 }
 function repeat(e, t, n) {
   const r = t;
   const i = computed(
     updateRepeat.bind({
-      Be: createOwner(),
-      Ke: 0,
-      tt: 0,
-      nt: e,
-      Ue: r,
-      Xe: [],
-      Je: [],
-      rt: n?.from,
-      et: n?.fallback
+      Ue: createOwner(),
+      Je: 0,
+      ot: 0,
+      ut: e,
+      Ze: r,
+      et: [],
+      $e: [],
+      lt: n?.from,
+      st: n?.fallback
     })
   );
-  i.de &= ~g;
+  i.ye &= ~y;
   return accessor(i);
 }
 function updateRepeat() {
-  const e = this.nt();
-  const t = this.rt?.() || 0;
-  runWithOwner(this.Be, () => {
+  const e = this.ut();
+  const t = this.lt?.() || 0;
+  runWithOwner(this.Ue, () => {
     if (e === 0) {
-      if (this.Ke !== 0) {
-        this.Be.dispose(false);
-        this.Xe = [];
-        this.Je = [];
-        this.Ke = 0;
+      if (this.Je !== 0) {
+        this.Ue.dispose(false);
+        this.et = [];
+        this.$e = [];
+        this.Je = 0;
       }
-      if (this.et && !this.Je[0]) {
-        this.Je[0] = runWithOwner((this.Xe[0] = createOwner()), this.et);
+      if (this.st && !this.$e[0]) {
+        this.$e[0] = runWithOwner((this.et[0] = createOwner()), this.st);
       }
       return;
     }
     const n = t + e;
-    const r = this.tt + this.Ke;
-    if (this.Ke === 0 && this.Xe[0]) this.Xe[0].dispose();
-    for (let e = n; e < r; e++) this.Xe[e - this.tt].dispose();
-    if (this.tt < t) {
-      let e = this.tt;
-      while (e < t && e < this.Ke) this.Xe[e++].dispose();
-      this.Xe.splice(0, t - this.tt);
-      this.Je.splice(0, t - this.tt);
-    } else if (this.tt > t) {
-      let n = r - this.tt - 1;
-      let i = this.tt - t;
-      this.Xe.length = this.Je.length = e;
+    const r = this.ot + this.Je;
+    if (this.Je === 0 && this.et[0]) this.et[0].dispose();
+    for (let e = n; e < r; e++) this.et[e - this.ot].dispose();
+    if (this.ot < t) {
+      let e = this.ot;
+      while (e < t && e < this.Je) this.et[e++].dispose();
+      this.et.splice(0, t - this.ot);
+      this.$e.splice(0, t - this.ot);
+    } else if (this.ot > t) {
+      let n = r - this.ot - 1;
+      let i = this.ot - t;
+      this.et.length = this.$e.length = e;
       while (n >= i) {
-        this.Xe[n] = this.Xe[n - i];
-        this.Je[n] = this.Je[n - i];
+        this.et[n] = this.et[n - i];
+        this.$e[n] = this.$e[n - i];
         n--;
       }
       for (let e = 0; e < i; e++) {
-        this.Je[e] = runWithOwner((this.Xe[e] = createOwner()), () => this.Ue(e + t));
+        this.$e[e] = runWithOwner((this.et[e] = createOwner()), () => this.Ze(e + t));
       }
     }
     for (let e = r; e < n; e++) {
-      this.Je[e - t] = runWithOwner((this.Xe[e - t] = createOwner()), () => this.Ue(e));
+      this.$e[e - t] = runWithOwner((this.et[e - t] = createOwner()), () => this.Ze(e));
     }
-    this.Je = this.Je.slice(0, e);
-    this.tt = t;
-    this.Ke = e;
+    this.$e = this.$e.slice(0, e);
+    this.ot = t;
+    this.Je = e;
   });
-  return this.Je;
+  return this.$e;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
   const n = computed(e, { lazy: true });
-  n.Te = (e, t) => {
-    const r = e !== undefined ? e : n.ge;
-    const i = t !== undefined ? t : n.pe;
-    n.ge &= ~n.it;
-    n.K.notify(n, n.it, r, i);
+  n.Fe = (e, t) => {
+    const r = e !== undefined ? e : n.be;
+    const i = t !== undefined ? t : n.we;
+    n.be &= ~n.ft;
+    n.te.notify(n, n.ft, r, i);
   };
-  n.it = t;
-  n.de &= ~g;
+  n.ft = t;
+  n.ye &= ~y;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, r) {
-  const i = e.K;
-  i.addChild((e.K = n));
-  cleanup(() => i.removeChild(e.K));
+  const i = e.te;
+  i.addChild((e.te = n));
+  cleanup(() => i.removeChild(e.te));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), r);
   });
 }
-const ve = Symbol();
-const xe = createContext(null);
-let Pe = false;
+const je = Symbol();
+const We = createContext(null);
+let Re = false;
 const FALSE_ACCESSOR = () => false;
 const SEQUENTIAL_ACCESSOR = () => "sequential";
 function isRevealController(e) {
   return e instanceof RevealController;
 }
 function isSlotReady(e) {
-  return isRevealController(e) ? e.isReady() : e.st.size === 0 && !e.ot;
+  return isRevealController(e) ? e.isReady() : e.ct.size === 0 && !e.dt;
 }
 function isSlotMinimallyReady(e) {
   return isRevealController(e) ? e.isMinimallyReady() : isSlotReady(e);
 }
 function setSlotState(e, t, n, r) {
-  setSignal(e.ut, n);
-  setSignal(e.ft, r);
+  setSignal(e.ht, n);
+  setSignal(e.gt, r);
   if (isRevealController(e)) {
-    if (!n && e.lt === t) e.lt = undefined;
+    if (!n && e.St === t) e.St = undefined;
     return e.evaluate(n, r);
   }
-  if (!n && e.ct === t && e.dt) e.ct = undefined;
+  if (!n && e.yt === t && e.wt) e.yt = undefined;
 }
 class RevealController {
-  ht;
-  yt;
-  gt = [];
-  lt;
-  ut = signal(false, { ownedWrite: true, Qe: true });
-  ft = signal(false, { ownedWrite: true, Qe: true });
-  St = true;
-  wt = true;
-  bt = false;
+  _t;
+  bt;
+  Ot = [];
+  St;
+  ht = signal(false, { ownedWrite: true, ze: true });
+  gt = signal(false, { ownedWrite: true, ze: true });
+  vt = true;
+  Pt = true;
+  xt = false;
   constructor(e, t) {
-    this.ht = e;
-    this.yt = t;
+    this._t = e;
+    this.bt = t;
   }
-  _t(e) {
-    for (let t = 0; t < this.gt.length; t++) {
-      const n = this.gt[t];
-      if ((isRevealController(n) ? n.lt : n.ct) !== this) continue;
+  Ct(e) {
+    for (let t = 0; t < this.Ot.length; t++) {
+      const n = this.Ot[t];
+      if ((isRevealController(n) ? n.St : n.yt) !== this) continue;
       if (e(n) === false) return false;
     }
     return true;
   }
   isReady() {
-    return this._t(isSlotReady);
+    return this.Ct(isSlotReady);
   }
   isMinimallyReady() {
-    const e = untrack(this.ht);
+    const e = untrack(this._t);
     if (e === "together") return this.isReady();
     if (e === "natural") {
       let e = false;
       let t = false;
-      this._t(n => {
+      this.Ct(n => {
         e = true;
         if (isSlotMinimallyReady(n)) {
           t = true;
@@ -3260,58 +3582,58 @@ class RevealController {
       return !e || t;
     }
     let t = true;
-    this._t(e => {
+    this.Ct(e => {
       t = isSlotMinimallyReady(e);
       return false;
     });
     return t;
   }
   register(e) {
-    if (this.gt.includes(e)) return;
-    this.gt.push(e);
-    const t = untrack(this.ht);
-    (setSignal(e.ut, true), setSignal(e.ft, t === "sequential" ? !!untrack(this.yt) : false));
+    if (this.Ot.includes(e)) return;
+    this.Ot.push(e);
+    const t = untrack(this._t);
+    (setSignal(e.ht, true), setSignal(e.gt, t === "sequential" ? !!untrack(this.bt) : false));
     untrack(() => this.evaluate());
   }
   unregister(e) {
-    const t = this.gt.indexOf(e);
-    if (t >= 0) this.gt.splice(t, 1);
+    const t = this.Ot.indexOf(e);
+    if (t >= 0) this.Ot.splice(t, 1);
     untrack(() => this.evaluate());
   }
   evaluate(e, t) {
-    if (this.bt) return;
-    this.bt = true;
-    const n = this.St;
-    const r = this.wt;
+    if (this.xt) return;
+    this.xt = true;
+    const n = this.vt;
+    const r = this.Pt;
     try {
-      const n = e ?? read(this.ut),
-        r = untrack(this.ht),
-        i = r === "sequential" && !!untrack(this.yt),
+      const n = e ?? read(this.ht),
+        r = untrack(this._t),
+        i = r === "sequential" && !!untrack(this.bt),
         s = t ?? i;
       if (n) {
-        this._t(e => setSlotState(e, this, true, s));
+        this.Ct(e => setSlotState(e, this, true, s));
       } else if (r === "natural") {
-        this._t(e => {
+        this.Ct(e => {
           if (isRevealController(e)) {
-            setSignal(e.ft, false);
-            setSignal(e.ut, false);
+            setSignal(e.gt, false);
+            setSignal(e.ht, false);
             e.evaluate(false, false);
           } else {
             setSlotState(e, this, !isSlotReady(e), false);
           }
         });
       } else if (r === "together") {
-        const e = this._t(isSlotMinimallyReady);
-        this._t(t => setSlotState(t, this, !e, false));
+        const e = this.Ct(isSlotMinimallyReady);
+        this.Ct(t => setSlotState(t, this, !e, false));
       } else {
         let e = false;
-        this._t(t => {
+        this.Ct(t => {
           if (e) return setSlotState(t, this, true, i);
           if (isSlotReady(t)) return setSlotState(t, this, false, false);
           e = true;
           if (isRevealController(t)) {
-            setSignal(t.ft, false);
-            setSignal(t.ut, false);
+            setSignal(t.gt, false);
+            setSignal(t.ht, false);
             t.evaluate(false, false);
           } else {
             setSlotState(t, this, true, false);
@@ -3319,92 +3641,92 @@ class RevealController {
         });
       }
     } finally {
-      this.St = this.isReady();
-      this.wt = this.isMinimallyReady();
-      this.bt = false;
+      this.vt = this.isReady();
+      this.Pt = this.isMinimallyReady();
+      this.xt = false;
     }
-    if (this.lt && (n !== this.St || r !== this.wt)) this.lt.evaluate();
+    if (this.St && (n !== this.vt || r !== this.Pt)) this.St.evaluate();
   }
 }
 class CollectionQueue extends Queue {
-  Ot;
-  st = new Set();
-  vt;
-  ot = true;
-  ut = signal(false, { ownedWrite: true, Qe: true });
-  ft = signal(false, { ownedWrite: true, Qe: true });
-  ct;
-  dt = false;
-  xt;
-  Pt = ve;
+  Nt;
+  ct = new Set();
+  Et;
+  dt = true;
+  ht = signal(false, { ownedWrite: true, ze: true });
+  gt = signal(false, { ownedWrite: true, ze: true });
+  yt;
+  wt = false;
+  kt;
+  jt = je;
   constructor(e) {
     super();
-    this.Ot = e;
+    this.Nt = e;
   }
   run(e) {
-    if (!e || (read(this.ut) && (!Pe || read(this.ft)))) return;
+    if (!e || (read(this.ht) && (!Re || read(this.gt)))) return;
     return super.run(e);
   }
   notify(e, t, n, r) {
-    if (!(t & this.Ot)) return super.notify(e, t, n, r);
-    if (this.dt && this.xt) {
+    if (!(t & this.Nt)) return super.notify(e, t, n, r);
+    if (this.wt && this.kt) {
       const e = untrack(() => {
         try {
-          return this.xt();
+          return this.kt();
         } catch {
-          return ve;
+          return je;
         }
       });
-      if (e !== this.Pt) {
-        this.Pt = e;
-        this.dt = false;
-        this.st.clear();
+      if (e !== this.jt) {
+        this.jt = e;
+        this.wt = false;
+        this.ct.clear();
       }
     }
-    if (this.Ot & S && this.dt) return super.notify(e, t, n, r);
-    if (this.Ot & S && n & w) {
-      return super.notify(e, w, n, r);
+    if (this.Nt & m && this.wt) return super.notify(e, t, n, r);
+    if (this.Nt & m && n & _) {
+      return super.notify(e, _, n, r);
     }
-    if (n & this.Ot) {
-      this.ot = true;
-      const t = r?.source || e.pe?.source;
+    if (n & this.Nt) {
+      this.dt = true;
+      const t = r?.source || e.we?.source;
       if (t) {
-        const e = this.st.size === 0;
-        this.st.add(t);
-        if (e) setSignal(this.ut, true);
+        const e = this.ct.size === 0;
+        this.ct.add(t);
+        if (e) setSignal(this.ht, true);
       }
     }
-    t &= ~this.Ot;
+    t &= ~this.Nt;
     return t ? super.notify(e, t, n, r) : true;
   }
   checkSources() {
-    for (const e of this.st) {
-      if (e.m & u || (!(e.ge & this.Ot) && !(this.Ot & w && e.ge & S))) this.st.delete(e);
+    for (const e of this.ct) {
+      if (e.m & u || (!(e.be & this.Nt) && !(this.Nt & _ && e.be & m))) this.ct.delete(e);
     }
-    if (!this.st.size) {
-      if (this.Ot & S && this.ot && !this.dt && this.vt) {
-        this.ot = !!(this.vt.ge & this.Ot);
+    if (!this.ct.size) {
+      if (this.Nt & m && this.dt && !this.wt && this.Et) {
+        this.dt = !!(this.Et.be & this.Nt);
       } else {
-        this.ot = false;
+        this.dt = false;
       }
-      if (!this.ot) {
-        setSignal(this.ut, false);
-        if (this.xt) {
+      if (!this.dt) {
+        setSignal(this.ht, false);
+        if (this.kt) {
           try {
-            this.Pt = untrack(() => this.xt());
+            this.jt = untrack(() => this.kt());
           } catch {}
         }
       }
     }
-    if (Pe) this.ct?.evaluate();
+    if (Re) this.yt?.evaluate();
   }
 }
 function createCollectionBoundary(e, t, n, r) {
   const i = createOwner();
-  if (Pe) setContext(xe, null, i);
+  if (Re) setContext(We, null, i);
   const s = new CollectionQueue(e);
-  if (r) s.xt = r;
-  const o = (s.vt = createBoundChildren(i, t, s, e));
+  if (r) s.kt = r;
+  const o = (s.Et = createBoundChildren(i, t, s, e));
   untrack(() => {
     let t = false;
     try {
@@ -3413,46 +3735,46 @@ function createCollectionBoundary(e, t, n, r) {
       if (e instanceof NotReadyError) t = true;
       else throw e;
     }
-    s.ot = t || !!(o.ge & e) || o.pe instanceof NotReadyError;
+    s.dt = t || !!(o.be & e) || o.we instanceof NotReadyError;
   });
-  const u = Pe && e === S ? getContext(xe) : null;
+  const u = Re && e === m ? getContext(We) : null;
   if (u) {
-    s.ct = u;
+    s.yt = u;
     u.register(s);
     cleanup(() => u.unregister(s));
   }
   return accessor(
     computed(() => {
-      if (!read(s.ut)) {
+      if (!read(s.ht)) {
         const e = read(o);
-        if (!untrack(() => read(s.ut))) return ((s.dt = true), e);
+        if (!untrack(() => read(s.ht))) return ((s.wt = true), e);
       }
-      if (Pe && read(s.ft)) return undefined;
+      if (Re && read(s.gt)) return undefined;
       return n(s);
     })
   );
 }
 function createLoadingBoundary(e, t, n) {
-  return createCollectionBoundary(S, e, () => t(), n?.on);
+  return createCollectionBoundary(m, e, () => t(), n?.on);
 }
 function createErrorBoundary(e, t) {
-  return createCollectionBoundary(w, e, e => {
-    let n = e.st.values().next().value;
-    const r = n.pe?.cause ?? n.pe;
+  return createCollectionBoundary(_, e, e => {
+    let n = e.ct.values().next().value;
+    const r = n.we?.cause ?? n.we;
     return t(r, () => {
-      for (const t of e.st) recompute(t);
+      for (const t of e.ct) recompute(t);
       schedule();
     });
   });
 }
 function createRevealOrder(e, t) {
-  Pe = true;
+  Re = true;
   const n = createOwner();
-  const r = getContext(xe);
+  const r = getContext(We);
   const i = t?.order || SEQUENTIAL_ACCESSOR,
     s = t?.collapsed || FALSE_ACCESSOR;
   const o = new RevealController(i, s);
-  setContext(xe, o, n);
+  setContext(We, o, n);
   return runWithOwner(n, () => {
     const t = e();
     computed(() => {
@@ -3461,7 +3783,7 @@ function createRevealOrder(e, t) {
       o.evaluate();
     });
     if (r) {
-      o.lt = r;
+      o.St = r;
       r.register(o);
       cleanup(() => r.unregister(o));
     }
@@ -3517,16 +3839,16 @@ function flattenArray(e, t = [], n) {
   if (r) throw r;
   return i;
 }
-const ke = undefined;
-exports.$PROXY = ne;
-exports.$REFRESH = E;
-exports.$TARGET = te;
-exports.$TRACK = ee;
+const Ae = undefined;
+exports.$PROXY = fe;
+exports.$REFRESH = j;
+exports.$TARGET = le;
+exports.$TRACK = ue;
 exports.ContextNotFoundError = ContextNotFoundError;
-exports.DEV = ke;
+exports.DEV = Ae;
 exports.NoOwnerError = NoOwnerError;
 exports.NotReadyError = NotReadyError;
-exports.SUPPORTS_PROXY = k;
+exports.SUPPORTS_PROXY = E;
 exports.action = action;
 exports.clearSnapshots = clearSnapshots;
 exports.createContext = createContext;
@@ -3576,5 +3898,5 @@ exports.runWithOwner = runWithOwner;
 exports.setContext = setContext;
 exports.setSnapshotCapture = setSnapshotCapture;
 exports.snapshot = snapshot;
-exports.storePath = me;
+exports.storePath = Ce;
 exports.untrack = untrack;