@solidjs/signals 0.10.0 → 0.10.1

package/dist/prod.js

@@ -1,15 +1,15 @@
 class NotReadyError extends Error {
-  t;
+  source;
   constructor(e) {
     super();
-    this.t = e;
+    this.source = e;
   }
 }
 class StatusError extends Error {
-  t;
+  source;
   constructor(e, t) {
     super(t instanceof Error ? t.message : String(t), { cause: t });
-    this.t = e;
+    this.source = e;
   }
 }
 class NoOwnerError extends Error {
@@ -42,114 +42,114 @@ const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
 const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
-  const n = (e.o?.i ? e.o.l?.u : e.o?.u) ?? -1;
-  if (n >= e.u) e.u = n + 1;
-  const i = e.u;
-  const r = t.T[i];
-  if (r === undefined) t.T[i] = e;
+  const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
+  if (n >= e.o) e.o = n + 1;
+  const i = e.o;
+  const r = t.l[i];
+  if (r === undefined) t.l[i] = e;
   else {
-    const t = r.R;
-    t.O = e;
-    e.R = t;
-    r.R = e;
+    const t = r.T;
+    t.R = e;
+    e.T = t;
+    r.T = e;
   }
-  if (i > t.S) t.S = i;
+  if (i > t.O) t.O = i;
 }
 function insertIntoHeap(e, t) {
-  let n = e._;
+  let n = e.S;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
   if (n & REACTIVE_CHECK) {
-    e._ = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else e._ = n | REACTIVE_IN_HEAP;
+    e.S = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e.S = n | REACTIVE_IN_HEAP;
   if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e._;
+  let n = e.S;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
-  e._ = n | REACTIVE_IN_HEAP_HEIGHT;
+  e.S = n | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e._;
+  const n = e.S;
   if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  e._ = n & -25;
-  const i = e.u;
-  if (e.R === e) t.T[i] = undefined;
+  e.S = n & -25;
+  const i = e.o;
+  if (e.T === e) t.l[i] = undefined;
   else {
-    const n = e.O;
-    const r = t.T[i];
+    const n = e.R;
+    const r = t.l[i];
     const o = n ?? r;
-    if (e === r) t.T[i] = n;
-    else e.R.O = n;
-    o.R = e.R;
+    if (e === r) t.l[i] = n;
+    else e.T.R = n;
+    o.T = e.T;
   }
-  e.R = e;
-  e.O = undefined;
+  e.T = e;
+  e.R = undefined;
 }
 function markHeap(e) {
-  if (e.I) return;
-  e.I = true;
-  for (let t = 0; t <= e.S; t++) {
-    for (let n = e.T[t]; n !== undefined; n = n.O) {
-      if (n._ & REACTIVE_IN_HEAP) markNode(n);
+  if (e._) return;
+  e._ = true;
+  for (let t = 0; t <= e.O; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.R) {
+      if (n.S & REACTIVE_IN_HEAP) markNode(n);
     }
   }
 }
 function markNode(e, t = REACTIVE_DIRTY) {
-  const n = e._;
+  const n = e.S;
   if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-  e._ = (n & -4) | t;
-  for (let t = e.p; t !== null; t = t.h) {
-    markNode(t.A, REACTIVE_CHECK);
+  e.S = (n & -4) | t;
+  for (let t = e.I; t !== null; t = t.p) {
+    markNode(t.h, REACTIVE_CHECK);
   }
-  if (e.P !== null) {
-    for (let t = e.P; t !== null; t = t.C) {
-      for (let e = t.p; e !== null; e = e.h) {
-        markNode(e.A, REACTIVE_CHECK);
+  if (e.A !== null) {
+    for (let t = e.A; t !== null; t = t.P) {
+      for (let e = t.I; e !== null; e = e.p) {
+        markNode(e.h, REACTIVE_CHECK);
       }
     }
   }
 }
 function runHeap(e, t) {
-  e.I = false;
-  for (e.N = 0; e.N <= e.S; e.N++) {
-    let n = e.T[e.N];
+  e._ = false;
+  for (e.C = 0; e.C <= e.O; e.C++) {
+    let n = e.l[e.C];
     while (n !== undefined) {
-      if (n._ & REACTIVE_IN_HEAP) t(n);
+      if (n.S & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
-      n = e.T[e.N];
+      n = e.l[e.C];
     }
   }
-  e.S = 0;
+  e.O = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
-  let n = e.u;
-  for (let t = e.D; t; t = t.V) {
-    const e = t.m;
-    const i = e.L || e;
-    if (i.k && i.u >= n) n = i.u + 1;
+  let n = e.o;
+  for (let t = e.N; t; t = t.D) {
+    const e = t.V;
+    const i = e.m || e;
+    if (i.L && i.o >= n) n = i.o + 1;
   }
-  if (e.u !== n) {
-    e.u = n;
-    for (let n = e.p; n !== null; n = n.h) {
-      insertIntoHeapHeight(n.A, t);
+  if (e.o !== n) {
+    e.o = n;
+    for (let n = e.I; n !== null; n = n.p) {
+      insertIntoHeapHeight(n.h, t);
     }
   }
 }
 const transitions = new Set();
-const dirtyQueue = { T: new Array(2e3).fill(undefined), I: false, N: 0, S: 0 };
-const zombieQueue = { T: new Array(2e3).fill(undefined), I: false, N: 0, S: 0 };
+const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, O: 0 };
+const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, O: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.U || t.W.size > 0) continue;
-    const n = t.F[e - 1];
+    if (t.k || t.U.size > 0) continue;
+    const n = t.W[e - 1];
     if (n.length) {
-      t.F[e - 1] = [];
+      t.W[e - 1] = [];
       runQueue(n, e);
     }
   }
@@ -160,129 +160,129 @@ function setProjectionWriteActive(e) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.G) queueMicrotask(flush);
+  if (!globalQueue.M) queueMicrotask(flush);
 }
 class Queue {
-  o = null;
-  M = [[], []];
-  $ = [];
+  i = null;
+  F = [[], []];
+  G = [];
   created = clock;
   addChild(e) {
-    this.$.push(e);
-    e.o = this;
+    this.G.push(e);
+    e.i = this;
   }
   removeChild(e) {
-    const t = this.$.indexOf(e);
+    const t = this.G.indexOf(e);
     if (t >= 0) {
-      this.$.splice(t, 1);
-      e.o = null;
+      this.G.splice(t, 1);
+      e.i = null;
     }
   }
   notify(e, t, n, i) {
-    if (this.o) return this.o.notify(e, t, n, i);
+    if (this.i) return this.i.notify(e, t, n, i);
     return false;
   }
   run(e) {
-    if (this.M[e - 1].length) {
-      const t = this.M[e - 1];
-      this.M[e - 1] = [];
+    if (this.F[e - 1].length) {
+      const t = this.F[e - 1];
+      this.F[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.$.length; t++) this.$[t].run?.(e);
+    for (let t = 0; t < this.G.length; t++) this.G[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.F[e - 1].push(t);
+        n.W[e - 1].push(t);
       } else {
-        this.M[e - 1].push(t);
+        this.F[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.M[0].push(...this.M[0]);
-    e.M[1].push(...this.M[1]);
-    this.M = [[], []];
-    for (let t = 0; t < this.$.length; t++) {
-      let n = this.$[t];
-      let i = e.$[t];
+    e.F[0].push(...this.F[0]);
+    e.F[1].push(...this.F[1]);
+    this.F = [[], []];
+    for (let t = 0; t < this.G.length; t++) {
+      let n = this.G[t];
+      let i = e.G[t];
       if (!i) {
-        i = { M: [[], []], $: [] };
-        e.$[t] = i;
+        i = { F: [[], []], G: [] };
+        e.G[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.M[0].push(...e.M[0]);
-    this.M[1].push(...e.M[1]);
-    for (let t = 0; t < e.$.length; t++) {
-      const n = e.$[t];
-      let i = this.$[t];
+    this.F[0].push(...e.F[0]);
+    this.F[1].push(...e.F[1]);
+    for (let t = 0; t < e.G.length; t++) {
+      const n = e.G[t];
+      let i = this.G[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  G = false;
+  M = false;
+  $ = [];
   H = [];
-  j = [];
-  K = new Set();
+  j = new Set();
+  static K;
   static Y;
-  static B;
-  static X = null;
+  static B = null;
   flush() {
-    if (this.G) return;
-    this.G = true;
+    if (this.M) return;
+    this.M = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.Y);
+      runHeap(dirtyQueue, GlobalQueue.K);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
           let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.Y);
+          runHeap(zombieQueue, GlobalQueue.K);
+          this.$ = [];
           this.H = [];
-          this.j = [];
-          this.K = new Set();
+          this.j = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition.q);
+          this.stashQueues(activeTransition.X);
           clock++;
-          scheduled = dirtyQueue.S >= dirtyQueue.N;
-          reassignPendingTransition(activeTransition.H);
+          scheduled = dirtyQueue.O >= dirtyQueue.C;
+          reassignPendingTransition(activeTransition.$);
           activeTransition = null;
           finalizePureQueue(null, true);
           return;
         }
-        this.H !== activeTransition.H && this.H.push(...activeTransition.H);
-        this.restoreQueues(activeTransition.q);
+        this.$ !== activeTransition.$ && this.$.push(...activeTransition.$);
+        this.restoreQueues(activeTransition.X);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.H);
+        reassignPendingTransition(this.$);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.Y);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.K);
         finalizePureQueue();
       }
       clock++;
-      scheduled = dirtyQueue.S >= dirtyQueue.N;
+      scheduled = dirtyQueue.O >= dirtyQueue.C;
       runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.G = false;
+      this.M = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.Z;
-        if (activeTransition && t && !activeTransition.J.includes(t.t)) {
-          activeTransition.J.push(t.t);
+        const t = i !== undefined ? i : e.q;
+        if (activeTransition && t && !activeTransition.Z.includes(t.source)) {
+          activeTransition.Z.push(t.source);
           schedule();
         }
       }
@@ -293,143 +293,143 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.ee === clock) return;
+    if (!e && activeTransition && activeTransition.J === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        ee: clock,
+        J: clock,
+        $: [],
+        Z: [],
         H: [],
-        J: [],
-        j: [],
-        K: new Set(),
-        te: [],
-        q: { M: [[], []], $: [] },
-        ne: false
+        j: new Set(),
+        ee: [],
+        X: { F: [[], []], G: [] },
+        te: false
       };
     } else if (e) {
       const t = activeTransition;
-      t.ne = e;
-      e.te.push(...t.te);
+      t.te = e;
+      e.ee.push(...t.ee);
       for (const n of activeLanes) {
-        if (n.ie === t) n.ie = e;
+        if (n.ne === t) n.ne = e;
       }
-      e.j.push(...t.j);
-      for (const n of t.K) {
-        e.K.add(n);
+      e.H.push(...t.H);
+      for (const n of t.j) {
+        e.j.add(n);
       }
       transitions.delete(t);
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.ee = clock;
+    activeTransition.J = clock;
+    for (let e = 0; e < this.$.length; e++) {
+      const t = this.$[e];
+      t.ne = activeTransition;
+      activeTransition.$.push(t);
+    }
+    this.$ = activeTransition.$;
     for (let e = 0; e < this.H.length; e++) {
       const t = this.H[e];
-      t.ie = activeTransition;
+      t.ne = activeTransition;
       activeTransition.H.push(t);
     }
     this.H = activeTransition.H;
-    for (let e = 0; e < this.j.length; e++) {
-      const t = this.j[e];
-      t.ie = activeTransition;
-      activeTransition.j.push(t);
-    }
-    this.j = activeTransition.j;
     for (const e of activeLanes) {
-      if (!e.ie) e.ie = activeTransition;
+      if (!e.ne) e.ne = activeTransition;
     }
-    for (const e of this.K) activeTransition.K.add(e);
-    this.K = activeTransition.K;
+    for (const e of this.j) activeTransition.j.add(e);
+    this.j = activeTransition.j;
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.re || currentOptimisticLane;
-  for (let i = e.p; i !== null; i = i.h) {
+  const n = e.ie || currentOptimisticLane;
+  for (let i = e.I; i !== null; i = i.p) {
     if (t && n) {
-      i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
-      assignOrMergeLane(i.A, n);
+      i.h.S |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(i.h, n);
     } else if (t) {
-      i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
-      i.A.re = undefined;
+      i.h.S |= REACTIVE_OPTIMISTIC_DIRTY;
+      i.h.ie = undefined;
     }
-    const e = i.A;
-    if (e.oe === EFFECT_TRACKED) {
-      if (!e.se) {
-        e.se = true;
-        e.ue.enqueue(EFFECT_USER, e.ce);
+    const e = i.h;
+    if (e.re === EFFECT_TRACKED) {
+      if (!e.oe) {
+        e.oe = true;
+        e.se.enqueue(EFFECT_USER, e.ue);
       }
       continue;
     }
-    const r = i.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (r.N > i.A.u) r.N = i.A.u;
-    insertIntoHeap(i.A, r);
+    const r = i.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (r.C > i.h.o) r.C = i.h.o;
+    insertIntoHeap(i.h, r);
   }
 }
 function finalizePureQueue(e = null, t = false) {
   let n = !t;
   if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.S >= dirtyQueue.N) runHeap(dirtyQueue, GlobalQueue.Y);
+  if (dirtyQueue.O >= dirtyQueue.C) runHeap(dirtyQueue, GlobalQueue.K);
   if (n) {
-    const t = globalQueue.H;
+    const t = globalQueue.$;
     for (let e = 0; e < t.length; e++) {
       const n = t[e];
-      if (n.le !== NOT_PENDING) {
-        n.ae = n.le;
-        n.le = NOT_PENDING;
-        if (n.oe && n.oe !== EFFECT_TRACKED) n.se = true;
+      if (n.ce !== NOT_PENDING) {
+        n.le = n.ce;
+        n.ce = NOT_PENDING;
+        if (n.re && n.re !== EFFECT_TRACKED) n.oe = true;
       }
-      n.fe &= ~STATUS_UNINITIALIZED;
-      if (n.k) GlobalQueue.B(n, false, true);
+      n.ae &= ~STATUS_UNINITIALIZED;
+      if (n.L) GlobalQueue.Y(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.j : globalQueue.j;
+    const n = e ? e.H : globalQueue.H;
     for (let e = 0; e < n.length; e++) {
       const t = n[e];
-      const i = t.le;
-      t.re = undefined;
-      if (i !== NOT_PENDING && t.ae !== i) {
-        t.ae = i;
+      const i = t.ce;
+      t.ie = undefined;
+      if (i !== NOT_PENDING && t.le !== i) {
+        t.le = i;
         insertSubs(t, true);
       }
-      t.le = NOT_PENDING;
-      t.ie = null;
+      t.ce = NOT_PENDING;
+      t.ne = null;
     }
     n.length = 0;
-    const i = e ? e.K : globalQueue.K;
-    if (GlobalQueue.X && i.size) {
+    const i = e ? e.j : globalQueue.j;
+    if (GlobalQueue.B && i.size) {
       for (const e of i) {
-        GlobalQueue.X(e);
+        GlobalQueue.B(e);
       }
       i.clear();
       schedule();
     }
     for (const t of activeLanes) {
-      const n = e ? t.ie === e : !t.ie;
+      const n = e ? t.ne === e : !t.ne;
       if (!n) continue;
-      if (!t.U) {
-        if (t.F[0].length) runQueue(t.F[0], EFFECT_RENDER);
-        if (t.F[1].length) runQueue(t.F[1], EFFECT_USER);
-      }
-      if (t.t.re === t) t.t.re = undefined;
-      t.W.clear();
-      t.F[0].length = 0;
-      t.F[1].length = 0;
+      if (!t.k) {
+        if (t.W[0].length) runQueue(t.W[0], EFFECT_RENDER);
+        if (t.W[1].length) runQueue(t.W[1], EFFECT_USER);
+      }
+      if (t.fe.ie === t) t.fe.ie = undefined;
+      t.U.clear();
+      t.W[0].length = 0;
+      t.W[1].length = 0;
       activeLanes.delete(t);
-      signalLanes.delete(t.t);
+      signalLanes.delete(t.fe);
     }
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.$) {
+  for (const t of e.G) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.K.add(e);
+  globalQueue.j.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].ie = activeTransition;
+    e[t].ne = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -442,21 +442,21 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.ne) return true;
-  if (e.te.length) return false;
+  if (e.te) return true;
+  if (e.ee.length) return false;
   let t = true;
-  for (let n = 0; n < e.J.length; n++) {
-    const i = e.J[n];
-    if (i.fe & STATUS_PENDING && i.Z?.t === i) {
+  for (let n = 0; n < e.Z.length; n++) {
+    const i = e.Z[n];
+    if (i.ae & STATUS_PENDING && i.q?.source === i) {
       t = false;
       break;
     }
   }
-  t && (e.ne = true);
+  t && (e.te = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.ne && typeof e.ne === "object") e = e.ne;
+  while (e.te && typeof e.te === "object") e = e.te;
   return e;
 }
 function setActiveTransition(e) {
@@ -479,58 +479,58 @@ function getOrCreateLane(e) {
     return findLane(t);
   }
   const n = e.Ee;
-  const i = n?.re ? findLane(n.re) : null;
-  t = { t: e, W: new Set(), F: [[], []], U: null, ie: activeTransition, Te: i };
+  const i = n?.ie ? findLane(n.ie) : null;
+  t = { fe: e, U: new Set(), W: [[], []], k: null, ne: activeTransition, Te: i };
   signalLanes.set(e, t);
   activeLanes.add(t);
   e.de = e.Re || 0;
   return t;
 }
 function findLane(e) {
-  while (e.U) e = e.U;
+  while (e.k) e = e.k;
   return e;
 }
 function mergeLanes(e, t) {
   e = findLane(e);
   t = findLane(t);
   if (e === t) return e;
-  t.U = e;
-  for (const n of t.W) e.W.add(n);
-  e.F[0].push(...t.F[0]);
-  e.F[1].push(...t.F[1]);
+  t.k = e;
+  for (const n of t.U) e.U.add(n);
+  e.W[0].push(...t.W[0]);
+  e.W[1].push(...t.W[1]);
   return e;
 }
 function resolveLane(e) {
-  const t = e.re;
+  const t = e.ie;
   if (!t) return undefined;
   const n = findLane(t);
   if (activeLanes.has(n)) return n;
-  e.re = undefined;
+  e.ie = undefined;
   return undefined;
 }
 function hasActiveOverride(e) {
-  return !!(e.Oe && e.le !== NOT_PENDING);
+  return !!(e.Oe && e.ce !== NOT_PENDING);
 }
 function assignOrMergeLane(e, t) {
   const n = findLane(t);
-  const i = e.re;
+  const i = e.ie;
   if (i) {
-    if (i.U) {
-      e.re = t;
+    if (i.k) {
+      e.ie = t;
       return;
     }
     const r = findLane(i);
     if (activeLanes.has(r)) {
       if (r !== n && !hasActiveOverride(e)) {
         if (n.Te && findLane(n.Te) === r) {
-          e.re = t;
+          e.ie = t;
         } else if (r.Te && findLane(r.Te) === n);
         else mergeLanes(n, r);
       }
       return;
     }
   }
-  e.re = t;
+  e.ie = t;
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
@@ -544,32 +544,32 @@ function handleAsync(e, t, n) {
   let s;
   const handleError = n => {
     if (e.Se !== t) return;
-    globalQueue.initTransition(e.ie);
+    globalQueue.initTransition(e.ne);
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.ee = clock;
+    e.J = clock;
   };
   const asyncWrite = (i, r) => {
     if (e.Se !== t) return;
-    if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(e.ie);
+    if (e.S & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(e.ne);
     clearStatus(e);
     const o = resolveLane(e);
-    if (o) o.W.delete(e);
+    if (o) o.U.delete(e);
     if (n) n(i);
     else if (e.Oe) {
-      const t = e.le !== NOT_PENDING;
-      if (e.k) e.le = i;
+      const t = e.ce !== NOT_PENDING;
+      if (e.L) e.ce = i;
       if (!t) {
-        e.ae = i;
+        e.le = i;
         insertSubs(e);
       }
-      e.ee = clock;
+      e.J = clock;
     } else if (o) {
-      const t = e.ae;
+      const t = e.le;
       const n = e._e;
       if (!n || !n(i, t)) {
-        e.ae = i;
-        e.ee = clock;
+        e.le = i;
+        e.J = clock;
         if (e.Ie) {
           setSignal(e.Ie, i);
         }
@@ -598,7 +598,7 @@ function handleAsync(e, t, n) {
     );
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.ie);
+      globalQueue.initTransition(e.ne);
       throw new NotReadyError(context);
     }
   }
@@ -630,36 +630,36 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.ie);
+      globalQueue.initTransition(e.ne);
       throw new NotReadyError(context);
     }
   }
   return s;
 }
 function clearStatus(e) {
-  e.fe = e.fe & STATUS_UNINITIALIZED;
-  e.Z = null;
+  e.ae = e.ae & STATUS_UNINITIALIZED;
+  e.q = null;
   updatePendingSignal(e);
   e.pe?.();
 }
 function notifyStatus(e, t, n, i, r) {
   if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
     n = new StatusError(e, n);
-  const o = n instanceof NotReadyError && n.t === e;
+  const o = n instanceof NotReadyError && n.source === e;
   const s = t === STATUS_PENDING && e.Oe && !o;
   const u = s && hasActiveOverride(e);
   if (!i) {
-    e.fe = t | (t !== STATUS_ERROR ? e.fe & STATUS_UNINITIALIZED : 0);
-    e.Z = n;
+    e.ae = t | (t !== STATUS_ERROR ? e.ae & STATUS_UNINITIALIZED : 0);
+    e.q = n;
     updatePendingSignal(e);
   }
   if (r && !i) {
     assignOrMergeLane(e, r);
   }
   if (u && activeTransition && n instanceof NotReadyError) {
-    const e = n.t;
-    if (!activeTransition.J.includes(e)) {
-      activeTransition.J.push(e);
+    const e = n.source;
+    if (!activeTransition.Z.includes(e)) {
+      activeTransition.Z.push(e);
     }
   }
   const c = i || u;
@@ -672,19 +672,19 @@ function notifyStatus(e, t, n, i, r) {
     }
     return;
   }
-  for (let i = e.p; i !== null; i = i.h) {
-    i.A.ee = clock;
-    if (i.A.Z !== n) {
-      !i.A.ie && globalQueue.H.push(i.A);
-      notifyStatus(i.A, t, n, c, l);
+  for (let i = e.I; i !== null; i = i.p) {
+    i.h.J = clock;
+    if (i.h.q !== n) {
+      !i.h.ne && globalQueue.$.push(i.h);
+      notifyStatus(i.h, t, n, c, l);
     }
   }
-  for (let i = e.P; i !== null; i = i.C) {
-    for (let e = i.p; e !== null; e = e.h) {
-      e.A.ee = clock;
-      if (e.A.Z !== n) {
-        !e.A.ie && globalQueue.H.push(e.A);
-        notifyStatus(e.A, t, n, c, l);
+  for (let i = e.A; i !== null; i = i.P) {
+    for (let e = i.I; e !== null; e = e.p) {
+      e.h.J = clock;
+      if (e.h.q !== n) {
+        !e.h.ne && globalQueue.$.push(e.h);
+        notifyStatus(e.h, t, n, c, l);
       }
     }
   }
@@ -694,8 +694,8 @@ function effect(e, t, n, i, r) {
   const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
     ...r,
     equals: () => {
-      s.se = !s.Z;
-      if (o) s.ue.enqueue(s.oe, runEffect.bind(s));
+      s.oe = !s.q;
+      if (o) s.se.enqueue(s.re, runEffect.bind(s));
       return false;
     },
     lazy: true
@@ -704,14 +704,14 @@ function effect(e, t, n, i, r) {
   s.Ae = t;
   s.ge = n;
   s.Pe = undefined;
-  s.oe = r?.render ? EFFECT_RENDER : EFFECT_USER;
+  s.re = r?.render ? EFFECT_RENDER : EFFECT_USER;
   s.pe = (e, t) => {
-    const n = e !== undefined ? e : s.fe;
-    const i = t !== undefined ? t : s.Z;
+    const n = e !== undefined ? e : s.ae;
+    const i = t !== undefined ? t : s.q;
     if (n & STATUS_ERROR) {
       let e = i;
-      s.ue.notify(s, STATUS_PENDING, 0);
-      if (s.oe === EFFECT_USER) {
+      s.se.notify(s, STATUS_PENDING, 0);
+      if (s.re === EFFECT_USER) {
         try {
           return s.ge
             ? s.ge(e, () => {
@@ -723,31 +723,31 @@ function effect(e, t, n, i, r) {
           e = t;
         }
       }
-      if (!s.ue.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (s.oe === EFFECT_RENDER) s.ue.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
+      if (!s.se.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
+    } else if (s.re === EFFECT_RENDER) s.se.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
   };
   recompute(s, true);
-  !r?.defer && (s.oe === EFFECT_USER ? s.ue.enqueue(s.oe, runEffect.bind(s)) : runEffect.call(s));
+  !r?.defer && (s.re === EFFECT_USER ? s.se.enqueue(s.re, runEffect.bind(s)) : runEffect.call(s));
   o = true;
   onCleanup(() => s.Pe?.());
 }
 function runEffect() {
-  if (!this.se || this._ & REACTIVE_DISPOSED) return;
+  if (!this.oe || this.S & REACTIVE_DISPOSED) return;
   this.Pe?.();
   this.Pe = undefined;
   try {
-    this.Pe = this.Ae(this.ae, this.he);
+    this.Pe = this.Ae(this.le, this.he);
   } catch (e) {
-    if (!this.ue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+    if (!this.se.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.he = this.ae;
-    this.se = false;
+    this.he = this.le;
+    this.oe = false;
   }
 }
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.se || n._ & REACTIVE_DISPOSED) return;
-    n.se = false;
+    if (!n.oe || n.S & REACTIVE_DISPOSED) return;
+    n.oe = false;
     recompute(n);
   };
   const n = computed(
@@ -763,18 +763,18 @@ function trackedEffect(e, t) {
     { ...t, lazy: true, pureWrite: true }
   );
   n.Pe = undefined;
-  n.se = true;
-  n.oe = EFFECT_TRACKED;
-  n.ce = run;
-  n.ue.enqueue(EFFECT_USER, run);
+  n.oe = true;
+  n.re = EFFECT_TRACKED;
+  n.ue = run;
+  n.se.enqueue(EFFECT_USER, run);
   onCleanup(() => n.Pe?.());
 }
 const PENDING_OWNER = {};
 function markDisposal(e) {
   let t = e.Ce;
   while (t) {
-    t._ |= REACTIVE_ZOMBIE;
-    if (t._ & REACTIVE_IN_HEAP) {
+    t.S |= REACTIVE_ZOMBIE;
+    if (t.S & REACTIVE_IN_HEAP) {
       deleteFromHeap(t, dirtyQueue);
       insertIntoHeap(t, zombieQueue);
     }
@@ -783,28 +783,28 @@ function markDisposal(e) {
   }
 }
 function dispose(e) {
-  let t = e.D || null;
+  let t = e.N || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.D = null;
+  e.N = null;
   e.ye = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e._ & REACTIVE_DISPOSED) return;
-  if (t) e._ = REACTIVE_DISPOSED;
+  if (e.S & REACTIVE_DISPOSED) return;
+  if (t) e.S = REACTIVE_DISPOSED;
   let i = n ? e.De : e.Ce;
   while (i) {
     const e = i.Ne;
-    if (i.D) {
+    if (i.N) {
       const e = i;
-      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.D;
+      deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.N;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.D = null;
+      e.N = null;
       e.ye = null;
     }
     disposeChildren(i, true);
@@ -858,17 +858,17 @@ function createOwner(e) {
   const t = context;
   const n = {
     id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
-    i: true,
-    l: t?.i ? t.l : t,
+    t: true,
+    u: t?.t ? t.u : t,
     Ce: null,
     Ne: null,
     we: null,
-    ue: t?.ue ?? globalQueue,
+    se: t?.se ?? globalQueue,
     Ve: t?.Ve || defaultContext,
     be: 0,
     ve: null,
     De: null,
-    o: t,
+    i: t,
     dispose(e = true) {
       disposeChildren(n, e);
     }
@@ -889,65 +889,65 @@ function createRoot(e, t) {
   return runWithOwner(n, () => e(n.dispose));
 }
 function unlinkSubs(e) {
-  const t = e.m;
-  const n = e.V;
-  const i = e.h;
+  const t = e.V;
+  const n = e.D;
+  const i = e.p;
   const r = e.me;
   if (i !== null) i.me = r;
   else t.Le = r;
-  if (r !== null) r.h = i;
+  if (r !== null) r.p = i;
   else {
-    t.p = i;
+    t.I = i;
     if (i === null) {
       t.ke?.();
-      t.k && !t.Ue && unobserved(t);
+      t.L && !t.Ue && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
-  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let t = e.D;
+  deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.N;
   while (t !== null) {
     t = unlinkSubs(t);
   }
-  e.D = null;
+  e.N = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
   const n = t.ye;
-  if (n !== null && n.m === e) return;
+  if (n !== null && n.V === e) return;
   let i = null;
-  const r = t._ & REACTIVE_RECOMPUTING_DEPS;
+  const r = t.S & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
-    i = n !== null ? n.V : t.D;
-    if (i !== null && i.m === e) {
+    i = n !== null ? n.D : t.N;
+    if (i !== null && i.V === e) {
       t.ye = i;
       return;
     }
   }
   const o = e.Le;
-  if (o !== null && o.A === t && (!r || isValidLink(o, t))) return;
-  const s = (t.ye = e.Le = { m: e, A: t, V: i, me: o, h: null });
-  if (n !== null) n.V = s;
-  else t.D = s;
-  if (o !== null) o.h = s;
-  else e.p = s;
+  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
+  const s = (t.ye = e.Le = { V: e, h: t, D: i, me: o, p: null });
+  if (n !== null) n.D = s;
+  else t.N = s;
+  if (o !== null) o.p = s;
+  else e.I = s;
 }
 function isValidLink(e, t) {
   const n = t.ye;
   if (n !== null) {
-    let i = t.D;
+    let i = t.N;
     do {
       if (i === e) return true;
       if (i === n) break;
-      i = i.V;
+      i = i.D;
     } while (i !== null);
   }
   return false;
 }
-GlobalQueue.Y = recompute;
-GlobalQueue.B = disposeChildren;
+GlobalQueue.K = recompute;
+GlobalQueue.Y = disposeChildren;
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -957,12 +957,12 @@ let pendingReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
 function recompute(e, t = false) {
-  const n = e.oe;
+  const n = e.re;
   if (!t) {
-    if (e.ie && (!n || activeTransition) && activeTransition !== e.ie)
-      globalQueue.initTransition(e.ie);
-    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.ie || n === EFFECT_TRACKED) disposeChildren(e);
+    if (e.ne && (!n || activeTransition) && activeTransition !== e.ne)
+      globalQueue.initTransition(e.ne);
+    deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (e.ne || n === EFFECT_TRACKED) disposeChildren(e);
     else {
       markDisposal(e);
       e.ve = e.we;
@@ -971,16 +971,16 @@ function recompute(e, t = false) {
       e.Ce = null;
     }
   }
-  const i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
+  const i = !!(e.S & REACTIVE_OPTIMISTIC_DIRTY);
   const r = hasActiveOverride(e);
-  const o = !!(e.fe & STATUS_PENDING);
+  const o = !!(e.ae & STATUS_PENDING);
   const s = context;
   context = e;
   e.ye = null;
-  e._ = REACTIVE_RECOMPUTING_DEPS;
-  e.ee = clock;
-  let u = e.le === NOT_PENDING ? e.ae : e.le;
-  let c = e.u;
+  e.S = REACTIVE_RECOMPUTING_DEPS;
+  e.J = clock;
+  let u = e.ce === NOT_PENDING ? e.le : e.ce;
+  let c = e.o;
   let l = tracking;
   let a = currentOptimisticLane;
   tracking = true;
@@ -989,20 +989,20 @@ function recompute(e, t = false) {
     if (t) currentOptimisticLane = t;
   }
   try {
-    u = handleAsync(e, e.k(u));
+    u = handleAsync(e, e.L(u));
     clearStatus(e);
     const t = resolveLane(e);
     if (t) {
-      t.W.delete(e);
-      updatePendingSignal(t.t);
+      t.U.delete(e);
+      updatePendingSignal(t.fe);
     }
   } catch (t) {
     if (t instanceof NotReadyError && currentOptimisticLane) {
       const t = findLane(currentOptimisticLane);
-      if (t.t !== e) {
-        t.W.add(e);
-        e.re = t;
-        updatePendingSignal(t.t);
+      if (t.fe !== e) {
+        t.U.add(e);
+        e.ie = t;
+        updatePendingSignal(t.fe);
       }
     }
     notifyStatus(
@@ -1010,66 +1010,66 @@ function recompute(e, t = false) {
       t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
       t,
       undefined,
-      t instanceof NotReadyError ? e.re : undefined
+      t instanceof NotReadyError ? e.ie : undefined
     );
   } finally {
     tracking = l;
-    e._ = REACTIVE_NONE;
+    e.S = REACTIVE_NONE;
     context = s;
   }
-  if (!e.Z) {
+  if (!e.q) {
     const s = e.ye;
-    let l = s !== null ? s.V : e.D;
+    let l = s !== null ? s.D : e.N;
     if (l !== null) {
       do {
         l = unlinkSubs(l);
       } while (l !== null);
-      if (s !== null) s.V = null;
-      else e.D = null;
+      if (s !== null) s.D = null;
+      else e.N = null;
     }
-    const a = r ? e.ae : e.le === NOT_PENDING ? e.ae : e.le;
+    const a = r ? e.le : e.ce === NOT_PENDING ? e.le : e.ce;
     const f = !e._e || !e._e(a, u);
     if (f) {
-      const s = r ? e.ae : undefined;
-      if (t || (n && activeTransition !== e.ie) || i) e.ae = u;
-      else e.le = u;
+      const s = r ? e.le : undefined;
+      if (t || (n && activeTransition !== e.ne) || i) e.le = u;
+      else e.ce = u;
       if (r && !i && o) {
         const t = e.Re || 0;
         const n = e.de || 0;
-        if (t <= n) e.ae = u;
+        if (t <= n) e.le = u;
       }
-      if (!r || i || e.ae !== s) {
+      if (!r || i || e.le !== s) {
         insertSubs(e, i || r);
       }
     } else if (r) {
-      e.le = u;
-    } else if (e.u != c) {
-      for (let t = e.p; t !== null; t = t.h) {
-        insertIntoHeapHeight(t.A, t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      e.ce = u;
+    } else if (e.o != c) {
+      for (let t = e.I; t !== null; t = t.p) {
+        insertIntoHeapHeight(t.h, t.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       }
     }
   }
   currentOptimisticLane = a;
-  (!t || e.fe & STATUS_PENDING) && !e.ie && !(activeTransition && e.Oe) && globalQueue.H.push(e);
-  e.ie && n && activeTransition !== e.ie && runInTransition(e.ie, () => recompute(e));
+  (!t || e.ae & STATUS_PENDING) && !e.ne && !(activeTransition && e.Oe) && globalQueue.$.push(e);
+  e.ne && n && activeTransition !== e.ne && runInTransition(e.ne, () => recompute(e));
 }
 function updateIfNecessary(e) {
-  if (e._ & REACTIVE_CHECK) {
-    for (let t = e.D; t; t = t.V) {
-      const n = t.m;
-      const i = n.L || n;
-      if (i.k) {
+  if (e.S & REACTIVE_CHECK) {
+    for (let t = e.N; t; t = t.D) {
+      const n = t.V;
+      const i = n.m || n;
+      if (i.L) {
         updateIfNecessary(i);
       }
-      if (e._ & REACTIVE_DIRTY) {
+      if (e.S & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.Z && e.ee < clock)) {
+  if (e.S & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.q && e.J < clock)) {
     recompute(e);
   }
-  e._ = REACTIVE_NONE;
+  e.S = REACTIVE_NONE;
 }
 function computed(e, t, n) {
   const i = {
@@ -1078,33 +1078,33 @@ function computed(e, t, n) {
     We: !!n?.pureWrite,
     ke: n?.unobserved,
     we: null,
-    ue: context?.ue ?? globalQueue,
+    se: context?.se ?? globalQueue,
     Ve: context?.Ve ?? defaultContext,
     be: 0,
-    k: e,
-    ae: t,
-    u: 0,
-    P: null,
-    O: undefined,
-    R: null,
-    D: null,
+    L: e,
+    le: t,
+    o: 0,
+    A: null,
+    R: undefined,
+    T: null,
+    N: null,
     ye: null,
-    p: null,
+    I: null,
     Le: null,
-    o: context,
+    i: context,
     Ne: null,
     Ce: null,
-    _: REACTIVE_NONE,
-    fe: STATUS_UNINITIALIZED,
-    ee: clock,
-    le: NOT_PENDING,
+    S: REACTIVE_NONE,
+    ae: STATUS_UNINITIALIZED,
+    J: clock,
+    ce: NOT_PENDING,
     ve: null,
     De: null,
     Se: null,
-    ie: null
+    ne: null
   };
-  i.R = i;
-  const r = context?.i ? context.l : context;
+  i.T = i;
+  const r = context?.t ? context.u : context;
   if (context) {
     const e = context.Ce;
     if (e === null) {
@@ -1114,7 +1114,7 @@ function computed(e, t, n) {
       context.Ce = i;
     }
   }
-  if (r) i.u = r.u + 1;
+  if (r) i.o = r.o + 1;
   !n?.lazy && recompute(i, true);
   return i;
 }
@@ -1123,15 +1123,15 @@ function signal(e, t, n = null) {
     _e: t?.equals != null ? t.equals : isEqual,
     We: !!t?.pureWrite,
     ke: t?.unobserved,
-    ae: e,
-    p: null,
+    le: e,
+    I: null,
     Le: null,
-    ee: clock,
-    L: n,
-    C: n?.P || null,
-    le: NOT_PENDING
+    J: clock,
+    m: n,
+    P: n?.A || null,
+    ce: NOT_PENDING
   };
-  n && (n.P = i);
+  n && (n.A = i);
   return i;
 }
 function optimisticSignal(e, t) {
@@ -1163,18 +1163,18 @@ function read(e) {
     pendingReadActive = false;
     const i = read(t);
     pendingReadActive = n;
-    if (t.fe & STATUS_PENDING) return e.ae;
-    if (stale && currentOptimisticLane && t.re) {
-      const n = findLane(t.re);
+    if (t.ae & STATUS_PENDING) return e.le;
+    if (stale && currentOptimisticLane && t.ie) {
+      const n = findLane(t.ie);
       const i = findLane(currentOptimisticLane);
-      if (n !== i && n.W.size > 0) {
-        return e.ae;
+      if (n !== i && n.U.size > 0) {
+        return e.le;
       }
     }
     return i;
   }
   if (pendingCheckActive) {
-    const t = e.L || e;
+    const t = e.m || e;
     const n = getPendingSignal(t);
     const i = pendingCheckActive;
     pendingCheckActive = false;
@@ -1182,92 +1182,92 @@ function read(e) {
       foundPending = true;
     }
     pendingCheckActive = i;
-    return e.ae;
+    return e.le;
   }
   let t = context;
-  if (t?.i) t = t.l;
-  if (refreshing && e.k) recompute(e);
+  if (t?.t) t = t.u;
+  if (refreshing && e.L) recompute(e);
   if (t && tracking) {
-    if (e.k && e._ & REACTIVE_DISPOSED) recompute(e);
+    if (e.L && e.S & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    const n = e.L || e;
-    if (n.k) {
-      const i = e._ & REACTIVE_ZOMBIE;
-      if (n.u >= (i ? zombieQueue.N : dirtyQueue.N)) {
+    const n = e.m || e;
+    if (n.L) {
+      const i = e.S & REACTIVE_ZOMBIE;
+      if (n.o >= (i ? zombieQueue.C : dirtyQueue.C)) {
         markNode(t);
         markHeap(i ? zombieQueue : dirtyQueue);
         updateIfNecessary(n);
       }
-      const r = n.u;
-      if (r >= t.u && e.o !== t) {
-        t.u = r + 1;
+      const r = n.o;
+      if (r >= t.o && e.i !== t) {
+        t.o = r + 1;
       }
     }
   }
-  const n = e.L || e;
-  if (t && n.fe & STATUS_PENDING && !(stale && n.ie && activeTransition !== n.ie)) {
+  const n = e.m || e;
+  if (t && n.ae & STATUS_PENDING && !(stale && n.ne && activeTransition !== n.ne)) {
     if (currentOptimisticLane) {
-      const i = n.re;
+      const i = n.ie;
       const r = findLane(currentOptimisticLane);
       if (i && findLane(i) === r && !hasActiveOverride(n)) {
         if (!tracking) link(e, t);
-        throw n.Z;
+        throw n.q;
       }
     } else {
       if (!tracking) link(e, t);
-      throw n.Z;
+      throw n.q;
     }
   }
-  if (e.k && e.fe & STATUS_ERROR) {
-    if (e.ee < clock) {
+  if (e.L && e.ae & STATUS_ERROR) {
+    if (e.J < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.Z;
+    } else throw e.q;
   }
   return !t ||
     currentOptimisticLane !== null ||
-    e.le === NOT_PENDING ||
-    (stale && e.ie && activeTransition !== e.ie)
-    ? e.ae
-    : e.le;
+    e.ce === NOT_PENDING ||
+    (stale && e.ne && activeTransition !== e.ne)
+    ? e.le
+    : e.ce;
 }
 function setSignal(e, t) {
-  if (e.ie && activeTransition !== e.ie) globalQueue.initTransition(e.ie);
+  if (e.ne && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
   const n = e.Oe && !projectionWriteActive;
-  const i = n ? e.ae : e.le === NOT_PENDING ? e.ae : e.le;
+  const i = n ? e.le : e.ce === NOT_PENDING ? e.le : e.ce;
   if (typeof t === "function") t = t(i);
   const r = !e._e || !e._e(i, t);
   if (!r) {
-    if (n && e.le !== NOT_PENDING && e.k) {
+    if (n && e.ce !== NOT_PENDING && e.L) {
       insertSubs(e, true);
       schedule();
     }
     return t;
   }
   if (n) {
-    const n = globalQueue.j.includes(e);
-    if (e.ie && n) {
-      globalQueue.initTransition(e.ie);
+    const n = globalQueue.H.includes(e);
+    if (e.ne && n) {
+      globalQueue.initTransition(e.ne);
     }
-    if (e.le === NOT_PENDING) {
-      e.le = e.ae;
+    if (e.ce === NOT_PENDING) {
+      e.ce = e.le;
     }
     if (!n) {
-      globalQueue.j.push(e);
+      globalQueue.H.push(e);
     }
     e.Re = (e.Re || 0) + 1;
     const i = getOrCreateLane(e);
-    e.re = i;
-    e.ae = t;
-  } else {
-    if (e.le === NOT_PENDING) globalQueue.H.push(e);
+    e.ie = i;
     e.le = t;
+  } else {
+    if (e.ce === NOT_PENDING) globalQueue.$.push(e);
+    e.ce = t;
   }
   updatePendingSignal(e);
   if (e.Ie) {
     setSignal(e.Ie, t);
   }
-  e.ee = clock;
+  e.J = clock;
   insertSubs(e, n);
   schedule();
   return t;
@@ -1296,32 +1296,32 @@ function getPendingSignal(e) {
 }
 function computePendingState(e) {
   const t = e;
-  if (e.Oe && e.le !== NOT_PENDING) {
-    if (t.fe & STATUS_PENDING && !(t.fe & STATUS_UNINITIALIZED)) return true;
+  if (e.Oe && e.ce !== NOT_PENDING) {
+    if (t.ae & STATUS_PENDING && !(t.ae & STATUS_UNINITIALIZED)) return true;
     if (e.Ee) {
-      const t = e.re ? findLane(e.re) : null;
-      return !!(t && t.W.size > 0);
+      const t = e.ie ? findLane(e.ie) : null;
+      return !!(t && t.U.size > 0);
     }
     return true;
   }
-  if (e.le !== NOT_PENDING && !(t.fe & STATUS_UNINITIALIZED)) return true;
-  return !!(t.fe & STATUS_PENDING && !(t.fe & STATUS_UNINITIALIZED));
+  if (e.ce !== NOT_PENDING && !(t.ae & STATUS_UNINITIALIZED)) return true;
+  return !!(t.ae & STATUS_PENDING && !(t.ae & STATUS_UNINITIALIZED));
 }
 function updatePendingSignal(e) {
   if (e.Qe) {
     const t = computePendingState(e);
     const n = e.Qe;
     setSignal(n, t);
-    if (!t && n.re) {
+    if (!t && n.ie) {
       const t = resolveLane(e);
-      if (t && t.W.size > 0) {
-        const e = findLane(n.re);
+      if (t && t.U.size > 0) {
+        const e = findLane(n.ie);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
       signalLanes.delete(n);
-      n.re = undefined;
+      n.ie = undefined;
     }
   }
 }
@@ -1430,11 +1430,11 @@ function action(e) {
       const r = e(...t);
       globalQueue.initTransition();
       let o = activeTransition;
-      o.te.push(r);
+      o.ee.push(r);
       const done = (e, t) => {
         o = currentTransition(o);
-        const s = o.te.indexOf(r);
-        if (s >= 0) o.te.splice(s, 1);
+        const s = o.ee.indexOf(r);
+        if (s >= 0) o.ee.splice(s, 1);
         setActiveTransition(o);
         schedule();
         t ? i(t) : n(e);
@@ -1533,7 +1533,8 @@ function onSettled(e) {
 function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
 }
-function getOverrideValue(e, t, n, i) {
+function getOverrideValue(e, t, n, i, r) {
+  if (r && i in r) return r[i];
   return t && i in t ? t[i] : e[i];
 }
 function getAllKeys(e, t, n) {
@@ -1546,110 +1547,112 @@ function applyState(e, t, n, i) {
   if (!r) return;
   const o = r[STORE_VALUE];
   const s = r[STORE_OVERRIDE];
-  let u = r[STORE_NODE];
-  if (e === o && !s) return;
+  const u = r[STORE_OPTIMISTIC_OVERRIDE];
+  let c = r[STORE_NODE];
+  if (e === o && !s && !u) return;
   (r[STORE_LOOKUP] || storeLookup).set(e, r[$PROXY]);
   r[STORE_VALUE] = e;
   r[STORE_OVERRIDE] = undefined;
   if (Array.isArray(o)) {
     let t = false;
-    const c = getOverrideValue(o, s, u, "length");
-    if (e.length && c && e[0] && n(e[0]) != null) {
-      let l, a, f, E, T, d, R, O;
+    const l = getOverrideValue(o, s, c, "length", u);
+    if (e.length && l && e[0] && n(e[0]) != null) {
+      let a, f, E, T, d, R, O, S;
       for (
-        f = 0, E = Math.min(c, e.length);
-        f < E && ((d = getOverrideValue(o, s, u, f)) === e[f] || (d && e[f] && n(d) === n(e[f])));
-        f++
+        E = 0, T = Math.min(l, e.length);
+        E < T &&
+        ((R = getOverrideValue(o, s, c, E, u)) === e[E] || (R && e[E] && n(R) === n(e[E])));
+        E++
       ) {
-        applyState(e[f], wrap(d, r), n, i);
+        applyState(e[E], wrap(R, r), n, i);
       }
-      const S = new Array(e.length),
-        _ = new Map();
+      const _ = new Array(e.length),
+        I = new Map();
       for (
-        E = c - 1, T = e.length - 1;
-        E >= f &&
-        T >= f &&
-        ((d = getOverrideValue(o, s, u, E)) === e[T] || (d && e[T] && n(d) === n(e[T])));
-        E--, T--
+        T = l - 1, d = e.length - 1;
+        T >= E &&
+        d >= E &&
+        ((R = getOverrideValue(o, s, c, T, u)) === e[d] || (R && e[d] && n(R) === n(e[d])));
+        T--, d--
       ) {
-        S[T] = d;
+        _[d] = R;
       }
-      if (f > T || f > E) {
-        for (a = f; a <= T; a++) {
+      if (E > d || E > T) {
+        for (f = E; f <= d; f++) {
           t = true;
-          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
+          r[STORE_NODE][f] && setSignal(r[STORE_NODE][f], wrap(e[f], r));
         }
-        for (; a < e.length; a++) {
+        for (; f < e.length; f++) {
           t = true;
-          const o = wrap(S[a], r);
-          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], o);
-          applyState(e[a], o, n, i);
+          const o = wrap(_[f], r);
+          r[STORE_NODE][f] && setSignal(r[STORE_NODE][f], o);
+          applyState(e[f], o, n, i);
         }
         t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
-        c !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
+        l !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
         return;
       }
-      R = new Array(T + 1);
-      for (a = T; a >= f; a--) {
-        d = e[a];
-        O = d ? n(d) : d;
-        l = _.get(O);
-        R[a] = l === undefined ? -1 : l;
-        _.set(O, a);
-      }
-      for (l = f; l <= E; l++) {
-        d = getOverrideValue(o, s, u, l);
-        O = d ? n(d) : d;
-        a = _.get(O);
-        if (a !== undefined && a !== -1) {
-          S[a] = d;
-          a = R[a];
-          _.set(O, a);
+      O = new Array(d + 1);
+      for (f = d; f >= E; f--) {
+        R = e[f];
+        S = R ? n(R) : R;
+        a = I.get(S);
+        O[f] = a === undefined ? -1 : a;
+        I.set(S, f);
+      }
+      for (a = E; a <= T; a++) {
+        R = getOverrideValue(o, s, c, a, u);
+        S = R ? n(R) : R;
+        f = I.get(S);
+        if (f !== undefined && f !== -1) {
+          _[f] = R;
+          f = O[f];
+          I.set(S, f);
         }
       }
-      for (a = f; a < e.length; a++) {
-        if (a in S) {
-          const t = wrap(S[a], r);
-          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], t);
-          applyState(e[a], t, n, i);
-        } else r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
+      for (f = E; f < e.length; f++) {
+        if (f in _) {
+          const t = wrap(_[f], r);
+          r[STORE_NODE][f] && setSignal(r[STORE_NODE][f], t);
+          applyState(e[f], t, n, i);
+        } else r[STORE_NODE][f] && setSignal(r[STORE_NODE][f], wrap(e[f], r));
       }
-      if (f < e.length) t = true;
+      if (E < e.length) t = true;
     } else if (e.length) {
-      for (let t = 0, c = e.length; t < c; t++) {
-        const c = getOverrideValue(o, s, u, t);
-        isWrappable(c)
-          ? applyState(e[t], wrap(c, r), n, i)
+      for (let t = 0, l = e.length; t < l; t++) {
+        const l = getOverrideValue(o, s, c, t, u);
+        isWrappable(l)
+          ? applyState(e[t], wrap(l, r), n, i)
           : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
       }
     }
-    if (c !== e.length) {
+    if (l !== e.length) {
       t = true;
       r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
     }
     t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
     return;
   }
-  if (u) {
-    const t = u[$TRACK];
-    const c = t || i ? getAllKeys(o, s, e) : Object.keys(u);
-    for (let l = 0, a = c.length; l < a; l++) {
-      const a = c[l];
-      const f = u[a];
-      const E = unwrap(getOverrideValue(o, s, u, a));
-      let T = unwrap(e[a]);
-      if (E === T) continue;
-      if (!E || !isWrappable(E) || !isWrappable(T) || (n(E) != null && n(E) !== n(T))) {
+  if (c) {
+    const t = c[$TRACK];
+    const l = t || i ? getAllKeys(o, s, e) : Object.keys(c);
+    for (let a = 0, f = l.length; a < f; a++) {
+      const f = l[a];
+      const E = c[f];
+      const T = unwrap(getOverrideValue(o, s, c, f, u));
+      let d = unwrap(e[f]);
+      if (T === d) continue;
+      if (!T || !isWrappable(T) || !isWrappable(d) || (n(T) != null && n(T) !== n(d))) {
         t && setSignal(t, void 0);
-        f && setSignal(f, isWrappable(T) ? wrap(T, r) : T);
-      } else applyState(T, wrap(E, r), n, i);
+        E && setSignal(E, isWrappable(d) ? wrap(d, r) : d);
+      } else applyState(d, wrap(T, r), n, i);
     }
   }
-  if ((u = r[STORE_HAS])) {
-    const t = Object.keys(u);
+  if ((c = r[STORE_HAS])) {
+    const t = Object.keys(c);
     for (let n = 0, i = t.length; n < i; n++) {
       const i = t[n];
-      setSignal(u[i], i in e);
+      setSignal(c[i], i in e);
     }
   }
 }
@@ -1847,7 +1850,7 @@ const storeTraps = {
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = r && (s || !u) ? (r.le !== NOT_PENDING ? (r.Oe ? r.ae : r.le) : r.ae) : c[t];
+      let n = r && (s || !u) ? (r.ce !== NOT_PENDING ? (r.Oe ? r.le : r.ce) : r.le) : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
@@ -1896,8 +1899,8 @@ const storeTraps = {
     if (writeOnly(i)) {
       if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.ie) {
-          globalQueue.initTransition(t.ie);
+        if (t?.ne) {
+          globalQueue.initTransition(t.ne);
         }
       }
       untrack(() => {
@@ -2086,7 +2089,7 @@ function deep(e) {
   return e[$DEEP];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.X ||= clearOptimisticStore;
+  GlobalQueue.B ||= clearOptimisticStore;
   const i = typeof e === "function";
   const r = (i ? t : e) ?? {};
   const o = i ? e : undefined;
@@ -2103,7 +2106,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].re = undefined;
+          i[e].ie = undefined;
           const n =
             t[STORE_OVERRIDE] && e in t[STORE_OVERRIDE] ? t[STORE_OVERRIDE][e] : t[STORE_VALUE][e];
           const r = n === $DELETED ? undefined : n;
@@ -2111,7 +2114,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].re = undefined;
+        i[$TRACK].ie = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2347,9 +2350,9 @@ function mapArray(e, t, n) {
   return createMemo(
     updateKeyedMap.bind({
       xe: createOwner(),
-      Fe: 0,
-      Ge: e,
-      Me: [],
+      Me: 0,
+      Fe: e,
+      Ge: [],
       $e: t,
       He: [],
       je: [],
@@ -2362,7 +2365,7 @@ function mapArray(e, t, n) {
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.Ge() || [],
+  const e = this.Fe() || [],
     t = e.length;
   e[$TRACK];
   runWithOwner(this.xe, () => {
@@ -2388,26 +2391,26 @@ function updateKeyedMap() {
               return this.$e(() => t);
             };
     if (t === 0) {
-      if (this.Fe !== 0) {
+      if (this.Me !== 0) {
         this.xe.dispose(false);
         this.je = [];
-        this.Me = [];
+        this.Ge = [];
         this.He = [];
-        this.Fe = 0;
+        this.Me = 0;
         this.Ye && (this.Ye = []);
         this.Be && (this.Be = []);
       }
       if (this.Xe && !this.He[0]) {
         this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
       }
-    } else if (this.Fe === 0) {
+    } else if (this.Me === 0) {
       if (this.je[0]) this.je[0].dispose();
       this.He = new Array(t);
       for (i = 0; i < t; i++) {
-        this.Me[i] = e[i];
+        this.Ge[i] = e[i];
         this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
       }
-      this.Fe = t;
+      this.Me = t;
     } else {
       let o,
         s,
@@ -2421,17 +2424,17 @@ function updateKeyedMap() {
         d = this.Ye ? new Array(t) : undefined,
         R = this.Be ? new Array(t) : undefined;
       for (
-        o = 0, s = Math.min(this.Fe, t);
-        o < s && (this.Me[o] === e[o] || (this.Ye && compare(this.Ke, this.Me[o], e[o])));
+        o = 0, s = Math.min(this.Me, t);
+        o < s && (this.Ge[o] === e[o] || (this.Ye && compare(this.Ke, this.Ge[o], e[o])));
         o++
       ) {
         if (this.Ye) setSignal(this.Ye[o], e[o]);
       }
       for (
-        s = this.Fe - 1, u = t - 1;
+        s = this.Me - 1, u = t - 1;
         s >= o &&
         u >= o &&
-        (this.Me[s] === e[u] || (this.Ye && compare(this.Ke, this.Me[s], e[u])));
+        (this.Ge[s] === e[u] || (this.Ye && compare(this.Ke, this.Ge[s], e[u])));
         s--, u--
       ) {
         E[u] = this.He[s];
@@ -2449,7 +2452,7 @@ function updateKeyedMap() {
         a.set(l, i);
       }
       for (n = o; n <= s; n++) {
-        c = this.Me[n];
+        c = this.Ge[n];
         l = this.Ke ? this.Ke(c) : c;
         i = a.get(l);
         if (i !== undefined && i !== -1) {
@@ -2477,8 +2480,8 @@ function updateKeyedMap() {
           this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
         }
       }
-      this.He = this.He.slice(0, (this.Fe = t));
-      this.Me = e.slice(0);
+      this.He = this.He.slice(0, (this.Me = t));
+      this.Ge = e.slice(0);
     }
   });
   return this.He;
@@ -2486,7 +2489,7 @@ function updateKeyedMap() {
 function repeat(e, t, n) {
   return updateRepeat.bind({
     xe: createOwner(),
-    Fe: 0,
+    Me: 0,
     qe: 0,
     ze: e,
     $e: t,
@@ -2501,11 +2504,11 @@ function updateRepeat() {
   const t = this.Ze?.() || 0;
   runWithOwner(this.xe, () => {
     if (e === 0) {
-      if (this.Fe !== 0) {
+      if (this.Me !== 0) {
         this.xe.dispose(false);
         this.je = [];
         this.He = [];
-        this.Fe = 0;
+        this.Me = 0;
       }
       if (this.Xe && !this.He[0]) {
         this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
@@ -2513,12 +2516,12 @@ function updateRepeat() {
       return;
     }
     const n = t + e;
-    const i = this.qe + this.Fe;
-    if (this.Fe === 0 && this.je[0]) this.je[0].dispose();
+    const i = this.qe + this.Me;
+    if (this.Me === 0 && this.je[0]) this.je[0].dispose();
     for (let e = n; e < i; e++) this.je[e - this.qe].dispose();
     if (this.qe < t) {
       let e = this.qe;
-      while (e < t && e < this.Fe) this.je[e++].dispose();
+      while (e < t && e < this.Me) this.je[e++].dispose();
       this.je.splice(0, t - this.qe);
       this.He.splice(0, t - this.qe);
     } else if (this.qe > t) {
@@ -2539,7 +2542,7 @@ function updateRepeat() {
     }
     this.He = this.He.slice(0, e);
     this.qe = t;
-    this.Fe = e;
+    this.Me = e;
   });
   return this.He;
 }
@@ -2549,10 +2552,10 @@ function compare(e, t, n) {
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, { lazy: true });
   n.pe = (e, t) => {
-    const i = e !== undefined ? e : n.fe;
-    const r = t !== undefined ? t : n.Z;
-    n.fe &= ~n.Je;
-    n.ue.notify(n, n.Je, i, r);
+    const i = e !== undefined ? e : n.ae;
+    const r = t !== undefined ? t : n.q;
+    n.ae &= ~n.Je;
+    n.se.notify(n, n.Je, i, r);
   };
   n.Je = t;
   n.Ue = true;
@@ -2560,9 +2563,9 @@ function boundaryComputed(e, t) {
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.ue;
-  r.addChild((e.ue = n));
-  onCleanup(() => r.removeChild(e.ue));
+  const r = e.se;
+  r.addChild((e.se = n));
+  onCleanup(() => r.removeChild(e.se));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
@@ -2584,7 +2587,7 @@ class CollectionQueue extends Queue {
   notify(e, t, n, i) {
     if (!(t & this.et) || (this.et & STATUS_PENDING && this.it)) return super.notify(e, t, n, i);
     if (n & this.et) {
-      const t = i?.t || e.Z?.t;
+      const t = i?.source || e.q?.source;
       if (t) {
         const e = this.tt.size === 0;
         this.tt.add(t);
@@ -2596,7 +2599,7 @@ class CollectionQueue extends Queue {
   }
   checkSources() {
     for (const e of this.tt) {
-      if (!(e.fe & this.et)) this.tt.delete(e);
+      if (!(e.ae & this.et)) this.tt.delete(e);
     }
     if (!this.tt.size) setSignal(this.nt, false);
   }
@@ -2623,7 +2626,7 @@ function createLoadBoundary(e, t) {
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
     let n = e.tt.values().next().value;
-    const i = n.Z?.cause ?? n.Z;
+    const i = n.q?.cause ?? n.q;
     return t(i, () => {
       for (const t of e.tt) recompute(t);
       schedule();