@solidjs/signals 0.9.8 → 0.9.10

package/dist/prod.js

@@ -1,8 +1,15 @@
 class NotReadyError extends Error {
-  cause;
+  t;
   constructor(e) {
     super();
-    this.cause = e;
+    this.t = e;
+  }
+}
+class StatusError extends Error {
+  t;
+  constructor(e, t) {
+    super(t instanceof Error ? t.message : String(t), { cause: t });
+    this.t = e;
   }
 }
 class NoOwnerError extends Error {
@@ -24,7 +31,6 @@ const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
 const REACTIVE_ZOMBIE = 1 << 5;
 const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
-const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -36,111 +42,187 @@ const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
 const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
-  const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
-  if (n >= e.o) e.o = n + 1;
-  const i = e.o;
-  const r = t.l[i];
-  if (r === undefined) t.l[i] = e;
+  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;
   else {
-    const t = r.T;
-    t.R = e;
-    e.T = t;
-    r.T = e;
+    const t = r.R;
+    t.O = e;
+    e.R = t;
+    r.R = e;
   }
-  if (i > t.O) t.O = i;
+  if (i > t.S) t.S = i;
 }
 function insertIntoHeap(e, t) {
-  let n = e.S;
+  let n = e._;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
   if (n & REACTIVE_CHECK) {
-    e.S = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else e.S = n | REACTIVE_IN_HEAP;
+    e._ = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e._ = n | REACTIVE_IN_HEAP;
   if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e.S;
+  let n = e._;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
-  e.S = n | REACTIVE_IN_HEAP_HEIGHT;
+  e._ = n | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e.S;
+  const n = e._;
   if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  e.S = n & -25;
-  const i = e.o;
-  if (e.T === e) t.l[i] = undefined;
+  e._ = n & -25;
+  const i = e.u;
+  if (e.R === e) t.T[i] = undefined;
   else {
-    const n = e.R;
-    const r = t.l[i];
+    const n = e.O;
+    const r = t.T[i];
     const o = n ?? r;
-    if (e === r) t.l[i] = n;
-    else e.T.R = n;
-    o.T = e.T;
+    if (e === r) t.T[i] = n;
+    else e.R.O = n;
+    o.R = e.R;
   }
-  e.T = e;
-  e.R = undefined;
+  e.R = e;
+  e.O = undefined;
 }
 function markHeap(e) {
-  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);
+  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);
     }
   }
 }
 function markNode(e, t = REACTIVE_DIRTY) {
-  const n = e.S;
+  const n = e._;
   if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-  e.S = (n & -4) | t;
-  for (let t = e.p; t !== null; t = t.I) {
-    markNode(t.h, REACTIVE_CHECK);
-  }
-  if (e.A !== null) {
-    for (let t = e.A; t !== null; t = t.P) {
-      for (let e = t.p; e !== null; e = e.I) {
-        markNode(e.h, REACTIVE_CHECK);
+  e._ = (n & -4) | t;
+  for (let t = e.p; t !== null; t = t.h) {
+    markNode(t.A, 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);
       }
     }
   }
 }
 function runHeap(e, t) {
-  e._ = false;
-  for (e.N = 0; e.N <= e.O; e.N++) {
-    let n = e.l[e.N];
+  e.I = false;
+  for (e.C = 0; e.C <= e.S; e.C++) {
+    let n = e.T[e.C];
     while (n !== undefined) {
-      if (n.S & REACTIVE_IN_HEAP) t(n);
+      if (n._ & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.N];
+      n = e.T[e.C];
     }
   }
-  e.O = 0;
+  e.S = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
-  let n = e.o;
-  for (let t = e.C; t; t = t.D) {
+  let n = e.u;
+  for (let t = e.D; t; t = t.m) {
     const e = t.V;
-    const i = e.m || e;
-    if (i.U && i.o >= n) n = i.o + 1;
+    const i = e.L || e;
+    if (i.U && i.u >= n) n = i.u + 1;
   }
-  if (e.o !== n) {
-    e.o = n;
-    for (let n = e.p; n !== null; n = n.I) {
-      insertIntoHeapHeight(n.h, t);
+  if (e.u !== n) {
+    e.u = n;
+    for (let n = e.p; n !== null; n = n.h) {
+      insertIntoHeapHeight(n.A, t);
     }
   }
 }
 const transitions = new Set();
-const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, N: 0, O: 0 };
-const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, N: 0, O: 0 };
+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 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
-let optimisticReadActive = false;
 let projectionWriteActive = false;
-function setOptimisticReadActive(e) {
-  optimisticReadActive = e;
+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 (n.length) {
+      t.M[e - 1] = [];
+      runQueue(n, e);
+    }
+  }
 }
 function setProjectionWriteActive(e) {
   projectionWriteActive = e;
@@ -148,133 +230,129 @@ function setProjectionWriteActive(e) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.k) queueMicrotask(flush);
+  if (!globalQueue.X) queueMicrotask(flush);
 }
 class Queue {
-  i = null;
-  W = [[], []];
-  G = [[], []];
-  M = [];
+  o = null;
+  q = [[], []];
+  Z = [];
   created = clock;
   addChild(e) {
-    this.M.push(e);
-    e.i = this;
+    this.Z.push(e);
+    e.o = this;
   }
   removeChild(e) {
-    const t = this.M.indexOf(e);
+    const t = this.Z.indexOf(e);
     if (t >= 0) {
-      this.M.splice(t, 1);
-      e.i = null;
+      this.Z.splice(t, 1);
+      e.o = null;
     }
   }
-  notify(e, t, n) {
-    if (this.i) return this.i.notify(e, t, n);
+  notify(e, t, n, i) {
+    if (this.o) return this.o.notify(e, t, n, i);
     return false;
   }
-  $(e, t, n) {
-    if (t[e - 1].length) {
-      const n = t[e - 1];
-      t[e - 1] = [];
-      runQueue(n, e);
-    }
-    for (let t = 0; t < this.M.length; t++) {
-      this.M[t][n]?.(e);
-    }
-  }
   run(e) {
-    this.$(e, this.W, "run");
-  }
-  runOptimistic(e) {
-    this.$(e, this.G, "runOptimistic");
+    if (this.q[e - 1].length) {
+      const t = this.q[e - 1];
+      this.q[e - 1] = [];
+      runQueue(t, e);
+    }
+    for (let t = 0; t < this.Z.length; t++) this.Z[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
-      const n = optimisticReadActive ? this.G : this.W;
-      n[e - 1].push(t);
+      if (currentOptimisticLane) {
+        const n = findLane(currentOptimisticLane);
+        n.M[e - 1].push(t);
+      } else {
+        this.q[e - 1].push(t);
+      }
     }
     schedule();
   }
   stashQueues(e) {
-    e.W[0].push(...this.W[0]);
-    e.W[1].push(...this.W[1]);
-    this.W = [[], []];
-    for (let t = 0; t < this.M.length; t++) {
-      let n = this.M[t];
-      let i = e.M[t];
+    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];
       if (!i) {
-        i = { W: [[], []], M: [] };
-        e.M[t] = i;
+        i = { q: [[], []], Z: [] };
+        e.Z[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.W[0].push(...e.W[0]);
-    this.W[1].push(...e.W[1]);
-    for (let t = 0; t < e.M.length; t++) {
-      const n = e.M[t];
-      let i = this.M[t];
+    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];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  k = false;
-  L = [];
-  H = [];
-  F = new Set();
-  static j;
-  static K;
-  static Y = null;
+  X = false;
+  J = [];
+  ee = [];
+  te = new Set();
+  static ne;
+  static ie;
+  static re = null;
   flush() {
-    if (this.k) return;
-    this.k = true;
+    if (this.X) return;
+    this.X = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.j);
+      runHeap(dirtyQueue, GlobalQueue.ne);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
           let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.j);
-          this.L = [];
-          this.H = [];
-          this.F = new Set();
-          this.runOptimistic(EFFECT_RENDER);
-          this.runOptimistic(EFFECT_USER);
-          this.stashQueues(activeTransition.queueStash);
+          runHeap(zombieQueue, GlobalQueue.ne);
+          this.J = [];
+          this.ee = [];
+          this.te = new Set();
+          runLaneEffects(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.stashQueues(activeTransition.oe);
           clock++;
-          scheduled = false;
-          runTransitionPending(activeTransition.pendingNodes);
+          scheduled = dirtyQueue.S >= dirtyQueue.C;
+          reassignPendingTransition(activeTransition.J);
           activeTransition = null;
           finalizePureQueue(null, true);
           return;
         }
-        this.L !== activeTransition.pendingNodes && this.L.push(...activeTransition.pendingNodes);
-        this.restoreQueues(activeTransition.queueStash);
+        this.J !== activeTransition.J && this.J.push(...activeTransition.J);
+        this.restoreQueues(activeTransition.oe);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        runTransitionPending(this.L);
+        reassignPendingTransition(this.J);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.j);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.ne);
         finalizePureQueue();
       }
       clock++;
-      scheduled = dirtyQueue.O >= dirtyQueue.N;
-      this.runOptimistic(EFFECT_RENDER);
+      scheduled = dirtyQueue.S >= dirtyQueue.C;
+      runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
-      this.runOptimistic(EFFECT_USER);
+      runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.k = false;
+      this.X = false;
     }
   }
-  notify(e, t, n) {
+  notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        if (activeTransition && e.B && !activeTransition.asyncNodes.includes(e.B.cause)) {
-          activeTransition.asyncNodes.push(e.B.cause);
+        const t = i !== undefined ? i : e.se;
+        if (activeTransition && t && !activeTransition.ue.includes(t.t)) {
+          activeTransition.ue.push(t.t);
           schedule();
         }
       }
@@ -285,106 +363,143 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.time === clock) return;
+    if (!e && activeTransition && activeTransition.ce === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        time: clock,
-        pendingNodes: [],
-        asyncNodes: [],
-        optimisticNodes: [],
-        optimisticStores: new Set(),
-        actions: [],
-        queueStash: { W: [[], []], M: [] },
-        done: false
+        ce: clock,
+        J: [],
+        ue: [],
+        ee: [],
+        te: new Set(),
+        le: [],
+        oe: { q: [[], []], Z: [] },
+        ae: false
       };
     } else if (e) {
-      activeTransition.done = e;
-      e.actions.push(...activeTransition.actions);
-      transitions.delete(activeTransition);
+      const t = activeTransition;
+      t.ae = e;
+      e.le.push(...t.le);
+      for (const n of activeLanes) {
+        if (n.$ === t) n.$ = e;
+      }
+      e.ee.push(...t.ee);
+      for (const n of t.te) {
+        e.te.add(n);
+      }
+      transitions.delete(t);
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.time = clock;
-    for (let e = 0; e < this.L.length; e++) {
-      const t = this.L[e];
-      t.X = activeTransition;
-      activeTransition.pendingNodes.push(t);
+    activeTransition.ce = clock;
+    for (let e = 0; e < this.J.length; e++) {
+      const t = this.J[e];
+      t.$ = activeTransition;
+      activeTransition.J.push(t);
     }
-    this.L = activeTransition.pendingNodes;
-    for (let e = 0; e < this.H.length; e++) {
-      const t = this.H[e];
-      t.X = activeTransition;
-      activeTransition.optimisticNodes.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.H = activeTransition.optimisticNodes;
-    for (const e of this.F) {
-      activeTransition.optimisticStores.add(e);
+    this.ee = activeTransition.ee;
+    for (const e of activeLanes) {
+      if (!e.$) e.$ = activeTransition;
     }
-    this.F = activeTransition.optimisticStores;
+    for (const e of this.te) activeTransition.te.add(e);
+    this.te = activeTransition.te;
   }
 }
 function insertSubs(e, t = false) {
-  for (let n = e.p; n !== null; n = n.I) {
-    if (t) n.h.S |= REACTIVE_OPTIMISTIC_DIRTY;
-    const e = n.h;
-    if (e.q === EFFECT_TRACKED) {
-      if (!e.Z) {
-        e.Z = true;
-        e.J.enqueue(EFFECT_USER, e.ee);
+  const n = e.W || currentOptimisticLane;
+  for (let i = e.p; i !== null; i = i.h) {
+    if (t && n) {
+      i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(i.A, n);
+    } else if (t) {
+      i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
+      i.A.W = undefined;
+    }
+    const e = i.A;
+    if (e.fe === EFFECT_TRACKED) {
+      if (!e.Ee) {
+        e.Ee = true;
+        e.Te.enqueue(EFFECT_USER, e.de);
       }
       continue;
     }
-    const i = n.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (i.N > n.h.o) i.N = n.h.o;
-    insertIntoHeap(n.h, i);
+    const r = i.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (r.C > i.A.u) r.C = i.A.u;
+    insertIntoHeap(i.A, r);
   }
 }
 function finalizePureQueue(e = null, t = false) {
   let n = !t;
-  if (dirtyQueue.O >= dirtyQueue.N) {
-    runHeap(dirtyQueue, GlobalQueue.j);
-  }
+  if (!t) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue.S >= dirtyQueue.C) runHeap(dirtyQueue, GlobalQueue.ne);
   if (n) {
-    const t = globalQueue.L;
+    const t = globalQueue.J;
     for (let e = 0; e < t.length; e++) {
       const n = t[e];
-      if (n.te !== NOT_PENDING) {
-        n.ne = n.te;
-        n.te = NOT_PENDING;
-        if (n.q && n.q !== EFFECT_TRACKED) n.Z = true;
+      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.U) GlobalQueue.K(n, false, true);
+      n.Oe &= ~STATUS_UNINITIALIZED;
+      if (n.U) GlobalQueue.ie(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.optimisticNodes : globalQueue.H;
+    const n = e ? e.ee : globalQueue.ee;
     for (let e = 0; e < n.length; e++) {
       const t = n[e];
-      const i = t.te;
-      if (i !== NOT_PENDING && t.ne !== i) {
-        t.ne = i;
+      const i = t.B;
+      t.W = undefined;
+      if (i !== NOT_PENDING && t.Re !== i) {
+        t.Re = i;
         insertSubs(t, true);
       }
-      t.te = NOT_PENDING;
-      t.X = null;
+      t.B = NOT_PENDING;
+      t.$ = null;
     }
     n.length = 0;
-    const i = e ? e.optimisticStores : globalQueue.F;
-    if (GlobalQueue.Y && i.size) {
+    const i = e ? e.te : globalQueue.te;
+    if (GlobalQueue.re && i.size) {
       for (const e of i) {
-        GlobalQueue.Y(e);
+        GlobalQueue.re(e);
       }
       i.clear();
       schedule();
     }
+    for (const t of activeLanes) {
+      const n = e ? t.$ === e : !t.$;
+      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;
+      activeLanes.delete(t);
+      signalLanes.delete(t.t);
+    }
+  }
+}
+function checkBoundaryChildren(e) {
+  for (const t of e.Z) {
+    t.checkSources?.();
+    checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.F.add(e);
+  globalQueue.te.add(e);
   schedule();
 }
-function runTransitionPending(e) {
+function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].X = activeTransition;
+    e[t].$ = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -397,20 +512,21 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.done) return true;
-  if (e.actions.length) return false;
+  if (e.ae) return true;
+  if (e.le.length) return false;
   let t = true;
-  for (let n = 0; n < e.asyncNodes.length; n++) {
-    if (e.asyncNodes[n].ie & STATUS_PENDING) {
+  for (let n = 0; n < e.ue.length; n++) {
+    const i = e.ue[n];
+    if (i.Oe & STATUS_PENDING && i.se?.t === i) {
       t = false;
       break;
     }
   }
-  t && (e.done = true);
+  t && (e.ae = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.done && typeof e.done === "object") e = e.done;
+  while (e.ae && typeof e.ae === "object") e = e.ae;
   return e;
 }
 function runInTransition(e, t) {
@@ -434,11 +550,11 @@ function action(e) {
       const r = e(...t);
       globalQueue.initTransition();
       let o = activeTransition;
-      o.actions.push(r);
+      o.le.push(r);
       const done = (e, t) => {
         o = currentTransition(o);
-        const s = o.actions.indexOf(r);
-        if (s >= 0) o.actions.splice(s, 1);
+        const s = o.le.indexOf(r);
+        if (s >= 0) o.le.splice(s, 1);
         activeTransition = o;
         schedule();
         t ? i(t) : n(e);
@@ -466,8 +582,8 @@ function action(e) {
       step();
     });
 }
-GlobalQueue.j = recompute;
-GlobalQueue.K = disposeChildren;
+GlobalQueue.ne = recompute;
+GlobalQueue.ie = disposeChildren;
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -476,105 +592,149 @@ let foundPending = false;
 let pendingReadActive = false;
 let context = null;
 function recompute(e, t = false) {
-  const n = e.q;
+  const n = e.fe;
   if (!t) {
-    if (e.X && (!n || activeTransition) && activeTransition !== e.X)
-      globalQueue.initTransition(e.X);
-    deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.X) disposeChildren(e);
+    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.re = e.oe;
-      e.se = e.ue;
-      e.oe = null;
-      e.ue = null;
+      e.Se = e._e;
+      e.Ie = e.pe;
+      e._e = null;
+      e.pe = null;
     }
   }
-  const i = !!(e.S & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = e.le && e.te !== NOT_PENDING;
-  const o = context;
+  const i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = hasActiveOverride(e);
+  const o = !!(e.Oe & STATUS_PENDING);
+  const s = context;
   context = e;
-  e.ce = null;
-  e.S = REACTIVE_RECOMPUTING_DEPS;
-  e.ae = clock;
-  let s = e.te === NOT_PENDING ? e.ne : e.te;
-  let u = e.o;
+  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 c = optimisticReadActive;
+  let a = currentOptimisticLane;
   tracking = true;
-  if (i) setOptimisticReadActive(true);
+  if (i) {
+    const t = resolveLane(e);
+    if (t) setCurrentOptimisticLane(t);
+  }
   try {
-    s = handleAsync(e, e.U(s));
+    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) {
-      if (t.cause !== e) link(t.cause, e);
-      notifyStatus(e, STATUS_PENDING, t);
-    } else notifyStatus(e, STATUS_ERROR, 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.S = REACTIVE_NONE;
-    context = o;
+    e._ = REACTIVE_NONE;
+    context = s;
   }
-  if (!e.B) {
-    const o = e.ce;
-    let l = o !== null ? o.D : e.C;
+  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 (o !== null) o.D = null;
-      else e.C = null;
-    }
-    const c = !e.fe || !e.fe(e.te === NOT_PENDING ? e.ne : e.te, s);
-    if (c) {
-      if (t || (n && activeTransition !== e.X) || i) e.ne = s;
-      else e.te = s;
-      insertSubs(e, i || r);
-    } else if (e.o != u) {
-      for (let t = e.p; t !== null; t = t.I) {
-        insertIntoHeapHeight(t.h, t.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      if (s !== null) s.m = null;
+      else e.D = null;
+    }
+    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);
       }
     }
   }
-  setOptimisticReadActive(c);
-  (!t || e.ie & STATUS_PENDING) && !e.X && !(activeTransition && e.le) && globalQueue.L.push(e);
-  e.X && n && activeTransition !== e.X && runInTransition(e.X, () => recompute(e));
+  setCurrentOptimisticLane(a);
+  (!t || e.Oe & STATUS_PENDING) && !e.$ && !(activeTransition && e.Y) && globalQueue.J.push(e);
+  e.$ && n && activeTransition !== e.$ && runInTransition(e.$, () => recompute(e));
 }
 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.Ee = null;
+    e.ge = null;
     return t;
   }
-  e.Ee = t;
+  e.ge = t;
   let s;
   const handleError = n => {
-    if (e.Ee !== t) return;
-    globalQueue.initTransition(e.X);
-    if (n instanceof NotReadyError) {
-      if (n.cause !== e) link(n.cause, e);
-      notifyStatus(e, STATUS_PENDING, n);
-    } else notifyStatus(e, STATUS_ERROR, n);
-    e.ae = clock;
+    if (e.ge !== t) return;
+    globalQueue.initTransition(e.$);
+    notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
+    e.ce = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e.Ee !== t) return;
-    globalQueue.initTransition(e.X);
+    if (e.ge !== t) return;
+    if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(e.$);
     clearStatus(e);
+    const o = resolveLane(e);
+    if (o) o.G.delete(e);
     if (n) n(i);
-    else if (e.le) {
-      const t = e.te !== NOT_PENDING;
-      if (e.U) e.te = i;
+    else if (e.Y) {
+      const t = e.B !== NOT_PENDING;
+      if (e.U) e.B = i;
       if (!t) {
-        e.ne = i;
+        e.Re = i;
         insertSubs(e);
       }
-      e.ae = clock;
-      schedule();
-    } else setSignal(e, () => i);
+      e.ce = clock;
+    } else if (o) {
+      const t = e.Re;
+      const n = e.Ae;
+      if (!n || !n(i, t)) {
+        e.Re = i;
+        e.ce = clock;
+        if (e.Ne) {
+          setSignal(e.Ne, i);
+        }
+        insertSubs(e, true);
+      }
+    } else {
+      setSignal(e, () => i);
+    }
+    schedule();
     flush();
     r?.();
   };
@@ -594,7 +754,7 @@ function handleAsync(e, t, n) {
     );
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.X);
+      globalQueue.initTransition(e.$);
       throw new NotReadyError(context);
     }
   }
@@ -626,177 +786,191 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.X);
+      globalQueue.initTransition(e.$);
       throw new NotReadyError(context);
     }
   }
   return s;
 }
 function clearStatus(e) {
-  e.ie = STATUS_NONE;
-  e.B = null;
+  e.Oe = e.Oe & STATUS_UNINITIALIZED;
+  e.se = null;
   updatePendingSignal(e);
-  if (e.Te) {
-    e.Te();
-  } else {
-    if (!e.X) {
-      for (let t = e.p; t !== null; t = t.I) {
-        if (t.h.ie & STATUS_PENDING) {
-          insertIntoHeap(t.h, t.h.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-        }
-      }
+  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 u = s && hasActiveOverride(e);
+  if (!i) {
+    e.Oe = t | (t !== STATUS_ERROR ? e.Oe & STATUS_UNINITIALIZED : 0);
+    e.se = 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 c = i || u;
+  const l = i || s ? undefined : r;
+  if (e.Pe) {
+    if (c) {
+      e.Pe(t, n);
+    } else {
+      e.Pe();
     }
-    schedule();
+    return;
   }
-}
-function notifyStatus(e, t, n) {
-  e.ie = t | (t !== STATUS_ERROR ? e.ie & STATUS_UNINITIALIZED : 0);
-  e.B = n;
-  updatePendingSignal(e);
-  if (e.Te) return e.Te();
-  for (let i = e.p; i !== null; i = i.I) {
-    i.h.ae = clock;
-    if (i.h.B !== n) {
-      !i.h.X && globalQueue.L.push(i.h);
-      notifyStatus(i.h, t, n);
+  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.A; i !== null; i = i.P) {
-    for (let e = i.p; e !== null; e = e.I) {
-      e.h.ae = clock;
-      if (e.h.B !== n) {
-        !e.h.X && globalQueue.L.push(e.h);
-        notifyStatus(e.h, t, n);
+  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);
       }
     }
   }
 }
 function updateIfNecessary(e) {
-  if (e.S & REACTIVE_CHECK) {
-    for (let t = e.C; t; t = t.D) {
+  if (e._ & REACTIVE_CHECK) {
+    for (let t = e.D; t; t = t.m) {
       const n = t.V;
-      const i = n.m || n;
+      const i = n.L || n;
       if (i.U) {
         updateIfNecessary(i);
       }
-      if (e.S & REACTIVE_DIRTY) {
+      if (e._ & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (e.S & REACTIVE_DIRTY) {
+  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.se && e.ce < clock)) {
     recompute(e);
   }
-  e.S = REACTIVE_NONE;
+  e._ = REACTIVE_NONE;
 }
 function unlinkSubs(e) {
   const t = e.V;
-  const n = e.D;
-  const i = e.I;
-  const r = e.Re;
-  if (i !== null) i.Re = r;
-  else t.de = r;
-  if (r !== null) r.I = i;
+  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;
   else {
     t.p = i;
     if (i === null) {
-      t.Oe?.();
-      t.U && !t.Se && unobserved(t);
+      t.De?.();
+      t.U && !t.ve && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
-  deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let t = e.C;
+  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.D;
   while (t !== null) {
     t = unlinkSubs(t);
   }
-  e.C = null;
+  e.D = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.ce;
+  const n = t.he;
   if (n !== null && n.V === e) return;
   let i = null;
-  const r = t.S & REACTIVE_RECOMPUTING_DEPS;
+  const r = t._ & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
-    i = n !== null ? n.D : t.C;
+    i = n !== null ? n.m : t.D;
     if (i !== null && i.V === e) {
-      t.ce = i;
+      t.he = i;
       return;
     }
   }
-  const o = e.de;
-  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
-  const s = (t.ce = e.de = { V: e, h: t, D: i, Re: o, I: null });
-  if (n !== null) n.D = s;
-  else t.C = s;
-  if (o !== null) o.I = s;
+  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;
 }
 function isValidLink(e, t) {
-  const n = t.ce;
+  const n = t.he;
   if (n !== null) {
-    let i = t.C;
+    let i = t.D;
     do {
       if (i === e) return true;
       if (i === n) break;
-      i = i.D;
+      i = i.m;
     } while (i !== null);
   }
   return false;
 }
 function markDisposal(e) {
-  let t = e.ue;
+  let t = e.pe;
   while (t) {
-    t.S |= REACTIVE_ZOMBIE;
-    if (t.S & REACTIVE_IN_HEAP) {
+    t._ |= REACTIVE_ZOMBIE;
+    if (t._ & REACTIVE_IN_HEAP) {
       deleteFromHeap(t, dirtyQueue);
       insertIntoHeap(t, zombieQueue);
     }
     markDisposal(t);
-    t = t._e;
+    t = t.we;
   }
 }
 function dispose(e) {
-  let t = e.C || null;
+  let t = e.D || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.C = null;
-  e.ce = null;
+  e.D = null;
+  e.he = 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.se : e.ue;
+  if (e._ & REACTIVE_DISPOSED) return;
+  if (t) e._ = REACTIVE_DISPOSED;
+  let i = n ? e.Ie : e.pe;
   while (i) {
-    const e = i._e;
-    if (i.C) {
+    const e = i.we;
+    if (i.D) {
       const e = i;
-      deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.C;
+      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.D;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.C = null;
-      e.ce = null;
+      e.D = null;
+      e.he = null;
     }
     disposeChildren(i, true);
     i = e;
   }
   if (n) {
-    e.se = null;
+    e.Ie = null;
   } else {
-    e.ue = null;
-    e._e = null;
+    e.pe = null;
+    e.we = null;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.re : e.oe;
+  let n = t ? e.Se : e._e;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -806,10 +980,10 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.re = null) : (e.oe = null);
+  t ? (e.Se = null) : (e._e = null);
 }
 function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.pe++);
+  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) {
@@ -820,102 +994,132 @@ function formatId(e, t) {
 function computed(e, t, n) {
   const i = {
     id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    fe: n?.equals != null ? n.equals : isEqual,
-    Ie: !!n?.pureWrite,
-    Oe: n?.unobserved,
-    oe: null,
-    J: context?.J ?? globalQueue,
-    he: context?.he ?? defaultContext,
-    pe: 0,
+    Ae: n?.equals != null ? n.equals : isEqual,
+    me: !!n?.pureWrite,
+    De: n?.unobserved,
+    _e: null,
+    Te: context?.Te ?? globalQueue,
+    Ve: context?.Ve ?? defaultContext,
+    be: 0,
     U: e,
-    ne: t,
-    o: 0,
-    A: null,
-    R: undefined,
-    T: null,
-    C: null,
-    ce: null,
+    Re: t,
+    u: 0,
+    N: null,
+    O: undefined,
+    R: null,
+    D: null,
+    he: null,
     p: null,
-    de: null,
-    i: context,
-    _e: null,
-    ue: null,
-    S: REACTIVE_NONE,
-    ie: STATUS_UNINITIALIZED,
-    ae: clock,
-    te: NOT_PENDING,
-    re: null,
-    se: null,
-    Ee: null,
-    X: null
+    ye: null,
+    o: context,
+    we: null,
+    pe: null,
+    _: REACTIVE_NONE,
+    Oe: STATUS_UNINITIALIZED,
+    ce: clock,
+    B: NOT_PENDING,
+    Se: null,
+    Ie: null,
+    ge: null,
+    $: null
   };
-  i.T = i;
-  const r = context?.t ? context.u : context;
+  i.R = i;
+  const r = context?.i ? context.l : context;
   if (context) {
-    const e = context.ue;
+    const e = context.pe;
     if (e === null) {
-      context.ue = i;
+      context.pe = i;
     } else {
-      i._e = e;
-      context.ue = i;
+      i.we = e;
+      context.pe = i;
     }
   }
-  if (r) i.o = r.o + 1;
+  if (r) i.u = r.u + 1;
   !n?.lazy && recompute(i, true);
   return i;
 }
 function signal(e, t, n = null) {
   const i = {
-    fe: t?.equals != null ? t.equals : isEqual,
-    Ie: !!t?.pureWrite,
-    Oe: t?.unobserved,
-    ne: e,
+    Ae: t?.equals != null ? t.equals : isEqual,
+    me: !!t?.pureWrite,
+    De: t?.unobserved,
+    Re: e,
     p: null,
-    de: null,
-    ae: clock,
-    m: n,
-    P: n?.A || null,
-    te: NOT_PENDING
+    ye: null,
+    ce: clock,
+    L: n,
+    P: n?.N || null,
+    B: NOT_PENDING
   };
-  n && (n.A = i);
+  n && (n.N = i);
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.le = true;
+  n.Y = true;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const i = computed(e, t, n);
-  i.le = true;
+  i.Y = true;
   return i;
 }
 function getPendingSignal(e) {
-  if (!e.Ae) {
-    e.Ae = optimisticSignal(false, { pureWrite: true });
-    if (computePendingState(e)) setSignal(e.Ae, true);
+  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.Ae;
+  return e.Le;
 }
 function computePendingState(e) {
-  if (e.te !== NOT_PENDING) return true;
   const t = e;
-  return !!(t.ie & STATUS_PENDING && !(t.ie & STATUS_UNINITIALIZED));
+  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.ge) {
+  if (!e.Ne) {
     const t = pendingReadActive;
     pendingReadActive = false;
-    const n = context;
+    const n = pendingCheckActive;
+    pendingCheckActive = false;
+    const i = context;
     context = null;
-    e.ge = optimisticComputed(() => read(e));
-    context = n;
+    e.Ne = optimisticComputed(() => read(e));
+    e.Ne.k = e;
+    context = i;
+    pendingCheckActive = n;
     pendingReadActive = t;
   }
-  return e.ge;
+  return e.Ne;
 }
 function updatePendingSignal(e) {
-  if (e.Ae) setSignal(e.Ae, computePendingState(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;
@@ -930,8 +1134,24 @@ function untrack(e) {
   }
 }
 function read(e) {
+  if (pendingReadActive) {
+    const t = getPendingValueComputed(e);
+    const n = pendingReadActive;
+    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);
+      const i = findLane(currentOptimisticLane);
+      if (n !== i && n.G.size > 0) {
+        return e.Re;
+      }
+    }
+    return i;
+  }
   if (pendingCheckActive) {
-    const t = e.m || e;
+    const t = e.L || e;
     const n = getPendingSignal(t);
     const i = pendingCheckActive;
     pendingCheckActive = false;
@@ -939,86 +1159,92 @@ function read(e) {
       foundPending = true;
     }
     pendingCheckActive = i;
-    return e.ne;
-  }
-  if (pendingReadActive) {
-    const t = getPendingValueComputed(e);
-    const n = pendingReadActive;
-    pendingReadActive = false;
-    const i = read(t);
-    pendingReadActive = n;
-    if (t.ie & STATUS_PENDING) return e.ne;
-    return i;
+    return e.Re;
   }
   let t = context;
-  if (t?.t) t = t.u;
+  if (t?.i) t = t.l;
   if (refreshing && e.U) recompute(e);
   if (t && tracking) {
-    if (e.U && e.S & REACTIVE_DISPOSED) recompute(e);
+    if (e.U && e._ & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    const n = e.m || e;
+    const n = e.L || e;
     if (n.U) {
-      const i = e.S & REACTIVE_ZOMBIE;
-      if (n.o >= (i ? zombieQueue.N : dirtyQueue.N)) {
+      const i = e._ & REACTIVE_ZOMBIE;
+      if (n.u >= (i ? zombieQueue.C : dirtyQueue.C)) {
         markNode(t);
         markHeap(i ? zombieQueue : dirtyQueue);
         updateIfNecessary(n);
       }
-      const r = n.o;
-      if (r >= t.o && e.i !== t) {
-        t.o = r + 1;
+      const r = n.u;
+      if (r >= t.u && e.o !== t) {
+        t.u = r + 1;
+      }
+    }
+  }
+  const n = e.L || e;
+  if (t && n.Oe & STATUS_PENDING && !(stale && n.$ && activeTransition !== n.$)) {
+    if (currentOptimisticLane) {
+      const i = n.W;
+      const r = findLane(currentOptimisticLane);
+      if (i && findLane(i) === r && !hasActiveOverride(n)) {
+        if (!tracking) link(e, t);
+        throw n.se;
       }
+    } else {
+      if (!tracking) link(e, t);
+      throw n.se;
     }
   }
-  const n = e.m || e;
-  if (
-    t &&
-    !optimisticReadActive &&
-    n.ie & STATUS_PENDING &&
-    !(stale && n.X && activeTransition !== n.X)
-  )
-    throw n.B;
-  if (e.U && e.ie & STATUS_ERROR) {
-    if (e.ae < clock) {
+  if (e.U && e.Oe & STATUS_ERROR) {
+    if (e.ce < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.B;
+    } else throw e.se;
   }
   return !t ||
-    optimisticReadActive ||
-    e.te === NOT_PENDING ||
-    (stale && e.X && activeTransition !== e.X)
-    ? e.ne
-    : e.te;
+    currentOptimisticLane !== null ||
+    e.B === NOT_PENDING ||
+    (stale && e.$ && activeTransition !== e.$)
+    ? e.Re
+    : e.B;
 }
 function setSignal(e, t) {
-  if (e.X && activeTransition !== e.X) globalQueue.initTransition(e.X);
-  const n = e.le && !projectionWriteActive;
-  const i = n ? e.ne : e.te === NOT_PENDING ? e.ne : e.te;
+  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 (typeof t === "function") t = t(i);
-  const r = !e.fe || !e.fe(i, t);
-  if (!r) return t;
+  const r = !e.Ae || !e.Ae(i, t);
+  if (!r) {
+    if (n && e.B !== NOT_PENDING && e.U) {
+      insertSubs(e, true);
+      schedule();
+    }
+    return t;
+  }
   if (n) {
-    const n = globalQueue.H.includes(e);
-    if (e.X && n) {
-      globalQueue.initTransition(e.X);
+    const n = globalQueue.ee.includes(e);
+    if (e.$ && n) {
+      globalQueue.initTransition(e.$);
     }
-    if (e.te === NOT_PENDING) {
-      e.te = e.ne;
+    if (e.B === NOT_PENDING) {
+      e.B = e.Re;
     }
     if (!n) {
-      globalQueue.H.push(e);
+      globalQueue.ee.push(e);
     }
-    e.ne = t;
+    e.K = (e.K || 0) + 1;
+    const i = getOrCreateLane(e);
+    e.W = i;
+    e.Re = t;
   } else {
-    if (e.te === NOT_PENDING) globalQueue.L.push(e);
-    e.te = t;
+    if (e.B === NOT_PENDING) globalQueue.J.push(e);
+    e.B = t;
   }
   updatePendingSignal(e);
-  if (e.ge) {
-    setSignal(e.ge, t);
+  if (e.Ne) {
+    setSignal(e.Ne, t);
   }
-  e.ae = clock;
+  e.ce = clock;
   insertSubs(e, n);
   schedule();
   return t;
@@ -1033,37 +1259,37 @@ function getOwner() {
 }
 function onCleanup(e) {
   if (!context) return e;
-  if (!context.oe) context.oe = e;
-  else if (Array.isArray(context.oe)) context.oe.push(e);
-  else context.oe = [context.oe, 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),
-    t: true,
-    u: t?.t ? t.u : t,
-    ue: null,
+    i: true,
+    l: t?.i ? t.l : t,
+    pe: null,
+    we: null,
     _e: null,
-    oe: null,
-    J: t?.J ?? globalQueue,
-    he: t?.he || defaultContext,
-    pe: 0,
-    re: null,
-    se: null,
-    i: t,
+    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.ue;
+    const e = t.pe;
     if (e === null) {
-      t.ue = n;
+      t.pe = n;
     } else {
-      n._e = e;
-      t.ue = n;
+      n.we = e;
+      t.pe = n;
     }
   }
   return n;
@@ -1110,6 +1336,8 @@ function isPending(e) {
   try {
     e();
     return foundPending;
+  } catch {
+    return foundPending;
   } finally {
     pendingCheckActive = t;
     foundPending = n;
@@ -1141,7 +1369,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.he[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.Ve[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -1151,10 +1379,10 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.he = { ...n.he, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.Ve = { ...n.Ve, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.he[e.id]);
+  return !isUndefined(t?.Ve[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
@@ -1164,78 +1392,80 @@ function effect(e, t, n, i, r) {
   const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
     ...r,
     equals: () => {
-      s.Z = !s.B;
-      if (o) s.J.enqueue(s.q, runEffect.bind(s));
+      s.Ee = !s.se;
+      if (o) s.Te.enqueue(s.fe, runEffect.bind(s));
       return false;
     },
     lazy: true
   });
-  s.Pe = i;
-  s.Ne = t;
-  s.Ce = n;
-  s.ye = undefined;
-  s.q = r?.render ? EFFECT_RENDER : EFFECT_USER;
-  s.Te = () => {
-    if (s.ie & STATUS_ERROR) {
-      let e = s.B;
-      s.J.notify(s, STATUS_PENDING, 0);
-      if (s.q === EFFECT_USER) {
+  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) {
         try {
-          return s.Ce
-            ? s.Ce(e, () => {
-                s.ye?.();
-                s.ye = undefined;
+          return s.We
+            ? s.We(e, () => {
+                s.Qe?.();
+                s.Qe = undefined;
               })
             : console.error(e);
         } catch (t) {
           e = t;
         }
       }
-      if (!s.J.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (s.q === EFFECT_RENDER) s.J.notify(s, STATUS_PENDING | STATUS_ERROR, s.ie);
+      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.q === EFFECT_USER ? s.J.enqueue(s.q, runEffect.bind(s)) : runEffect.call(s));
+  !r?.defer && (s.fe === EFFECT_USER ? s.Te.enqueue(s.fe, runEffect.bind(s)) : runEffect.call(s));
   o = true;
-  onCleanup(() => s.ye?.());
+  onCleanup(() => s.Qe?.());
 }
 function runEffect() {
-  if (!this.Z || this.S & REACTIVE_DISPOSED) return;
-  this.ye?.();
-  this.ye = undefined;
+  if (!this.Ee || this._ & REACTIVE_DISPOSED) return;
+  this.Qe?.();
+  this.Qe = undefined;
   try {
-    this.ye = this.Ne(this.ne, this.Pe);
+    this.Qe = this.ke(this.Re, this.Ue);
   } catch (e) {
-    if (!this.J.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+    if (!this.Te.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.Pe = this.ne;
-    this.Z = false;
+    this.Ue = this.Re;
+    this.Ee = false;
   }
 }
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.Z || n.S & REACTIVE_DISPOSED) return;
-    n.Z = false;
+    if (!n.Ee || n._ & REACTIVE_DISPOSED) return;
+    n.Ee = false;
     recompute(n);
   };
   const n = computed(
     () => {
       try {
-        n.ye?.();
-        n.ye = undefined;
-        n.ye = staleValues(e) || undefined;
+        n.Qe?.();
+        n.Qe = undefined;
+        n.Qe = staleValues(e) || undefined;
       } finally {
       }
     },
     undefined,
     { ...t, lazy: true, pureWrite: true }
   );
-  n.ye = undefined;
-  n.Z = true;
-  n.q = EFFECT_TRACKED;
-  n.ee = run;
-  n.J.enqueue(EFFECT_USER, run);
-  onCleanup(() => n.ye?.());
+  n.Qe = undefined;
+  n.Ee = true;
+  n.fe = EFFECT_TRACKED;
+  n.de = run;
+  n.Te.enqueue(EFFECT_USER, run);
+  onCleanup(() => n.Qe?.());
 }
 function createSignal(e, t, n) {
   if (typeof e === "function") {
@@ -1328,26 +1558,26 @@ function applyState(e, t, n, i) {
   r[STORE_OVERRIDE] = undefined;
   if (Array.isArray(o)) {
     let t = false;
-    const l = getOverrideValue(o, s, u, "length");
-    if (e.length && l && e[0] && n(e[0]) != null) {
-      let c, a, f, E, T, R, d, O;
+    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;
       for (
-        f = 0, E = Math.min(l, e.length);
-        f < E && ((R = getOverrideValue(o, s, u, f)) === e[f] || (R && e[f] && n(R) === n(e[f])));
+        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++
       ) {
-        applyState(e[f], wrap(R, r), n, i);
+        applyState(e[f], wrap(d, r), n, i);
       }
       const S = new Array(e.length),
         _ = new Map();
       for (
-        E = l - 1, T = e.length - 1;
+        E = c - 1, T = e.length - 1;
         E >= f &&
         T >= f &&
-        ((R = getOverrideValue(o, s, u, E)) === e[T] || (R && e[T] && n(R) === n(e[T])));
+        ((d = getOverrideValue(o, s, u, E)) === e[T] || (d && e[T] && n(d) === n(e[T])));
         E--, T--
       ) {
-        S[T] = R;
+        S[T] = d;
       }
       if (f > T || f > E) {
         for (a = f; a <= T; a++) {
@@ -1361,24 +1591,24 @@ function applyState(e, t, n, i) {
           applyState(e[a], o, n, i);
         }
         t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
-        l !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
+        c !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
         return;
       }
-      d = new Array(T + 1);
+      R = new Array(T + 1);
       for (a = T; a >= f; a--) {
-        R = e[a];
-        O = R ? n(R) : R;
-        c = _.get(O);
-        d[a] = c === undefined ? -1 : c;
+        d = e[a];
+        O = d ? n(d) : d;
+        l = _.get(O);
+        R[a] = l === undefined ? -1 : l;
         _.set(O, a);
       }
-      for (c = f; c <= E; c++) {
-        R = getOverrideValue(o, s, u, c);
-        O = R ? n(R) : R;
+      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] = R;
-          a = d[a];
+          S[a] = d;
+          a = R[a];
           _.set(O, a);
         }
       }
@@ -1391,14 +1621,14 @@ function applyState(e, t, n, i) {
       }
       if (f < e.length) t = true;
     } else if (e.length) {
-      for (let t = 0, l = e.length; t < l; t++) {
-        const l = getOverrideValue(o, s, u, t);
-        isWrappable(l)
-          ? applyState(e[t], wrap(l, r), n, i)
+      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)
           : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
       }
     }
-    if (l !== e.length) {
+    if (c !== e.length) {
       t = true;
       r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
     }
@@ -1407,9 +1637,9 @@ function applyState(e, t, n, i) {
   }
   if (u) {
     const t = u[$TRACK];
-    const l = t || i ? getAllKeys(o, s, e) : Object.keys(u);
-    for (let c = 0, a = l.length; c < a; c++) {
-      const a = l[c];
+    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]);
@@ -1469,7 +1699,7 @@ function createProjectionInternal(e, t = {}, n) {
       r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(o);
     });
   });
-  i.Se = true;
+  i.ve = true;
   return { store: o, node: i };
 }
 function createProjection(e, t = {}, n) {
@@ -1569,7 +1799,7 @@ function getNode(e, t, n, i, r = isEqual, o) {
     },
     i
   );
-  if (o) s.le = true;
+  if (o) s.Y = true;
   return (e[t] = s);
 }
 function trackSelf(e, t = $TRACK) {
@@ -1612,39 +1842,39 @@ const storeTraps = {
     const o = e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE];
     const s = o || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]);
     const u = !!e[STORE_VALUE][$TARGET];
-    const l = o
+    const c = o
       ? e[STORE_OPTIMISTIC_OVERRIDE]
       : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
         ? e[STORE_OVERRIDE]
         : e[STORE_VALUE];
     if (!r) {
-      const e = Object.getOwnPropertyDescriptor(l, t);
+      const e = Object.getOwnPropertyDescriptor(c, t);
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = r && (s || !u) ? (r.te !== NOT_PENDING ? (r.le ? r.ne : r.te) : r.ne) : l[t];
+      let n = r && (s || !u) ? (r.B !== NOT_PENDING ? (r.Y ? r.Re : r.B) : r.Re) : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
       Writing?.add(i);
       return i;
     }
-    let c = r ? (s || !u ? read(i[t]) : (read(i[t]), l[t])) : l[t];
-    c === $DELETED && (c = undefined);
+    let l = r ? (s || !u ? read(i[t]) : (read(i[t]), c[t])) : c[t];
+    l === $DELETED && (l = undefined);
     if (!r) {
-      if (!s && typeof c === "function" && !l.hasOwnProperty(t)) {
+      if (!s && typeof l === "function" && !c.hasOwnProperty(t)) {
         let t;
         return !Array.isArray(e[STORE_VALUE]) &&
           (t = Object.getPrototypeOf(e[STORE_VALUE])) &&
           t !== Object.prototype
-          ? c.bind(l)
-          : c;
+          ? l.bind(c)
+          : l;
       } else if (getObserver()) {
         return read(
           getNode(
             i,
             t,
-            isWrappable(c) ? wrap(c, e) : c,
+            isWrappable(l) ? wrap(l, e) : l,
             e[STORE_FIREWALL],
             isEqual,
             e[STORE_OPTIMISTIC]
@@ -1652,7 +1882,7 @@ const storeTraps = {
         );
       }
     }
-    return isWrappable(c) ? wrap(c, e) : c;
+    return isWrappable(l) ? wrap(l, e) : l;
   },
   has(e, t) {
     if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -1671,8 +1901,8 @@ const storeTraps = {
     if (writeOnly(i)) {
       if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.X) {
-          globalQueue.initTransition(t.X);
+        if (t?.$) {
+          globalQueue.initTransition(t.$);
         }
       }
       untrack(() => {
@@ -1681,29 +1911,29 @@ const storeTraps = {
         const s = e[STORE_OPTIMISTIC] && !projectionWriteActive;
         const u = s ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
         if (s) trackOptimisticStore(i);
-        const l =
+        const c =
           e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
             ? e[STORE_OPTIMISTIC_OVERRIDE][t]
             : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
               ? e[STORE_OVERRIDE][t]
               : o;
-        const c = n?.[$TARGET]?.[STORE_VALUE] ?? n;
-        if (l === c) return true;
+        const l = n?.[$TARGET]?.[STORE_VALUE] ?? n;
+        if (c === l) return true;
         const a = e[STORE_OPTIMISTIC_OVERRIDE]?.length || e[STORE_OVERRIDE]?.length || r.length;
-        if (c !== undefined && c === o) delete e[u][t];
-        else (e[u] || (e[u] = Object.create(null)))[t] = c;
-        const f = isWrappable(c);
-        if (isWrappable(l)) {
-          const e = PARENTS.get(l);
-          e && (e instanceof Set ? e.delete(i) : PARENTS.delete(l));
+        if (l !== undefined && l === o) delete e[u][t];
+        else (e[u] || (e[u] = Object.create(null)))[t] = l;
+        const f = isWrappable(l);
+        if (isWrappable(c)) {
+          const e = PARENTS.get(c);
+          e && (e instanceof Set ? e.delete(i) : PARENTS.delete(c));
         }
-        if (recursivelyNotify(i, storeLookup) && f) recursivelyAddParent(c, i);
+        if (recursivelyNotify(i, storeLookup) && f) recursivelyAddParent(l, i);
         e[STORE_HAS]?.[t] && setSignal(e[STORE_HAS][t], true);
         const E = getNodes(e, STORE_NODE);
-        E[t] && setSignal(E[t], () => (f ? wrap(c, e) : c));
+        E[t] && setSignal(E[t], () => (f ? wrap(l, e) : l));
         if (Array.isArray(r)) {
           if (t === "length") {
-            E.length && setSignal(E.length, c);
+            E.length && setSignal(E.length, l);
           } else {
             const e = parseInt(t) + 1;
             if (e > a) E.length && setSignal(E.length, e);
@@ -1861,7 +2091,7 @@ function deep(e) {
   return e[$DEEP];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.Y ||= clearOptimisticStore;
+  GlobalQueue.re ||= clearOptimisticStore;
   const i = typeof e === "function";
   const r = (i ? t : e) ?? {};
   const o = i ? e : undefined;
@@ -1873,16 +2103,25 @@ function clearOptimisticStore(e) {
   if (!t || !t[STORE_OPTIMISTIC_OVERRIDE]) return;
   const n = t[STORE_OPTIMISTIC_OVERRIDE];
   const i = t[STORE_NODE];
-  if (i) {
-    for (const e of Reflect.ownKeys(n)) {
-      if (i[e]) {
-        const n =
-          t[STORE_OVERRIDE] && e in t[STORE_OVERRIDE] ? t[STORE_OVERRIDE][e] : t[STORE_VALUE][e];
-        const r = n === $DELETED ? undefined : n;
-        setSignal(i[e], isWrappable(r) ? wrap(r, t) : r);
+  setProjectionWriteActive(true);
+  try {
+    if (i) {
+      for (const e of Reflect.ownKeys(n)) {
+        if (i[e]) {
+          i[e].W = 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;
+          setSignal(i[e], isWrappable(r) ? wrap(r, t) : r);
+        }
+      }
+      if (i[$TRACK]) {
+        i[$TRACK].W = undefined;
+        setSignal(i[$TRACK], undefined);
       }
     }
-    i[$TRACK] && setSignal(i[$TRACK], undefined);
+  } finally {
+    setProjectionWriteActive(false);
   }
   delete t[STORE_OPTIMISTIC_OVERRIDE];
 }
@@ -1928,12 +2167,12 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
         setProjectionWriteActive(false);
       }
     });
-    i.Se = true;
+    i.ve = true;
   }
   return { store: o, node: i };
 }
 function snapshot(e, t, n) {
-  let i, r, o, s, u, l;
+  let i, r, o, s, u, c;
   if (!isWrappable(e)) return e;
   if (t && t.has(e)) return t.get(e);
   if (!t) t = new Map();
@@ -1953,26 +2192,26 @@ function snapshot(e, t, n) {
   if (r) {
     const i = o?.length || e.length;
     for (let r = 0; r < i; r++) {
-      l = o && r in o ? o[r] : e[r];
-      if (l === $DELETED) continue;
-      if ((u = snapshot(l, t, n)) !== l || s) {
+      c = o && r in o ? o[r] : e[r];
+      if (c === $DELETED) continue;
+      if ((u = snapshot(c, t, n)) !== c || s) {
         if (!s) t.set(e, (s = [...e]));
         s[r] = u;
       }
     }
   } else {
     const i = getKeys(e, o);
-    for (let r = 0, c = i.length; r < c; r++) {
-      let c = i[r];
-      const a = getPropertyDescriptor(e, o, c);
+    for (let r = 0, l = i.length; r < l; r++) {
+      let l = i[r];
+      const a = getPropertyDescriptor(e, o, l);
       if (a.get) continue;
-      l = o && c in o ? o[c] : e[c];
-      if ((u = snapshot(l, t, n)) !== e[c] || s) {
+      c = o && l in o ? o[l] : e[l];
+      if ((u = snapshot(c, t, n)) !== e[l] || s) {
         if (!s) {
           s = Object.create(Object.getPrototypeOf(e));
           Object.assign(s, e);
         }
-        s[c] = u;
+        s[l] = u;
       }
     }
   }
@@ -2112,281 +2351,289 @@ function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      De: createOwner(),
-      we: 0,
-      be: e,
-      ve: [],
-      Ve: t,
-      me: [],
-      Ue: [],
-      ke: i,
-      We: i || n?.keyed === false ? [] : undefined,
-      Qe: t.length > 1 ? [] : undefined,
-      xe: n?.fallback
+      xe: createOwner(),
+      Ge: 0,
+      Me: e,
+      Fe: [],
+      $e: t,
+      He: [],
+      je: [],
+      Ke: i,
+      Ye: i || n?.keyed === false ? [] : undefined,
+      Be: t.length > 1 ? [] : undefined,
+      Xe: n?.fallback
     })
   );
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.be() || [],
+  const e = this.Me() || [],
     t = e.length;
   e[$TRACK];
-  runWithOwner(this.De, () => {
+  runWithOwner(this.xe, () => {
     let n,
       i,
-      r = this.We
+      r = this.Ye
         ? () => {
-            this.We[i] = signal(e[i], pureOptions);
-            this.Qe && (this.Qe[i] = signal(i, pureOptions));
-            return this.Ve(
-              read.bind(null, this.We[i]),
-              this.Qe ? read.bind(null, this.Qe[i]) : undefined
+            this.Ye[i] = signal(e[i], pureOptions);
+            this.Be && (this.Be[i] = signal(i, pureOptions));
+            return this.$e(
+              read.bind(null, this.Ye[i]),
+              this.Be ? read.bind(null, this.Be[i]) : undefined
             );
           }
-        : this.Qe
+        : this.Be
           ? () => {
               const t = e[i];
-              this.Qe[i] = signal(i, pureOptions);
-              return this.Ve(() => t, read.bind(null, this.Qe[i]));
+              this.Be[i] = signal(i, pureOptions);
+              return this.$e(() => t, read.bind(null, this.Be[i]));
             }
           : () => {
               const t = e[i];
-              return this.Ve(() => t);
+              return this.$e(() => t);
             };
     if (t === 0) {
-      if (this.we !== 0) {
-        this.De.dispose(false);
-        this.Ue = [];
-        this.ve = [];
-        this.me = [];
-        this.we = 0;
-        this.We && (this.We = []);
-        this.Qe && (this.Qe = []);
-      }
-      if (this.xe && !this.me[0]) {
-        this.me[0] = runWithOwner((this.Ue[0] = createOwner()), this.xe);
-      }
-    } else if (this.we === 0) {
-      if (this.Ue[0]) this.Ue[0].dispose();
-      this.me = new Array(t);
+      if (this.Ge !== 0) {
+        this.xe.dispose(false);
+        this.je = [];
+        this.Fe = [];
+        this.He = [];
+        this.Ge = 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) {
+      if (this.je[0]) this.je[0].dispose();
+      this.He = new Array(t);
       for (i = 0; i < t; i++) {
-        this.ve[i] = e[i];
-        this.me[i] = runWithOwner((this.Ue[i] = createOwner()), r);
+        this.Fe[i] = e[i];
+        this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
       }
-      this.we = t;
+      this.Ge = t;
     } else {
       let o,
         s,
         u,
-        l,
         c,
+        l,
         a,
         f,
         E = new Array(t),
         T = new Array(t),
-        R = this.We ? new Array(t) : undefined,
-        d = this.Qe ? new Array(t) : undefined;
+        d = this.Ye ? new Array(t) : undefined,
+        R = this.Be ? new Array(t) : undefined;
       for (
-        o = 0, s = Math.min(this.we, t);
-        o < s && (this.ve[o] === e[o] || (this.We && compare(this.ke, this.ve[o], e[o])));
+        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++
       ) {
-        if (this.We) setSignal(this.We[o], e[o]);
+        if (this.Ye) setSignal(this.Ye[o], e[o]);
       }
       for (
-        s = this.we - 1, u = t - 1;
+        s = this.Ge - 1, u = t - 1;
         s >= o &&
         u >= o &&
-        (this.ve[s] === e[u] || (this.We && compare(this.ke, this.ve[s], e[u])));
+        (this.Fe[s] === e[u] || (this.Ye && compare(this.Ke, this.Fe[s], e[u])));
         s--, u--
       ) {
-        E[u] = this.me[s];
-        T[u] = this.Ue[s];
-        R && (R[u] = this.We[s]);
-        d && (d[u] = this.Qe[s]);
+        E[u] = this.He[s];
+        T[u] = this.je[s];
+        d && (d[u] = this.Ye[s]);
+        R && (R[u] = this.Be[s]);
       }
       a = new Map();
       f = new Array(u + 1);
       for (i = u; i >= o; i--) {
-        l = e[i];
-        c = this.ke ? this.ke(l) : l;
-        n = a.get(c);
+        c = e[i];
+        l = this.Ke ? this.Ke(c) : c;
+        n = a.get(l);
         f[i] = n === undefined ? -1 : n;
-        a.set(c, i);
+        a.set(l, i);
       }
       for (n = o; n <= s; n++) {
-        l = this.ve[n];
-        c = this.ke ? this.ke(l) : l;
-        i = a.get(c);
+        c = this.Fe[n];
+        l = this.Ke ? this.Ke(c) : c;
+        i = a.get(l);
         if (i !== undefined && i !== -1) {
-          E[i] = this.me[n];
-          T[i] = this.Ue[n];
-          R && (R[i] = this.We[n]);
-          d && (d[i] = this.Qe[n]);
+          E[i] = this.He[n];
+          T[i] = this.je[n];
+          d && (d[i] = this.Ye[n]);
+          R && (R[i] = this.Be[n]);
           i = f[i];
-          a.set(c, i);
-        } else this.Ue[n].dispose();
+          a.set(l, i);
+        } else this.je[n].dispose();
       }
       for (i = o; i < t; i++) {
         if (i in E) {
-          this.me[i] = E[i];
-          this.Ue[i] = T[i];
-          if (R) {
-            this.We[i] = R[i];
-            setSignal(this.We[i], e[i]);
-          }
+          this.He[i] = E[i];
+          this.je[i] = T[i];
           if (d) {
-            this.Qe[i] = d[i];
-            setSignal(this.Qe[i], i);
+            this.Ye[i] = d[i];
+            setSignal(this.Ye[i], e[i]);
+          }
+          if (R) {
+            this.Be[i] = R[i];
+            setSignal(this.Be[i], i);
           }
         } else {
-          this.me[i] = runWithOwner((this.Ue[i] = createOwner()), r);
+          this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
         }
       }
-      this.me = this.me.slice(0, (this.we = t));
-      this.ve = e.slice(0);
+      this.He = this.He.slice(0, (this.Ge = t));
+      this.Fe = e.slice(0);
     }
   });
-  return this.me;
+  return this.He;
 }
 function repeat(e, t, n) {
   return updateRepeat.bind({
-    De: createOwner(),
-    we: 0,
+    xe: createOwner(),
     Ge: 0,
-    Me: e,
-    Ve: t,
-    Ue: [],
-    me: [],
-    $e: n?.from,
-    xe: n?.fallback
+    qe: 0,
+    ze: e,
+    $e: t,
+    je: [],
+    He: [],
+    Ze: n?.from,
+    Xe: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.Me();
-  const t = this.$e?.() || 0;
-  runWithOwner(this.De, () => {
+  const e = this.ze();
+  const t = this.Ze?.() || 0;
+  runWithOwner(this.xe, () => {
     if (e === 0) {
-      if (this.we !== 0) {
-        this.De.dispose(false);
-        this.Ue = [];
-        this.me = [];
-        this.we = 0;
+      if (this.Ge !== 0) {
+        this.xe.dispose(false);
+        this.je = [];
+        this.He = [];
+        this.Ge = 0;
       }
-      if (this.xe && !this.me[0]) {
-        this.me[0] = runWithOwner((this.Ue[0] = createOwner()), this.xe);
+      if (this.Xe && !this.He[0]) {
+        this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
       }
       return;
     }
     const n = t + e;
-    const i = this.Ge + this.we;
-    if (this.we === 0 && this.Ue[0]) this.Ue[0].dispose();
-    for (let e = n; e < i; e++) this.Ue[e - this.Ge].dispose();
-    if (this.Ge < t) {
-      let e = this.Ge;
-      while (e < t && e < this.we) this.Ue[e++].dispose();
-      this.Ue.splice(0, t - this.Ge);
-      this.me.splice(0, t - this.Ge);
-    } else if (this.Ge > t) {
-      let n = i - this.Ge - 1;
-      let r = this.Ge - t;
-      this.Ue.length = this.me.length = e;
+    const i = this.qe + this.Ge;
+    if (this.Ge === 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();
+      this.je.splice(0, t - this.qe);
+      this.He.splice(0, t - this.qe);
+    } else if (this.qe > t) {
+      let n = i - this.qe - 1;
+      let r = this.qe - t;
+      this.je.length = this.He.length = e;
       while (n >= r) {
-        this.Ue[n] = this.Ue[n - r];
-        this.me[n] = this.me[n - r];
+        this.je[n] = this.je[n - r];
+        this.He[n] = this.He[n - r];
         n--;
       }
       for (let e = 0; e < r; e++) {
-        this.me[e] = runWithOwner((this.Ue[e] = createOwner()), () => this.Ve(e + t));
+        this.He[e] = runWithOwner((this.je[e] = createOwner()), () => this.$e(e + t));
       }
     }
     for (let e = i; e < n; e++) {
-      this.me[e - t] = runWithOwner((this.Ue[e - t] = createOwner()), () => this.Ve(e));
+      this.He[e - t] = runWithOwner((this.je[e - t] = createOwner()), () => this.$e(e));
     }
-    this.me = this.me.slice(0, e);
-    this.Ge = t;
-    this.we = e;
+    this.He = this.He.slice(0, e);
+    this.qe = t;
+    this.Ge = e;
   });
-  return this.me;
+  return this.He;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, { lazy: true });
-  n.Te = () => {
-    const e = n.ie;
-    n.ie &= ~n.Le;
-    n.J.notify(n, n.Le, e);
+  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.Le = t;
-  n.Se = true;
+  n.Je = t;
+  n.ve = true;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.J;
-  r.addChild((e.J = n));
-  onCleanup(() => r.removeChild(e.J));
+  const r = e.Te;
+  r.addChild((e.Te = n));
+  onCleanup(() => r.removeChild(e.Te));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
   });
 }
 class ConditionalQueue extends Queue {
-  He;
-  Fe = new Set();
-  L = new Set();
+  et;
+  tt = new Set();
+  J = new Set();
   constructor(e) {
     super();
-    this.He = e;
+    this.et = e;
   }
   run(e) {
-    if (!e || read(this.He)) return;
+    if (!e || read(this.et)) return;
     return super.run(e);
   }
-  notify(e, t, n) {
-    if (read(this.He)) {
+  notify(e, t, n, i) {
+    if (read(this.et)) {
       if (t & STATUS_PENDING) {
         if (n & STATUS_PENDING) {
-          this.L.add(e);
+          this.J.add(e);
           t &= ~STATUS_PENDING;
-        } else if (this.L.delete(e)) t &= ~STATUS_PENDING;
+        } else if (this.J.delete(e)) t &= ~STATUS_PENDING;
       }
       if (t & STATUS_ERROR) {
         if (n & STATUS_ERROR) {
-          this.Fe.add(e);
+          this.tt.add(e);
           t &= ~STATUS_ERROR;
-        } else if (this.Fe.delete(e)) t &= ~STATUS_ERROR;
+        } else if (this.tt.delete(e)) t &= ~STATUS_ERROR;
       }
     }
-    return t ? super.notify(e, t, n) : true;
+    return t ? super.notify(e, t, n, i ?? e.se) : true;
   }
 }
 class CollectionQueue extends Queue {
-  je;
-  Ue = new Set();
-  He = signal(false, { pureWrite: true });
-  Ke = false;
+  nt;
+  it = new Set();
+  et = signal(false, { pureWrite: true });
+  rt = false;
   constructor(e) {
     super();
-    this.je = e;
+    this.nt = e;
   }
   run(e) {
-    if (!e || read(this.He)) return;
+    if (!e || read(this.et)) return;
     return super.run(e);
   }
-  notify(e, t, n) {
-    if (!(t & this.je) || (this.je & STATUS_PENDING && this.Ke)) return super.notify(e, t, n);
-    if (n & this.je) {
-      this.Ue.add(e);
-      if (this.Ue.size === 1) setSignal(this.He, true);
-    } else if (this.Ue.size > 0) {
-      this.Ue.delete(e);
-      if (this.Ue.size === 0) setSignal(this.He, false);
+  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) {
+        const e = this.it.size === 0;
+        this.it.add(t);
+        if (e) setSignal(this.et, true);
+      }
+    }
+    t &= ~this.nt;
+    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);
     }
-    t &= ~this.je;
-    return t ? super.notify(e, t, n) : true;
+    if (!this.it.size) setSignal(this.et, false);
   }
 }
 var BoundaryMode;
@@ -2399,26 +2646,26 @@ function createBoundary(e, t) {
   const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
   const r = createBoundChildren(n, e, i, 0);
   computed(() => {
-    const e = read(i.He);
-    r.Le = e ? STATUS_ERROR | STATUS_PENDING : 0;
+    const e = read(i.et);
+    r.Je = e ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!e) {
-      i.L.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
-      i.Fe.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
-      i.L.clear();
-      i.Fe.clear();
+      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();
     }
   });
-  return () => (read(i.He) ? undefined : read(r));
+  return () => (read(i.et) ? undefined : read(r));
 }
 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.He)) {
+    if (!read(r.et)) {
       const e = read(o);
-      if (!untrack(() => read(r.He))) {
-        r.Ke = true;
+      if (!untrack(() => read(r.et))) {
+        r.rt = true;
         return e;
       }
     }
@@ -2429,26 +2676,12 @@ function createCollectionBoundary(e, t, n) {
 function createLoadBoundary(e, t) {
   return createCollectionBoundary(STATUS_PENDING, e, () => t());
 }
-function collectErrorSources(e, t) {
-  let n = true;
-  let i = e.C;
-  while (i !== null) {
-    const e = i.V;
-    if (e.C && e.ie & STATUS_ERROR) {
-      n = false;
-      collectErrorSources(e, t);
-    }
-    i = i.D;
-  }
-  n && t.push(e);
-}
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.Ue.values().next().value;
-    return t(n.B, () => {
-      const t = [];
-      for (const n of e.Ue) collectErrorSources(n, t);
-      for (const e of t) recompute(e);
+    let n = e.it.values().next().value;
+    const i = n.se?.cause ?? n.se;
+    return t(i, () => {
+      for (const t of e.it) recompute(t);
       schedule();
     });
   });