@solidjs/signals 0.9.11 → 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,182 +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.N !== null) {
-    for (let t = e.N; t !== null; t = t.P) {
-      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.C = 0; e.C <= e.S; e.C++) {
-    let n = e.T[e.C];
+  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.C];
+      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.m) {
+  let n = e.o;
+  for (let t = e.N; t; t = t.D) {
     const e = t.V;
-    const i = e.L || e;
-    if (i.U && i.u >= n) n = i.u + 1;
+    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, C: 0, S: 0 };
-const zombieQueue = { T: new Array(2e3).fill(undefined), I: false, C: 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;
-const signalLanes = new WeakMap();
-const activeLanes = new Set();
-let currentOptimisticLane = null;
-function setCurrentOptimisticLane(e) {
-  currentOptimisticLane = e;
-}
-function getOrCreateLane(e) {
-  let t = signalLanes.get(e);
-  if (t) {
-    return findLane(t);
-  }
-  const n = e.k;
-  const i = n?.W ? findLane(n.W) : null;
-  t = { t: e, G: new Set(), M: [[], []], F: null, $: activeTransition, H: i };
-  signalLanes.set(e, t);
-  activeLanes.add(t);
-  e.j = e.K || 0;
-  return t;
-}
-function findLane(e) {
-  while (e.F) e = e.F;
-  return e;
-}
-function mergeLanes(e, t) {
-  e = findLane(e);
-  t = findLane(t);
-  if (e === t) return e;
-  t.F = e;
-  for (const n of t.G) e.G.add(n);
-  e.M[0].push(...t.M[0]);
-  e.M[1].push(...t.M[1]);
-  return e;
-}
-function clearLaneEntry(e) {
-  signalLanes.delete(e);
-}
-function resolveLane(e) {
-  const t = e.W;
-  if (!t) return undefined;
-  const n = findLane(t);
-  if (activeLanes.has(n)) return n;
-  e.W = undefined;
-  return undefined;
-}
-function hasActiveOverride(e) {
-  return !!(e.Y && e.B !== NOT_PENDING);
-}
-function assignOrMergeLane(e, t) {
-  const n = findLane(t);
-  const i = e.W;
-  if (i) {
-    if (i.F) {
-      e.W = t;
-      return;
-    }
-    const r = findLane(i);
-    if (activeLanes.has(r)) {
-      if (r !== n && !hasActiveOverride(e)) {
-        if (n.H && findLane(n.H) === r) {
-          e.W = t;
-        } else if (r.H && findLane(r.H) === n);
-        else mergeLanes(n, r);
-      }
-      return;
-    }
-  }
-  e.W = t;
-}
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.F || t.G.size > 0) continue;
-    const n = t.M[e - 1];
+    if (t.k || t.U.size > 0) continue;
+    const n = t.W[e - 1];
     if (n.length) {
-      t.M[e - 1] = [];
+      t.W[e - 1] = [];
       runQueue(n, e);
     }
   }
@@ -228,129 +160,129 @@ function setProjectionWriteActive(e) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.X) queueMicrotask(flush);
+  if (!globalQueue.M) queueMicrotask(flush);
 }
 class Queue {
-  o = null;
-  q = [[], []];
-  Z = [];
+  i = null;
+  F = [[], []];
+  G = [];
   created = clock;
   addChild(e) {
-    this.Z.push(e);
-    e.o = this;
+    this.G.push(e);
+    e.i = this;
   }
   removeChild(e) {
-    const t = this.Z.indexOf(e);
+    const t = this.G.indexOf(e);
     if (t >= 0) {
-      this.Z.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.q[e - 1].length) {
-      const t = this.q[e - 1];
-      this.q[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.Z.length; t++) this.Z[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.M[e - 1].push(t);
+        n.W[e - 1].push(t);
       } else {
-        this.q[e - 1].push(t);
+        this.F[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.q[0].push(...this.q[0]);
-    e.q[1].push(...this.q[1]);
-    this.q = [[], []];
-    for (let t = 0; t < this.Z.length; t++) {
-      let n = this.Z[t];
-      let i = e.Z[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 = { q: [[], []], Z: [] };
-        e.Z[t] = i;
+        i = { F: [[], []], G: [] };
+        e.G[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.q[0].push(...e.q[0]);
-    this.q[1].push(...e.q[1]);
-    for (let t = 0; t < e.Z.length; t++) {
-      const n = e.Z[t];
-      let i = this.Z[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 {
-  X = false;
-  J = [];
-  ee = [];
-  te = new Set();
-  static ne;
-  static ie;
-  static re = null;
+  M = false;
+  $ = [];
+  H = [];
+  j = new Set();
+  static K;
+  static Y;
+  static B = null;
   flush() {
-    if (this.X) return;
-    this.X = true;
+    if (this.M) return;
+    this.M = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.ne);
+      runHeap(dirtyQueue, GlobalQueue.K);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
           let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.ne);
-          this.J = [];
-          this.ee = [];
-          this.te = new Set();
+          runHeap(zombieQueue, GlobalQueue.K);
+          this.$ = [];
+          this.H = [];
+          this.j = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition.oe);
+          this.stashQueues(activeTransition.X);
           clock++;
-          scheduled = dirtyQueue.S >= dirtyQueue.C;
-          reassignPendingTransition(activeTransition.J);
+          scheduled = dirtyQueue.O >= dirtyQueue.C;
+          reassignPendingTransition(activeTransition.$);
           activeTransition = null;
           finalizePureQueue(null, true);
           return;
         }
-        this.J !== activeTransition.J && this.J.push(...activeTransition.J);
-        this.restoreQueues(activeTransition.oe);
+        this.$ !== activeTransition.$ && this.$.push(...activeTransition.$);
+        this.restoreQueues(activeTransition.X);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.J);
+        reassignPendingTransition(this.$);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.ne);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.K);
         finalizePureQueue();
       }
       clock++;
-      scheduled = dirtyQueue.S >= dirtyQueue.C;
+      scheduled = dirtyQueue.O >= dirtyQueue.C;
       runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.X = false;
+      this.M = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.se;
-        if (activeTransition && t && !activeTransition.ue.includes(t.t)) {
-          activeTransition.ue.push(t.t);
+        const t = i !== undefined ? i : e.q;
+        if (activeTransition && t && !activeTransition.Z.includes(t.source)) {
+          activeTransition.Z.push(t.source);
           schedule();
         }
       }
@@ -361,143 +293,143 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.ce === clock) return;
+    if (!e && activeTransition && activeTransition.J === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        ce: clock,
-        J: [],
-        ue: [],
+        J: clock,
+        $: [],
+        Z: [],
+        H: [],
+        j: new Set(),
         ee: [],
-        te: new Set(),
-        le: [],
-        oe: { q: [[], []], Z: [] },
-        ae: false
+        X: { F: [[], []], G: [] },
+        te: false
       };
     } else if (e) {
       const t = activeTransition;
-      t.ae = e;
-      e.le.push(...t.le);
+      t.te = e;
+      e.ee.push(...t.ee);
       for (const n of activeLanes) {
-        if (n.$ === t) n.$ = e;
+        if (n.ne === t) n.ne = e;
       }
-      e.ee.push(...t.ee);
-      for (const n of t.te) {
-        e.te.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.ce = clock;
-    for (let e = 0; e < this.J.length; e++) {
-      const t = this.J[e];
-      t.$ = activeTransition;
-      activeTransition.J.push(t);
-    }
-    this.J = activeTransition.J;
-    for (let e = 0; e < this.ee.length; e++) {
-      const t = this.ee[e];
-      t.$ = activeTransition;
-      activeTransition.ee.push(t);
-    }
-    this.ee = activeTransition.ee;
+    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.ne = activeTransition;
+      activeTransition.H.push(t);
+    }
+    this.H = activeTransition.H;
     for (const e of activeLanes) {
-      if (!e.$) e.$ = activeTransition;
+      if (!e.ne) e.ne = activeTransition;
     }
-    for (const e of this.te) activeTransition.te.add(e);
-    this.te = activeTransition.te;
+    for (const e of this.j) activeTransition.j.add(e);
+    this.j = activeTransition.j;
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.W || 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.W = undefined;
+      i.h.S |= REACTIVE_OPTIMISTIC_DIRTY;
+      i.h.ie = undefined;
     }
-    const e = i.A;
-    if (e.fe === EFFECT_TRACKED) {
-      if (!e.Ee) {
-        e.Ee = true;
-        e.Te.enqueue(EFFECT_USER, e.de);
+    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.C > i.A.u) r.C = 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.C) runHeap(dirtyQueue, GlobalQueue.ne);
+  if (dirtyQueue.O >= dirtyQueue.C) runHeap(dirtyQueue, GlobalQueue.K);
   if (n) {
-    const t = globalQueue.J;
+    const t = globalQueue.$;
     for (let e = 0; e < t.length; e++) {
       const n = t[e];
-      if (n.B !== NOT_PENDING) {
-        n.Re = n.B;
-        n.B = NOT_PENDING;
-        if (n.fe && n.fe !== EFFECT_TRACKED) n.Ee = 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.Oe &= ~STATUS_UNINITIALIZED;
-      if (n.U) GlobalQueue.ie(n, false, true);
+      n.ae &= ~STATUS_UNINITIALIZED;
+      if (n.L) GlobalQueue.Y(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.ee : globalQueue.ee;
+    const n = e ? e.H : globalQueue.H;
     for (let e = 0; e < n.length; e++) {
       const t = n[e];
-      const i = t.B;
-      t.W = undefined;
-      if (i !== NOT_PENDING && t.Re !== i) {
-        t.Re = i;
+      const i = t.ce;
+      t.ie = undefined;
+      if (i !== NOT_PENDING && t.le !== i) {
+        t.le = i;
         insertSubs(t, true);
       }
-      t.B = NOT_PENDING;
-      t.$ = null;
+      t.ce = NOT_PENDING;
+      t.ne = null;
     }
     n.length = 0;
-    const i = e ? e.te : globalQueue.te;
-    if (GlobalQueue.re && i.size) {
+    const i = e ? e.j : globalQueue.j;
+    if (GlobalQueue.B && i.size) {
       for (const e of i) {
-        GlobalQueue.re(e);
+        GlobalQueue.B(e);
       }
       i.clear();
       schedule();
     }
     for (const t of activeLanes) {
-      const n = e ? t.$ === e : !t.$;
+      const n = e ? t.ne === e : !t.ne;
       if (!n) continue;
-      if (!t.F) {
-        if (t.M[0].length) runQueue(t.M[0], EFFECT_RENDER);
-        if (t.M[1].length) runQueue(t.M[1], EFFECT_USER);
-      }
-      if (t.t.W === t) t.t.W = undefined;
-      t.G.clear();
-      t.M[0].length = 0;
-      t.M[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.Z) {
+  for (const t of e.G) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.te.add(e);
+  globalQueue.j.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].$ = activeTransition;
+    e[t].ne = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -510,23 +442,26 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.ae) return true;
-  if (e.le.length) return false;
+  if (e.te) return true;
+  if (e.ee.length) return false;
   let t = true;
-  for (let n = 0; n < e.ue.length; n++) {
-    const i = e.ue[n];
-    if (i.Oe & STATUS_PENDING && i.se?.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.ae = true);
+  t && (e.te = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.ae && typeof e.ae === "object") e = e.ae;
+  while (e.te && typeof e.te === "object") e = e.te;
   return e;
 }
+function setActiveTransition(e) {
+  activeTransition = e;
+}
 function runInTransition(e, t) {
   const n = activeTransition;
   try {
@@ -536,196 +471,107 @@ function runInTransition(e, t) {
     activeTransition = n;
   }
 }
-function restoreTransition(e, t) {
-  globalQueue.initTransition(e);
-  const n = t();
-  flush();
-  return n;
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(e) {
+  let t = signalLanes.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.Ee;
+  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 action(e) {
-  return (...t) =>
-    new Promise((n, i) => {
-      const r = e(...t);
-      globalQueue.initTransition();
-      let o = activeTransition;
-      o.le.push(r);
-      const done = (e, t) => {
-        o = currentTransition(o);
-        const s = o.le.indexOf(r);
-        if (s >= 0) o.le.splice(s, 1);
-        activeTransition = o;
-        schedule();
-        t ? i(t) : n(e);
-      };
-      const step = (e, t) => {
-        let n;
-        try {
-          n = t ? r.throw(e) : r.next(e);
-        } catch (e) {
-          return done(undefined, e);
-        }
-        if (n instanceof Promise)
-          return void n.then(run, e => restoreTransition(o, () => step(e, true)));
-        run(n);
-      };
-      const run = e => {
-        if (e.done) return done(e.value);
-        if (e.value instanceof Promise)
-          return void e.value.then(
-            e => restoreTransition(o, () => step(e)),
-            e => restoreTransition(o, () => step(e, true))
-          );
-        restoreTransition(o, () => step(e.value));
-      };
-      step();
-    });
+function findLane(e) {
+  while (e.k) e = e.k;
+  return e;
 }
-GlobalQueue.ne = recompute;
-GlobalQueue.ie = disposeChildren;
-let tracking = false;
-let stale = false;
-let refreshing = false;
-let pendingCheckActive = false;
-let foundPending = false;
-let pendingReadActive = false;
-let context = null;
-function recompute(e, t = false) {
-  const n = e.fe;
-  if (!t) {
-    if (e.$ && (!n || activeTransition) && activeTransition !== e.$)
-      globalQueue.initTransition(e.$);
-    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.$ || n === EFFECT_TRACKED) disposeChildren(e);
-    else {
-      markDisposal(e);
-      e.Se = e._e;
-      e.Ie = e.pe;
-      e._e = null;
-      e.pe = null;
-    }
-  }
-  const i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = hasActiveOverride(e);
-  const o = !!(e.Oe & STATUS_PENDING);
-  const s = context;
-  context = e;
-  e.he = null;
-  e._ = REACTIVE_RECOMPUTING_DEPS;
-  e.ce = clock;
-  let u = e.B === NOT_PENDING ? e.Re : e.B;
-  let c = e.u;
-  let l = tracking;
-  let a = currentOptimisticLane;
-  tracking = true;
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  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.ie;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (activeLanes.has(n)) return n;
+  e.ie = undefined;
+  return undefined;
+}
+function hasActiveOverride(e) {
+  return !!(e.Oe && e.ce !== NOT_PENDING);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const i = e.ie;
   if (i) {
-    const t = resolveLane(e);
-    if (t) setCurrentOptimisticLane(t);
-  }
-  try {
-    u = handleAsync(e, e.U(u));
-    clearStatus(e);
-    const t = resolveLane(e);
-    if (t) {
-      t.G.delete(e);
-      updatePendingSignal(t.t);
-    }
-  } catch (t) {
-    if (t instanceof NotReadyError && currentOptimisticLane) {
-      const t = findLane(currentOptimisticLane);
-      if (t.t !== e) {
-        t.G.add(e);
-        e.W = t;
-        updatePendingSignal(t.t);
-      }
-    }
-    notifyStatus(
-      e,
-      t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
-      t,
-      undefined,
-      t instanceof NotReadyError ? e.W : undefined
-    );
-  } finally {
-    tracking = l;
-    e._ = REACTIVE_NONE;
-    context = s;
-  }
-  if (!e.se) {
-    const s = e.he;
-    let l = s !== null ? s.m : e.D;
-    if (l !== null) {
-      do {
-        l = unlinkSubs(l);
-      } while (l !== null);
-      if (s !== null) s.m = null;
-      else e.D = null;
+    if (i.k) {
+      e.ie = t;
+      return;
     }
-    const a = r ? e.Re : e.B === NOT_PENDING ? e.Re : e.B;
-    const f = !e.Ae || !e.Ae(a, u);
-    if (f) {
-      const s = r ? e.Re : undefined;
-      if (t || (n && activeTransition !== e.$) || i) e.Re = u;
-      else e.B = u;
-      if (r && !i && o) {
-        const t = e.K || 0;
-        const n = e.j || 0;
-        if (t <= n) e.Re = u;
-      }
-      if (!r || i || e.Re !== s) {
-        insertSubs(e, i || r);
-      }
-    } else if (r) {
-      e.B = 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);
+    const r = findLane(i);
+    if (activeLanes.has(r)) {
+      if (r !== n && !hasActiveOverride(e)) {
+        if (n.Te && findLane(n.Te) === r) {
+          e.ie = t;
+        } else if (r.Te && findLane(r.Te) === n);
+        else mergeLanes(n, r);
       }
+      return;
     }
   }
-  setCurrentOptimisticLane(a);
-  (!t || e.Oe & STATUS_PENDING) && !e.$ && !(activeTransition && e.Y) && globalQueue.J.push(e);
-  e.$ && n && activeTransition !== e.$ && runInTransition(e.$, () => recompute(e));
+  e.ie = t;
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
   const r = i && untrack(() => t[Symbol.asyncIterator]);
   const o = !r && i && untrack(() => typeof t.then === "function");
   if (!o && !r) {
-    e.ge = null;
+    e.Se = null;
     return t;
   }
-  e.ge = t;
+  e.Se = t;
   let s;
   const handleError = n => {
-    if (e.ge !== t) return;
-    globalQueue.initTransition(e.$);
+    if (e.Se !== t) return;
+    globalQueue.initTransition(e.ne);
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.ce = clock;
+    e.J = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e.ge !== t) return;
-    if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(e.$);
+    if (e.Se !== t) return;
+    if (e.S & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(e.ne);
     clearStatus(e);
     const o = resolveLane(e);
-    if (o) o.G.delete(e);
+    if (o) o.U.delete(e);
     if (n) n(i);
-    else if (e.Y) {
-      const t = e.B !== NOT_PENDING;
-      if (e.U) e.B = i;
+    else if (e.Oe) {
+      const t = e.ce !== NOT_PENDING;
+      if (e.L) e.ce = i;
       if (!t) {
-        e.Re = i;
+        e.le = i;
         insertSubs(e);
       }
-      e.ce = clock;
+      e.J = clock;
     } else if (o) {
-      const t = e.Re;
-      const n = e.Ae;
+      const t = e.le;
+      const n = e._e;
       if (!n || !n(i, t)) {
-        e.Re = i;
-        e.ce = clock;
-        if (e.Ne) {
-          setSignal(e.Ne, i);
+        e.le = i;
+        e.J = clock;
+        if (e.Ie) {
+          setSignal(e.Ie, i);
         }
         insertSubs(e, true);
       }
@@ -752,7 +598,7 @@ function handleAsync(e, t, n) {
     );
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.$);
+      globalQueue.initTransition(e.ne);
       throw new NotReadyError(context);
     }
   }
@@ -784,341 +630,520 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.$);
+      globalQueue.initTransition(e.ne);
       throw new NotReadyError(context);
     }
   }
   return s;
 }
 function clearStatus(e) {
-  e.Oe = e.Oe & STATUS_UNINITIALIZED;
-  e.se = null;
+  e.ae = e.ae & STATUS_UNINITIALIZED;
+  e.q = null;
   updatePendingSignal(e);
-  e.Pe?.();
+  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 s = t === STATUS_PENDING && e.Y && !o;
+  const o = n instanceof NotReadyError && n.source === e;
+  const s = t === STATUS_PENDING && e.Oe && !o;
   const u = s && hasActiveOverride(e);
   if (!i) {
-    e.Oe = t | (t !== STATUS_ERROR ? e.Oe & STATUS_UNINITIALIZED : 0);
-    e.se = 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.ue.includes(e)) {
-      activeTransition.ue.push(e);
+    const e = n.source;
+    if (!activeTransition.Z.includes(e)) {
+      activeTransition.Z.push(e);
     }
   }
   const c = i || u;
   const l = i || s ? undefined : r;
-  if (e.Pe) {
+  if (e.pe) {
     if (c) {
-      e.Pe(t, n);
+      e.pe(t, n);
     } else {
-      e.Pe();
+      e.pe();
     }
     return;
   }
-  for (let i = e.p; i !== null; i = i.h) {
-    i.A.ce = clock;
-    if (i.A.se !== n) {
-      !i.A.$ && globalQueue.J.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.N; i !== null; i = i.P) {
-    for (let e = i.p; e !== null; e = e.h) {
-      e.A.ce = clock;
-      if (e.A.se !== n) {
-        !e.A.$ && globalQueue.J.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);
       }
     }
   }
 }
-function updateIfNecessary(e) {
-  if (e._ & REACTIVE_CHECK) {
-    for (let t = e.D; t; t = t.m) {
-      const n = t.V;
-      const i = n.L || n;
-      if (i.U) {
-        updateIfNecessary(i);
+function effect(e, t, n, i, r) {
+  let o = false;
+  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
+    ...r,
+    equals: () => {
+      s.oe = !s.q;
+      if (o) s.se.enqueue(s.re, runEffect.bind(s));
+      return false;
+    },
+    lazy: true
+  });
+  s.he = i;
+  s.Ae = t;
+  s.ge = n;
+  s.Pe = undefined;
+  s.re = r?.render ? EFFECT_RENDER : EFFECT_USER;
+  s.pe = (e, t) => {
+    const n = e !== undefined ? e : s.ae;
+    const i = t !== undefined ? t : s.q;
+    if (n & STATUS_ERROR) {
+      let e = i;
+      s.se.notify(s, STATUS_PENDING, 0);
+      if (s.re === EFFECT_USER) {
+        try {
+          return s.ge
+            ? s.ge(e, () => {
+                s.Pe?.();
+                s.Pe = undefined;
+              })
+            : console.error(e);
+        } catch (t) {
+          e = t;
+        }
       }
-      if (e._ & REACTIVE_DIRTY) {
-        break;
+      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.re === EFFECT_USER ? s.se.enqueue(s.re, runEffect.bind(s)) : runEffect.call(s));
+  o = true;
+  onCleanup(() => s.Pe?.());
+}
+function runEffect() {
+  if (!this.oe || this.S & REACTIVE_DISPOSED) return;
+  this.Pe?.();
+  this.Pe = undefined;
+  try {
+    this.Pe = this.Ae(this.le, this.he);
+  } catch (e) {
+    if (!this.se.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+  } finally {
+    this.he = this.le;
+    this.oe = false;
+  }
+}
+function trackedEffect(e, t) {
+  const run = () => {
+    if (!n.oe || n.S & REACTIVE_DISPOSED) return;
+    n.oe = false;
+    recompute(n);
+  };
+  const n = computed(
+    () => {
+      try {
+        n.Pe?.();
+        n.Pe = undefined;
+        n.Pe = staleValues(e) || undefined;
+      } finally {
       }
+    },
+    undefined,
+    { ...t, lazy: true, pureWrite: true }
+  );
+  n.Pe = undefined;
+  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.S |= REACTIVE_ZOMBIE;
+    if (t.S & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
     }
+    markDisposal(t);
+    t = t.Ne;
   }
-  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.se && e.ce < clock)) {
-    recompute(e);
+}
+function dispose(e) {
+  let t = e.N || null;
+  do {
+    t = unlinkSubs(t);
+  } while (t !== null);
+  e.N = null;
+  e.ye = null;
+  disposeChildren(e, true);
+}
+function disposeChildren(e, t = false, n) {
+  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.N) {
+      const e = i;
+      deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.N;
+      do {
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.N = null;
+      e.ye = null;
+    }
+    disposeChildren(i, true);
+    i = e;
   }
-  e._ = REACTIVE_NONE;
+  if (n) {
+    e.De = null;
+  } else {
+    e.Ce = null;
+    e.Ne = null;
+  }
+  runDisposal(e, n);
+}
+function runDisposal(e, t) {
+  let n = t ? e.ve : e.we;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      t.call(t);
+    }
+  } else {
+    n.call(n);
+  }
+  t ? (e.ve = null) : (e.we = null);
+}
+function getNextChildId(e) {
+  if (e.id != null) return formatId(e.id, e.be++);
+  throw new Error("Cannot get child id from owner without an id");
+}
+function formatId(e, t) {
+  const n = t.toString(36),
+    i = n.length - 1;
+  return e + (i ? String.fromCharCode(64 + i) : "") + n;
+}
+function getObserver() {
+  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
+  return tracking ? context : null;
+}
+function getOwner() {
+  return context;
+}
+function onCleanup(e) {
+  if (!context) return e;
+  if (!context.we) context.we = e;
+  else if (Array.isArray(context.we)) context.we.push(e);
+  else context.we = [context.we, e];
+  return e;
+}
+function createOwner(e) {
+  const t = context;
+  const n = {
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
+    t: true,
+    u: t?.t ? t.u : t,
+    Ce: null,
+    Ne: null,
+    we: null,
+    se: t?.se ?? globalQueue,
+    Ve: t?.Ve || defaultContext,
+    be: 0,
+    ve: null,
+    De: null,
+    i: t,
+    dispose(e = true) {
+      disposeChildren(n, e);
+    }
+  };
+  if (t) {
+    const e = t.Ce;
+    if (e === null) {
+      t.Ce = n;
+    } else {
+      n.Ne = e;
+      t.Ce = n;
+    }
+  }
+  return n;
+}
+function createRoot(e, t) {
+  const n = createOwner(t);
+  return runWithOwner(n, () => e(n.dispose));
 }
 function unlinkSubs(e) {
   const t = e.V;
-  const n = e.m;
-  const i = e.h;
-  const r = e.Ce;
-  if (i !== null) i.Ce = r;
-  else t.ye = r;
-  if (r !== null) r.h = i;
+  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.p = i;
   else {
-    t.p = i;
+    t.I = i;
     if (i === null) {
-      t.De?.();
-      t.U && !t.ve && unobserved(t);
+      t.ke?.();
+      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.he;
+  const n = t.ye;
   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.m : t.D;
+    i = n !== null ? n.D : t.N;
     if (i !== null && i.V === e) {
-      t.he = i;
+      t.ye = i;
       return;
     }
   }
-  const o = e.ye;
-  if (o !== null && o.A === t && (!r || isValidLink(o, t))) return;
-  const s = (t.he = e.ye = { V: e, A: t, m: i, Ce: o, h: null });
-  if (n !== null) n.m = s;
-  else t.D = s;
-  if (o !== null) o.h = s;
-  else e.p = s;
+  const o = e.Le;
+  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.he;
+  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.m;
+      i = i.D;
     } while (i !== null);
   }
   return false;
 }
-function markDisposal(e) {
-  let t = e.pe;
-  while (t) {
-    t._ |= REACTIVE_ZOMBIE;
-    if (t._ & REACTIVE_IN_HEAP) {
-      deleteFromHeap(t, dirtyQueue);
-      insertIntoHeap(t, zombieQueue);
+GlobalQueue.K = recompute;
+GlobalQueue.Y = disposeChildren;
+let tracking = false;
+let stale = false;
+let refreshing = false;
+let pendingCheckActive = false;
+let foundPending = false;
+let pendingReadActive = false;
+let context = null;
+let currentOptimisticLane = null;
+function recompute(e, t = false) {
+  const n = e.re;
+  if (!t) {
+    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;
+      e.De = e.Ce;
+      e.we = null;
+      e.Ce = null;
     }
-    markDisposal(t);
-    t = t.we;
   }
-}
-function dispose(e) {
-  let t = e.D || null;
-  do {
-    t = unlinkSubs(t);
-  } while (t !== null);
-  e.D = null;
-  e.he = null;
-  disposeChildren(e, true);
-}
-function disposeChildren(e, t = false, n) {
-  if (e._ & REACTIVE_DISPOSED) return;
-  if (t) e._ = REACTIVE_DISPOSED;
-  let i = n ? e.Ie : e.pe;
-  while (i) {
-    const e = i.we;
-    if (i.D) {
-      const e = i;
-      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.D;
+  const i = !!(e.S & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = hasActiveOverride(e);
+  const o = !!(e.ae & STATUS_PENDING);
+  const s = context;
+  context = e;
+  e.ye = null;
+  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;
+  if (i) {
+    const t = resolveLane(e);
+    if (t) currentOptimisticLane = t;
+  }
+  try {
+    u = handleAsync(e, e.L(u));
+    clearStatus(e);
+    const t = resolveLane(e);
+    if (t) {
+      t.U.delete(e);
+      updatePendingSignal(t.fe);
+    }
+  } catch (t) {
+    if (t instanceof NotReadyError && currentOptimisticLane) {
+      const t = findLane(currentOptimisticLane);
+      if (t.fe !== e) {
+        t.U.add(e);
+        e.ie = t;
+        updatePendingSignal(t.fe);
+      }
+    }
+    notifyStatus(
+      e,
+      t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      t,
+      undefined,
+      t instanceof NotReadyError ? e.ie : undefined
+    );
+  } finally {
+    tracking = l;
+    e.S = REACTIVE_NONE;
+    context = s;
+  }
+  if (!e.q) {
+    const s = e.ye;
+    let l = s !== null ? s.D : e.N;
+    if (l !== null) {
       do {
-        t = unlinkSubs(t);
-      } while (t !== null);
-      e.D = null;
-      e.he = null;
+        l = unlinkSubs(l);
+      } while (l !== null);
+      if (s !== null) s.D = null;
+      else e.N = null;
+    }
+    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.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.le = u;
+      }
+      if (!r || i || e.le !== s) {
+        insertSubs(e, i || r);
+      }
+    } else if (r) {
+      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);
+      }
     }
-    disposeChildren(i, true);
-    i = e;
-  }
-  if (n) {
-    e.Ie = null;
-  } else {
-    e.pe = null;
-    e.we = null;
   }
-  runDisposal(e, n);
+  currentOptimisticLane = a;
+  (!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 runDisposal(e, t) {
-  let n = t ? e.Se : e._e;
-  if (!n) return;
-  if (Array.isArray(n)) {
-    for (let e = 0; e < n.length; e++) {
-      const t = n[e];
-      t.call(t);
+function updateIfNecessary(e) {
+  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.S & REACTIVE_DIRTY) {
+        break;
+      }
     }
-  } else {
-    n.call(n);
   }
-  t ? (e.Se = null) : (e._e = null);
-}
-function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.be++);
-  throw new Error("Cannot get child id from owner without an id");
-}
-function formatId(e, t) {
-  const n = t.toString(36),
-    i = n.length - 1;
-  return e + (i ? String.fromCharCode(64 + i) : "") + n;
+  if (e.S & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.q && e.J < clock)) {
+    recompute(e);
+  }
+  e.S = REACTIVE_NONE;
 }
 function computed(e, t, n) {
   const i = {
     id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    Ae: n?.equals != null ? n.equals : isEqual,
-    me: !!n?.pureWrite,
-    De: n?.unobserved,
-    _e: null,
-    Te: context?.Te ?? globalQueue,
+    _e: n?.equals != null ? n.equals : isEqual,
+    We: !!n?.pureWrite,
+    ke: n?.unobserved,
+    we: null,
+    se: context?.se ?? globalQueue,
     Ve: context?.Ve ?? defaultContext,
     be: 0,
-    U: e,
-    Re: t,
-    u: 0,
+    L: e,
+    le: t,
+    o: 0,
+    A: null,
+    R: undefined,
+    T: null,
     N: null,
-    O: undefined,
-    R: null,
-    D: null,
-    he: null,
-    p: null,
     ye: null,
-    o: context,
-    we: null,
-    pe: null,
-    _: REACTIVE_NONE,
-    Oe: STATUS_UNINITIALIZED,
-    ce: clock,
-    B: NOT_PENDING,
+    I: null,
+    Le: null,
+    i: context,
+    Ne: null,
+    Ce: null,
+    S: REACTIVE_NONE,
+    ae: STATUS_UNINITIALIZED,
+    J: clock,
+    ce: NOT_PENDING,
+    ve: null,
+    De: null,
     Se: null,
-    Ie: null,
-    ge: null,
-    $: 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.pe;
+    const e = context.Ce;
     if (e === null) {
-      context.pe = i;
+      context.Ce = i;
     } else {
-      i.we = e;
-      context.pe = i;
+      i.Ne = e;
+      context.Ce = i;
     }
   }
-  if (r) i.u = r.u + 1;
+  if (r) i.o = r.o + 1;
   !n?.lazy && recompute(i, true);
   return i;
 }
 function signal(e, t, n = null) {
   const i = {
-    Ae: t?.equals != null ? t.equals : isEqual,
-    me: !!t?.pureWrite,
-    De: t?.unobserved,
-    Re: e,
-    p: null,
-    ye: null,
-    ce: clock,
-    L: n,
-    P: n?.N || null,
-    B: NOT_PENDING
+    _e: t?.equals != null ? t.equals : isEqual,
+    We: !!t?.pureWrite,
+    ke: t?.unobserved,
+    le: e,
+    I: null,
+    Le: null,
+    J: clock,
+    m: n,
+    P: n?.A || null,
+    ce: NOT_PENDING
   };
-  n && (n.N = i);
+  n && (n.A = i);
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.Y = true;
+  n.Oe = true;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const i = computed(e, t, n);
-  i.Y = true;
+  i.Oe = true;
   return i;
 }
-function getPendingSignal(e) {
-  if (!e.Le) {
-    e.Le = optimisticSignal(false, { pureWrite: true });
-    if (e.k) {
-      e.Le.k = e;
-    }
-    if (computePendingState(e)) setSignal(e.Le, true);
-  }
-  return e.Le;
-}
-function computePendingState(e) {
-  const t = e;
-  if (e.Y && e.B !== NOT_PENDING) {
-    if (t.Oe & STATUS_PENDING && !(t.Oe & STATUS_UNINITIALIZED)) return true;
-    if (e.k) {
-      const t = e.W ? findLane(e.W) : null;
-      return !!(t && t.G.size > 0);
-    }
-    return true;
-  }
-  if (e.B !== NOT_PENDING && !(t.Oe & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Oe & STATUS_PENDING && !(t.Oe & STATUS_UNINITIALIZED));
-}
-function getPendingValueComputed(e) {
-  if (!e.Ne) {
-    const t = pendingReadActive;
-    pendingReadActive = false;
-    const n = pendingCheckActive;
-    pendingCheckActive = false;
-    const i = context;
-    context = null;
-    e.Ne = optimisticComputed(() => read(e));
-    e.Ne.k = e;
-    context = i;
-    pendingCheckActive = n;
-    pendingReadActive = t;
-  }
-  return e.Ne;
-}
-function updatePendingSignal(e) {
-  if (e.Le) {
-    const t = computePendingState(e);
-    const n = e.Le;
-    setSignal(n, t);
-    if (!t && n.W) {
-      const t = resolveLane(e);
-      if (t && t.G.size > 0) {
-        const e = findLane(n.W);
-        if (e !== t) {
-          mergeLanes(t, e);
-        }
-      }
-      clearLaneEntry(n);
-      n.W = undefined;
-    }
-  }
-}
 function isEqual(e, t) {
   return e === t;
 }
@@ -1138,18 +1163,18 @@ function read(e) {
     pendingReadActive = false;
     const i = read(t);
     pendingReadActive = n;
-    if (t.Oe & STATUS_PENDING) return e.Re;
-    if (stale && currentOptimisticLane && t.W) {
-      const n = findLane(t.W);
+    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.G.size > 0) {
-        return e.Re;
+      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;
@@ -1157,145 +1182,96 @@ function read(e) {
       foundPending = true;
     }
     pendingCheckActive = i;
-    return e.Re;
+    return e.le;
   }
   let t = context;
-  if (t?.i) t = t.l;
-  if (refreshing && e.U) recompute(e);
+  if (t?.t) t = t.u;
+  if (refreshing && e.L) recompute(e);
   if (t && tracking) {
-    if (e.U && e._ & REACTIVE_DISPOSED) recompute(e);
+    if (e.L && e.S & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    const n = e.L || e;
-    if (n.U) {
-      const i = e._ & REACTIVE_ZOMBIE;
-      if (n.u >= (i ? zombieQueue.C : dirtyQueue.C)) {
+    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.Oe & STATUS_PENDING && !(stale && n.$ && activeTransition !== n.$)) {
+  const n = e.m || e;
+  if (t && n.ae & STATUS_PENDING && !(stale && n.ne && activeTransition !== n.ne)) {
     if (currentOptimisticLane) {
-      const i = n.W;
+      const i = n.ie;
       const r = findLane(currentOptimisticLane);
       if (i && findLane(i) === r && !hasActiveOverride(n)) {
         if (!tracking) link(e, t);
-        throw n.se;
+        throw n.q;
       }
     } else {
       if (!tracking) link(e, t);
-      throw n.se;
+      throw n.q;
     }
   }
-  if (e.U && e.Oe & STATUS_ERROR) {
-    if (e.ce < clock) {
+  if (e.L && e.ae & STATUS_ERROR) {
+    if (e.J < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.se;
+    } else throw e.q;
   }
   return !t ||
     currentOptimisticLane !== null ||
-    e.B === NOT_PENDING ||
-    (stale && e.$ && activeTransition !== e.$)
-    ? e.Re
-    : e.B;
+    e.ce === NOT_PENDING ||
+    (stale && e.ne && activeTransition !== e.ne)
+    ? e.le
+    : e.ce;
 }
 function setSignal(e, t) {
-  if (e.$ && activeTransition !== e.$) globalQueue.initTransition(e.$);
-  const n = e.Y && !projectionWriteActive;
-  const i = n ? e.Re : e.B === NOT_PENDING ? e.Re : e.B;
+  if (e.ne && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
+  const n = e.Oe && !projectionWriteActive;
+  const i = n ? e.le : e.ce === NOT_PENDING ? e.le : e.ce;
   if (typeof t === "function") t = t(i);
-  const r = !e.Ae || !e.Ae(i, t);
+  const r = !e._e || !e._e(i, t);
   if (!r) {
-    if (n && e.B !== NOT_PENDING && e.U) {
+    if (n && e.ce !== NOT_PENDING && e.L) {
       insertSubs(e, true);
       schedule();
     }
     return t;
   }
   if (n) {
-    const n = globalQueue.ee.includes(e);
-    if (e.$ && n) {
-      globalQueue.initTransition(e.$);
+    const n = globalQueue.H.includes(e);
+    if (e.ne && n) {
+      globalQueue.initTransition(e.ne);
     }
-    if (e.B === NOT_PENDING) {
-      e.B = e.Re;
+    if (e.ce === NOT_PENDING) {
+      e.ce = e.le;
     }
     if (!n) {
-      globalQueue.ee.push(e);
+      globalQueue.H.push(e);
     }
-    e.K = (e.K || 0) + 1;
+    e.Re = (e.Re || 0) + 1;
     const i = getOrCreateLane(e);
-    e.W = i;
-    e.Re = t;
+    e.ie = i;
+    e.le = t;
   } else {
-    if (e.B === NOT_PENDING) globalQueue.J.push(e);
-    e.B = t;
+    if (e.ce === NOT_PENDING) globalQueue.$.push(e);
+    e.ce = t;
   }
   updatePendingSignal(e);
-  if (e.Ne) {
-    setSignal(e.Ne, t);
+  if (e.Ie) {
+    setSignal(e.Ie, t);
   }
-  e.ce = clock;
+  e.J = clock;
   insertSubs(e, n);
   schedule();
   return t;
 }
-const PENDING_OWNER = {};
-function getObserver() {
-  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
-  return tracking ? context : null;
-}
-function getOwner() {
-  return context;
-}
-function onCleanup(e) {
-  if (!context) return e;
-  if (!context._e) context._e = e;
-  else if (Array.isArray(context._e)) context._e.push(e);
-  else context._e = [context._e, e];
-  return e;
-}
-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,
-    pe: null,
-    we: null,
-    _e: null,
-    Te: t?.Te ?? globalQueue,
-    Ve: t?.Ve || defaultContext,
-    be: 0,
-    Se: null,
-    Ie: null,
-    o: t,
-    dispose(e = true) {
-      disposeChildren(n, e);
-    }
-  };
-  if (t) {
-    const e = t.pe;
-    if (e === null) {
-      t.pe = n;
-    } else {
-      n.we = e;
-      t.pe = n;
-    }
-  }
-  return n;
-}
-function createRoot(e, t) {
-  const n = createOwner(t);
-  return runWithOwner(n, () => e(n.dispose));
-}
 function runWithOwner(e, t) {
   const n = context;
   const i = tracking;
@@ -1308,6 +1284,63 @@ function runWithOwner(e, t) {
     tracking = i;
   }
 }
+function getPendingSignal(e) {
+  if (!e.Qe) {
+    e.Qe = optimisticSignal(false, { pureWrite: true });
+    if (e.Ee) {
+      e.Qe.Ee = e;
+    }
+    if (computePendingState(e)) setSignal(e.Qe, true);
+  }
+  return e.Qe;
+}
+function computePendingState(e) {
+  const t = e;
+  if (e.Oe && e.ce !== NOT_PENDING) {
+    if (t.ae & STATUS_PENDING && !(t.ae & STATUS_UNINITIALIZED)) return true;
+    if (e.Ee) {
+      const t = e.ie ? findLane(e.ie) : null;
+      return !!(t && t.U.size > 0);
+    }
+    return true;
+  }
+  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.ie) {
+      const t = resolveLane(e);
+      if (t && t.U.size > 0) {
+        const e = findLane(n.ie);
+        if (e !== t) {
+          mergeLanes(t, e);
+        }
+      }
+      signalLanes.delete(n);
+      n.ie = undefined;
+    }
+  }
+}
+function getPendingValueComputed(e) {
+  if (!e.Ie) {
+    const t = pendingReadActive;
+    pendingReadActive = false;
+    const n = pendingCheckActive;
+    pendingCheckActive = false;
+    const i = context;
+    context = null;
+    e.Ie = optimisticComputed(() => read(e));
+    e.Ie.Ee = e;
+    context = i;
+    pendingCheckActive = n;
+    pendingReadActive = t;
+  }
+  return e.Ie;
+}
 function staleValues(e, t = true) {
   const n = stale;
   stale = t;
@@ -1385,85 +1418,49 @@ function hasContext(e, t) {
 function isUndefined(e) {
   return typeof e === "undefined";
 }
-function effect(e, t, n, i, r) {
-  let o = false;
-  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
-    ...r,
-    equals: () => {
-      s.Ee = !s.se;
-      if (o) s.Te.enqueue(s.fe, runEffect.bind(s));
-      return false;
-    },
-    lazy: true
-  });
-  s.Ue = i;
-  s.ke = t;
-  s.We = n;
-  s.Qe = undefined;
-  s.fe = r?.render ? EFFECT_RENDER : EFFECT_USER;
-  s.Pe = (e, t) => {
-    const n = e !== undefined ? e : s.Oe;
-    const i = t !== undefined ? t : s.se;
-    if (n & STATUS_ERROR) {
-      let e = i;
-      s.Te.notify(s, STATUS_PENDING, 0);
-      if (s.fe === EFFECT_USER) {
+function restoreTransition(e, t) {
+  globalQueue.initTransition(e);
+  const n = t();
+  flush();
+  return n;
+}
+function action(e) {
+  return (...t) =>
+    new Promise((n, i) => {
+      const r = e(...t);
+      globalQueue.initTransition();
+      let o = activeTransition;
+      o.ee.push(r);
+      const done = (e, t) => {
+        o = currentTransition(o);
+        const s = o.ee.indexOf(r);
+        if (s >= 0) o.ee.splice(s, 1);
+        setActiveTransition(o);
+        schedule();
+        t ? i(t) : n(e);
+      };
+      const step = (e, t) => {
+        let n;
         try {
-          return s.We
-            ? s.We(e, () => {
-                s.Qe?.();
-                s.Qe = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
+          n = t ? r.throw(e) : r.next(e);
+        } catch (e) {
+          return done(undefined, e);
         }
-      }
-      if (!s.Te.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (s.fe === EFFECT_RENDER) s.Te.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
-  };
-  recompute(s, true);
-  !r?.defer && (s.fe === EFFECT_USER ? s.Te.enqueue(s.fe, runEffect.bind(s)) : runEffect.call(s));
-  o = true;
-  onCleanup(() => s.Qe?.());
-}
-function runEffect() {
-  if (!this.Ee || this._ & REACTIVE_DISPOSED) return;
-  this.Qe?.();
-  this.Qe = undefined;
-  try {
-    this.Qe = this.ke(this.Re, this.Ue);
-  } catch (e) {
-    if (!this.Te.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-  } finally {
-    this.Ue = this.Re;
-    this.Ee = false;
-  }
-}
-function trackedEffect(e, t) {
-  const run = () => {
-    if (!n.Ee || n._ & REACTIVE_DISPOSED) return;
-    n.Ee = false;
-    recompute(n);
-  };
-  const n = computed(
-    () => {
-      try {
-        n.Qe?.();
-        n.Qe = undefined;
-        n.Qe = staleValues(e) || undefined;
-      } finally {
-      }
-    },
-    undefined,
-    { ...t, lazy: true, pureWrite: true }
-  );
-  n.Qe = undefined;
-  n.Ee = true;
-  n.fe = EFFECT_TRACKED;
-  n.de = run;
-  n.Te.enqueue(EFFECT_USER, run);
-  onCleanup(() => n.Qe?.());
+        if (n instanceof Promise)
+          return void n.then(run, e => restoreTransition(o, () => step(e, true)));
+        run(n);
+      };
+      const run = e => {
+        if (e.done) return done(e.value);
+        if (e.value instanceof Promise)
+          return void e.value.then(
+            e => restoreTransition(o, () => step(e)),
+            e => restoreTransition(o, () => step(e, true))
+          );
+        restoreTransition(o, () => step(e.value));
+      };
+      step();
+    });
 }
 function createSignal(e, t, n) {
   if (typeof e === "function") {
@@ -1536,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) {
@@ -1549,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);
     }
   }
 }
@@ -1697,7 +1697,7 @@ function createProjectionInternal(e, t = {}, n) {
       r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(o);
     });
   });
-  i.ve = true;
+  i.Ue = true;
   return { store: o, node: i };
 }
 function createProjection(e, t = {}, n) {
@@ -1797,7 +1797,7 @@ function getNode(e, t, n, i, r = isEqual, o) {
     },
     i
   );
-  if (o) s.Y = true;
+  if (o) s.Oe = true;
   return (e[t] = s);
 }
 function trackSelf(e, t = $TRACK) {
@@ -1850,7 +1850,7 @@ const storeTraps = {
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = r && (s || !u) ? (r.B !== NOT_PENDING ? (r.Y ? r.Re : r.B) : r.Re) : 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);
@@ -1899,8 +1899,8 @@ const storeTraps = {
     if (writeOnly(i)) {
       if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.$) {
-          globalQueue.initTransition(t.$);
+        if (t?.ne) {
+          globalQueue.initTransition(t.ne);
         }
       }
       untrack(() => {
@@ -2089,7 +2089,7 @@ function deep(e) {
   return e[$DEEP];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.re ||= clearOptimisticStore;
+  GlobalQueue.B ||= clearOptimisticStore;
   const i = typeof e === "function";
   const r = (i ? t : e) ?? {};
   const o = i ? e : undefined;
@@ -2106,7 +2106,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].W = 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;
@@ -2114,7 +2114,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].W = undefined;
+        i[$TRACK].ie = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2165,7 +2165,7 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
         setProjectionWriteActive(false);
       }
     });
-    i.ve = true;
+    i.Ue = true;
   }
   return { store: o, node: i };
 }
@@ -2350,9 +2350,9 @@ function mapArray(e, t, n) {
   return createMemo(
     updateKeyedMap.bind({
       xe: createOwner(),
-      Ge: 0,
-      Me: e,
-      Fe: [],
+      Me: 0,
+      Fe: e,
+      Ge: [],
       $e: t,
       He: [],
       je: [],
@@ -2365,7 +2365,7 @@ function mapArray(e, t, n) {
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.Me() || [],
+  const e = this.Fe() || [],
     t = e.length;
   e[$TRACK];
   runWithOwner(this.xe, () => {
@@ -2391,26 +2391,26 @@ function updateKeyedMap() {
               return this.$e(() => t);
             };
     if (t === 0) {
-      if (this.Ge !== 0) {
+      if (this.Me !== 0) {
         this.xe.dispose(false);
         this.je = [];
-        this.Fe = [];
+        this.Ge = [];
         this.He = [];
-        this.Ge = 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.Ge === 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.Fe[i] = e[i];
+        this.Ge[i] = e[i];
         this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
       }
-      this.Ge = t;
+      this.Me = t;
     } else {
       let o,
         s,
@@ -2424,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.Ge, t);
-        o < s && (this.Fe[o] === e[o] || (this.Ye && compare(this.Ke, this.Fe[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.Ge - 1, u = t - 1;
+        s = this.Me - 1, u = t - 1;
         s >= o &&
         u >= o &&
-        (this.Fe[s] === e[u] || (this.Ye && compare(this.Ke, this.Fe[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];
@@ -2452,7 +2452,7 @@ function updateKeyedMap() {
         a.set(l, i);
       }
       for (n = o; n <= s; n++) {
-        c = this.Fe[n];
+        c = this.Ge[n];
         l = this.Ke ? this.Ke(c) : c;
         i = a.get(l);
         if (i !== undefined && i !== -1) {
@@ -2480,8 +2480,8 @@ function updateKeyedMap() {
           this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
         }
       }
-      this.He = this.He.slice(0, (this.Ge = t));
-      this.Fe = e.slice(0);
+      this.He = this.He.slice(0, (this.Me = t));
+      this.Ge = e.slice(0);
     }
   });
   return this.He;
@@ -2489,7 +2489,7 @@ function updateKeyedMap() {
 function repeat(e, t, n) {
   return updateRepeat.bind({
     xe: createOwner(),
-    Ge: 0,
+    Me: 0,
     qe: 0,
     ze: e,
     $e: t,
@@ -2504,11 +2504,11 @@ function updateRepeat() {
   const t = this.Ze?.() || 0;
   runWithOwner(this.xe, () => {
     if (e === 0) {
-      if (this.Ge !== 0) {
+      if (this.Me !== 0) {
         this.xe.dispose(false);
         this.je = [];
         this.He = [];
-        this.Ge = 0;
+        this.Me = 0;
       }
       if (this.Xe && !this.He[0]) {
         this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
@@ -2516,12 +2516,12 @@ function updateRepeat() {
       return;
     }
     const n = t + e;
-    const i = this.qe + this.Ge;
-    if (this.Ge === 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.Ge) 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) {
@@ -2542,7 +2542,7 @@ function updateRepeat() {
     }
     this.He = this.He.slice(0, e);
     this.qe = t;
-    this.Ge = e;
+    this.Me = e;
   });
   return this.He;
 }
@@ -2551,119 +2551,68 @@ 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.Oe;
-    const r = t !== undefined ? t : n.se;
-    n.Oe &= ~n.Je;
-    n.Te.notify(n, n.Je, i, r);
+  n.pe = (e, t) => {
+    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.ve = true;
+  n.Ue = true;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.Te;
-  r.addChild((e.Te = n));
-  onCleanup(() => r.removeChild(e.Te));
+  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);
   });
 }
-class ConditionalQueue extends Queue {
+class CollectionQueue extends Queue {
   et;
   tt = new Set();
-  J = new Set();
+  nt = signal(false, { pureWrite: true });
+  it = false;
   constructor(e) {
     super();
     this.et = e;
   }
   run(e) {
-    if (!e || read(this.et)) return;
-    return super.run(e);
-  }
-  notify(e, t, n, i) {
-    if (read(this.et)) {
-      if (t & STATUS_PENDING) {
-        if (n & STATUS_PENDING) {
-          this.J.add(e);
-          t &= ~STATUS_PENDING;
-        } else if (this.J.delete(e)) t &= ~STATUS_PENDING;
-      }
-      if (t & STATUS_ERROR) {
-        if (n & STATUS_ERROR) {
-          this.tt.add(e);
-          t &= ~STATUS_ERROR;
-        } else if (this.tt.delete(e)) t &= ~STATUS_ERROR;
-      }
-    }
-    return t ? super.notify(e, t, n, i ?? e.se) : true;
-  }
-}
-class CollectionQueue extends Queue {
-  nt;
-  it = new Set();
-  et = signal(false, { pureWrite: true });
-  rt = false;
-  constructor(e) {
-    super();
-    this.nt = e;
-  }
-  run(e) {
-    if (!e || read(this.et)) return;
+    if (!e || read(this.nt)) return;
     return super.run(e);
   }
   notify(e, t, n, i) {
-    if (!(t & this.nt) || (this.nt & STATUS_PENDING && this.rt)) return super.notify(e, t, n, i);
-    if (n & this.nt) {
-      const t = i?.t || e.se?.t;
+    if (!(t & this.et) || (this.et & STATUS_PENDING && this.it)) return super.notify(e, t, n, i);
+    if (n & this.et) {
+      const t = i?.source || e.q?.source;
       if (t) {
-        const e = this.it.size === 0;
-        this.it.add(t);
-        if (e) setSignal(this.et, true);
+        const e = this.tt.size === 0;
+        this.tt.add(t);
+        if (e) setSignal(this.nt, true);
       }
     }
-    t &= ~this.nt;
+    t &= ~this.et;
     return t ? super.notify(e, t, n, i) : true;
   }
   checkSources() {
-    for (const e of this.it) {
-      if (!(e.Oe & this.nt)) this.it.delete(e);
-    }
-    if (!this.it.size) setSignal(this.et, false);
-  }
-}
-var BoundaryMode;
-(function (e) {
-  e["VISIBLE"] = "visible";
-  e["HIDDEN"] = "hidden";
-})(BoundaryMode || (BoundaryMode = {}));
-function createBoundary(e, t) {
-  const n = createOwner();
-  const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
-  const r = createBoundChildren(n, e, i, 0);
-  computed(() => {
-    const e = read(i.et);
-    r.Je = e ? STATUS_ERROR | STATUS_PENDING : 0;
-    if (!e) {
-      i.J.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING, e.se));
-      i.tt.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR, e.se));
-      i.J.clear();
-      i.tt.clear();
+    for (const e of this.tt) {
+      if (!(e.ae & this.et)) this.tt.delete(e);
     }
-  });
-  return () => (read(i.et) ? undefined : read(r));
+    if (!this.tt.size) setSignal(this.nt, false);
+  }
 }
 function createCollectionBoundary(e, t, n) {
   const i = createOwner();
   const r = new CollectionQueue(e);
   const o = createBoundChildren(i, t, r, e);
   const s = computed(() => {
-    if (!read(r.et)) {
+    if (!read(r.nt)) {
       const e = read(o);
-      if (!untrack(() => read(r.et))) {
-        r.rt = true;
+      if (!untrack(() => read(r.nt))) {
+        r.it = true;
         return e;
       }
     }
@@ -2676,10 +2625,10 @@ function createLoadBoundary(e, t) {
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.it.values().next().value;
-    const i = n.se?.cause ?? n.se;
+    let n = e.tt.values().next().value;
+    const i = n.q?.cause ?? n.q;
     return t(i, () => {
-      for (const t of e.it) recompute(t);
+      for (const t of e.tt) recompute(t);
       schedule();
     });
   });
@@ -2742,7 +2691,6 @@ export {
   NotReadyError,
   SUPPORTS_PROXY,
   action,
-  createBoundary,
   createContext,
   createEffect,
   createErrorBoundary,
@@ -2750,6 +2698,7 @@ export {
   createMemo,
   createOptimistic,
   createOptimisticStore,
+  createOwner,
   createProjection,
   createReaction,
   createRenderEffect,