@solidjs/signals 0.13.3 → 0.13.5

package/dist/prod.js

@@ -148,38 +148,115 @@ let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
+let stashedOptimisticReads = null;
 function enforceLoadingBoundary(e) {}
+function shouldReadStashedOptimisticValue(e) {
+  return !!stashedOptimisticReads?.has(e);
+}
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.k || t.U.size > 0) continue;
-    const n = t.W[e - 1];
+    if (t.U || t.k.size > 0) continue;
+    const n = t.G[e - 1];
     if (n.length) {
-      t.W[e - 1] = [];
+      t.G[e - 1] = [];
       runQueue(n, e);
     }
   }
 }
+function queueStashedOptimisticEffects(e) {
+  for (let t = e.I; t !== null; t = t.p) {
+    const e = t.h;
+    if (!e.W) continue;
+    if (e.W === EFFECT_TRACKED) {
+      if (!e.H) {
+        e.H = true;
+        e.F.enqueue(EFFECT_USER, e.M);
+      }
+      continue;
+    }
+    const n = e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (n.P > e.o) n.P = e.o;
+    insertIntoHeap(e, n);
+  }
+}
 function setProjectionWriteActive(e) {
   projectionWriteActive = e;
 }
+function mergeTransitionState(e, t) {
+  t.$ = e;
+  e.j.push(...t.j);
+  for (const n of activeLanes) {
+    if (n.K === t) n.K = e;
+  }
+  e.Y.push(...t.Y);
+  for (const n of t.B) e.B.add(n);
+  for (const n of t.Z) {
+    if (!e.Z.includes(n)) e.Z.push(n);
+  }
+}
+function resolveOptimisticNodes(e) {
+  for (let t = 0; t < e.length; t++) {
+    const n = e[t];
+    n.q = undefined;
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+    }
+    const i = n.ee;
+    n.ee = NOT_PENDING;
+    if (i !== NOT_PENDING && n.J !== i) insertSubs(n, true);
+    n.K = null;
+  }
+  e.length = 0;
+}
+function cleanupCompletedLanes(e) {
+  for (const t of activeLanes) {
+    const n = e ? t.K === e : !t.K;
+    if (!n) continue;
+    if (!t.U) {
+      if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
+      if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
+    }
+    if (t.te.q === t) t.te.q = undefined;
+    t.k.clear();
+    t.G[0].length = 0;
+    t.G[1].length = 0;
+    activeLanes.delete(t);
+    signalLanes.delete(t.te);
+  }
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.H && !projectionWriteActive) queueMicrotask(flush);
+  if (!globalQueue.ne && !projectionWriteActive) queueMicrotask(flush);
+}
+function addTransitionBlocker(e) {
+  if (activeTransition && !activeTransition.Z.includes(e)) {
+    activeTransition.Z.push(e);
+  }
+}
+function removeTransitionBlocker(e) {
+  const remove = t => {
+    if (!t) return;
+    const n = t.indexOf(e);
+    if (n >= 0) t.splice(n, 1);
+  };
+  remove(e.K?.Z);
+  remove(activeTransition?.Z);
 }
 class Queue {
   i = null;
-  G = [[], []];
-  F = [];
+  ie = [[], []];
+  re = [];
   created = clock;
   addChild(e) {
-    this.F.push(e);
+    this.re.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.F.indexOf(e);
+    const t = this.re.indexOf(e);
     if (t >= 0) {
-      this.F.splice(t, 1);
+      this.re.splice(t, 1);
       e.i = null;
     }
   }
@@ -188,88 +265,101 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.G[e - 1].length) {
-      const t = this.G[e - 1];
-      this.G[e - 1] = [];
+    if (this.ie[e - 1].length) {
+      const t = this.ie[e - 1];
+      this.ie[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.F.length; t++) this.F[t].run?.(e);
+    for (let t = 0; t < this.re.length; t++) this.re[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.W[e - 1].push(t);
+        n.G[e - 1].push(t);
       } else {
-        this.G[e - 1].push(t);
+        this.ie[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.G[0].push(...this.G[0]);
-    e.G[1].push(...this.G[1]);
-    this.G = [[], []];
-    for (let t = 0; t < this.F.length; t++) {
-      let n = this.F[t];
-      let i = e.F[t];
+    e.ie[0].push(...this.ie[0]);
+    e.ie[1].push(...this.ie[1]);
+    this.ie = [[], []];
+    for (let t = 0; t < this.re.length; t++) {
+      let n = this.re[t];
+      let i = e.re[t];
       if (!i) {
-        i = { G: [[], []], F: [] };
-        e.F[t] = i;
+        i = { ie: [[], []], re: [] };
+        e.re[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.G[0].push(...e.G[0]);
-    this.G[1].push(...e.G[1]);
-    for (let t = 0; t < e.F.length; t++) {
-      const n = e.F[t];
-      let i = this.F[t];
+    this.ie[0].push(...e.ie[0]);
+    this.ie[1].push(...e.ie[1]);
+    for (let t = 0; t < e.re.length; t++) {
+      const n = e.re[t];
+      let i = this.re[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  H = false;
-  M = [];
-  $ = [];
-  j = new Set();
-  static K;
-  static Y;
-  static B = null;
+  ne = false;
+  oe = [];
+  Y = [];
+  B = new Set();
+  static se;
+  static ue;
+  static ce = null;
   flush() {
-    if (this.H) return;
-    this.H = true;
+    if (this.ne) return;
+    this.ne = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.K);
+      runHeap(dirtyQueue, GlobalQueue.se);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
-          let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.K);
-          this.M = [];
-          this.$ = [];
-          this.j = new Set();
+          const e = activeTransition;
+          runHeap(zombieQueue, GlobalQueue.se);
+          this.oe = [];
+          this.Y = [];
+          this.B = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition.Z);
+          this.stashQueues(e.ae);
           clock++;
           scheduled = dirtyQueue.R >= dirtyQueue.P;
-          reassignPendingTransition(activeTransition.M);
+          reassignPendingTransition(e.oe);
           activeTransition = null;
-          finalizePureQueue(null, true);
+          if (!e.j.length && e.Y.length) {
+            stashedOptimisticReads = new Set();
+            for (let t = 0; t < e.Y.length; t++) {
+              const n = e.Y[t];
+              if (n.L || n.fe) continue;
+              stashedOptimisticReads.add(n);
+              queueStashedOptimisticEffects(n);
+            }
+          }
+          try {
+            finalizePureQueue(null, true);
+          } finally {
+            stashedOptimisticReads = null;
+          }
           return;
         }
-        this.M !== activeTransition.M && this.M.push(...activeTransition.M);
-        this.restoreQueues(activeTransition.Z);
+        this.oe !== activeTransition.oe && this.oe.push(...activeTransition.oe);
+        this.restoreQueues(activeTransition.ae);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.M);
+        reassignPendingTransition(this.oe);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.K);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.se);
         finalizePureQueue();
       }
       clock++;
@@ -279,16 +369,19 @@ class GlobalQueue extends Queue {
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.H = false;
+      this.ne = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.q;
-        if (activeTransition && t && !activeTransition.X.includes(t.source)) {
-          activeTransition.X.push(t.source);
-          schedule();
+        const t = i !== undefined ? i : e.le;
+        if (activeTransition && t) {
+          const e = t.source;
+          if (!activeTransition.Z.includes(e)) {
+            activeTransition.Z.push(e);
+            schedule();
+          }
         }
       }
       return true;
@@ -298,58 +391,56 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.J === clock) return;
+    if (!e && activeTransition && activeTransition.Ee === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        J: clock,
-        M: [],
-        X: [],
-        $: [],
-        j: new Set(),
-        ee: [],
-        Z: { G: [[], []], F: [] },
-        te: false
+        Ee: clock,
+        oe: [],
+        Z: [],
+        Y: [],
+        B: new Set(),
+        j: [],
+        ae: { ie: [[], []], re: [] },
+        $: false
       };
     } else if (e) {
       const t = activeTransition;
-      t.te = e;
-      e.ee.push(...t.ee);
-      for (const n of activeLanes) {
-        if (n.ne === t) n.ne = e;
-      }
-      e.$.push(...t.$);
-      for (const n of t.j) {
-        e.j.add(n);
-      }
+      mergeTransitionState(e, t);
       transitions.delete(t);
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.J = clock;
-    for (let e = 0; e < this.M.length; e++) {
-      const t = this.M[e];
-      t.ne = activeTransition;
-      activeTransition.M.push(t);
-    }
-    this.M = activeTransition.M;
-    for (let e = 0; e < this.$.length; e++) {
-      const t = this.$[e];
-      t.ne = activeTransition;
-      activeTransition.$.push(t);
-    }
-    this.$ = activeTransition.$;
+    activeTransition.Ee = clock;
+    if (this.oe !== activeTransition.oe) {
+      for (let e = 0; e < this.oe.length; e++) {
+        const t = this.oe[e];
+        t.K = activeTransition;
+        activeTransition.oe.push(t);
+      }
+      this.oe = activeTransition.oe;
+    }
+    if (this.Y !== activeTransition.Y) {
+      for (let e = 0; e < this.Y.length; e++) {
+        const t = this.Y[e];
+        t.K = activeTransition;
+        activeTransition.Y.push(t);
+      }
+      this.Y = activeTransition.Y;
+    }
     for (const e of activeLanes) {
-      if (!e.ne) e.ne = activeTransition;
+      if (!e.K) e.K = activeTransition;
+    }
+    if (this.B !== activeTransition.B) {
+      for (const e of this.B) activeTransition.B.add(e);
+      this.B = activeTransition.B;
     }
-    for (const e of this.j) activeTransition.j.add(e);
-    this.j = activeTransition.j;
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.ie || currentOptimisticLane;
-  const i = e.re !== undefined;
+  const n = e.q || currentOptimisticLane;
+  const i = e.Te !== undefined;
   for (let r = e.I; r !== null; r = r.p) {
-    if (i && r.h.oe) {
+    if (i && r.h.de) {
       r.h.O |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
@@ -358,13 +449,13 @@ function insertSubs(e, t = false) {
       assignOrMergeLane(r.h, n);
     } else if (t) {
       r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      r.h.ie = undefined;
+      r.h.q = undefined;
     }
     const e = r.h;
-    if (e.se === EFFECT_TRACKED) {
-      if (!e.ue) {
-        e.ue = true;
-        e.ce.enqueue(EFFECT_USER, e.ae);
+    if (e.W === EFFECT_TRACKED) {
+      if (!e.H) {
+        e.H = true;
+        e.F.enqueue(EFFECT_USER, e.M);
       }
       continue;
     }
@@ -374,88 +465,56 @@ function insertSubs(e, t = false) {
   }
 }
 function commitPendingNodes() {
-  const e = globalQueue.M;
+  const e = globalQueue.oe;
   for (let t = 0; t < e.length; t++) {
     const n = e[t];
-    if (n.le !== NOT_PENDING) {
-      n.fe = n.le;
-      n.le = NOT_PENDING;
-      if (n.se && n.se !== EFFECT_TRACKED) n.ue = true;
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+      if (n.W && n.W !== EFFECT_TRACKED) n.H = true;
     }
-    if (n.Ee & STATUS_PENDING) {
-      const e = n.q?.source;
-      if (e && !(e.Ee & STATUS_PENDING)) {
-        n.Ee &= -6;
-        n.q = null;
-      }
-    } else n.Ee &= ~STATUS_UNINITIALIZED;
-    if (n.L) GlobalQueue.Y(n, false, true);
+    if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
+    if (n.L) GlobalQueue.ue(n, false, true);
   }
   e.length = 0;
 }
 function finalizePureQueue(e = null, t = false) {
-  let n = !t;
+  const n = !t;
   if (n) commitPendingNodes();
   if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.K);
+  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.se);
   if (n) {
     commitPendingNodes();
-    const t = e ? e.$ : globalQueue.$;
-    for (let e = 0; e < t.length; e++) {
-      const n = t[e];
-      n.ie = undefined;
-      if (n.le !== NOT_PENDING) {
-        n.fe = n.le;
-        n.le = NOT_PENDING;
-      }
-      const i = n.Te;
-      n.Te = NOT_PENDING;
-      if (i !== NOT_PENDING && n.fe !== i) insertSubs(n, true);
-      n.ne = null;
-    }
-    t.length = 0;
-    const n = e ? e.j : globalQueue.j;
-    if (GlobalQueue.B && n.size) {
-      for (const e of n) {
-        GlobalQueue.B(e);
-      }
-      n.clear();
-      schedule();
-    }
-    for (const t of activeLanes) {
-      const n = e ? t.ne === e : !t.ne;
-      if (!n) continue;
-      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);
+    resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
+    const t = e ? e.B : globalQueue.B;
+    if (GlobalQueue.ce && t.size) {
+      for (const e of t) {
+        GlobalQueue.ce(e);
       }
-      if (t.de.ie === t) t.de.ie = undefined;
-      t.U.clear();
-      t.W[0].length = 0;
-      t.W[1].length = 0;
-      activeLanes.delete(t);
-      signalLanes.delete(t.de);
+      t.clear();
+      schedule();
     }
+    cleanupCompletedLanes(e);
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.F) {
+  for (const t of e.re) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.j.add(e);
+  globalQueue.B.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].ne = activeTransition;
+    e[t].K = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
 function flush() {
-  while (scheduled) {
+  while (scheduled || activeTransition) {
     globalQueue.flush();
   }
 }
@@ -463,21 +522,21 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.te) return true;
-  if (e.ee.length) return false;
+  if (e.$) return true;
+  if (e.j.length) return false;
   let t = true;
-  for (let n = 0; n < e.X.length; n++) {
-    const i = e.X[n];
-    if (i.Ee & STATUS_PENDING && i.q?.source === i) {
+  for (let n = 0; n < e.Z.length; n++) {
+    const i = e.Z[n];
+    if (i.Se & STATUS_PENDING && i.le?.source === i) {
       t = false;
       break;
     }
   }
-  t && (e.te = true);
+  t && (e.$ = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.te && typeof e.te === "object") e = e.te;
+  while (e.$ && typeof e.$ === "object") e = e.$;
   return e;
 }
 function setActiveTransition(e) {
@@ -499,105 +558,199 @@ function getOrCreateLane(e) {
   if (t) {
     return findLane(t);
   }
-  const n = e.Se;
-  const i = n?.ie ? findLane(n.ie) : null;
-  t = { de: e, U: new Set(), W: [[], []], k: null, ne: activeTransition, Re: i };
+  const n = e.Re;
+  const i = n?.q ? findLane(n.q) : null;
+  t = { te: e, k: new Set(), G: [[], []], U: null, K: activeTransition, Oe: i };
   signalLanes.set(e, t);
   activeLanes.add(t);
-  e.Oe = false;
+  e._e = false;
   return t;
 }
 function findLane(e) {
-  while (e.k) e = e.k;
+  while (e.U) e = e.U;
   return e;
 }
 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]);
+  t.U = e;
+  for (const n of t.k) e.k.add(n);
+  e.G[0].push(...t.G[0]);
+  e.G[1].push(...t.G[1]);
   return e;
 }
 function resolveLane(e) {
-  const t = e.ie;
+  const t = e.q;
   if (!t) return undefined;
   const n = findLane(t);
   if (activeLanes.has(n)) return n;
-  e.ie = undefined;
+  e.q = undefined;
   return undefined;
 }
+function resolveTransition(e) {
+  return resolveLane(e)?.K ?? e.K;
+}
 function hasActiveOverride(e) {
-  return !!(e.Te !== undefined && e.Te !== NOT_PENDING);
+  return !!(e.ee !== undefined && e.ee !== NOT_PENDING);
 }
 function assignOrMergeLane(e, t) {
   const n = findLane(t);
-  const i = e.ie;
+  const i = e.q;
   if (i) {
-    if (i.k) {
-      e.ie = t;
+    if (i.U) {
+      e.q = t;
       return;
     }
     const r = findLane(i);
     if (activeLanes.has(r)) {
       if (r !== n && !hasActiveOverride(e)) {
-        if (n.Re && findLane(n.Re) === r) {
-          e.ie = t;
-        } else if (r.Re && findLane(r.Re) === n);
+        if (n.Oe && findLane(n.Oe) === r) {
+          e.q = t;
+        } else if (r.Oe && findLane(r.Oe) === n);
         else mergeLanes(n, r);
       }
       return;
     }
   }
-  e.ie = t;
+  e.q = t;
+}
+function addPendingSource(e, t) {
+  if (e.Ie === t || e.pe?.has(t)) return false;
+  if (!e.Ie) {
+    e.Ie = t;
+    return true;
+  }
+  if (!e.pe) {
+    e.pe = new Set([e.Ie, t]);
+  } else {
+    e.pe.add(t);
+  }
+  e.Ie = undefined;
+  return true;
+}
+function removePendingSource(e, t) {
+  if (e.Ie) {
+    if (e.Ie !== t) return false;
+    e.Ie = undefined;
+    return true;
+  }
+  if (!e.pe?.delete(t)) return false;
+  if (e.pe.size === 1) {
+    e.Ie = e.pe.values().next().value;
+    e.pe = undefined;
+  } else if (e.pe.size === 0) {
+    e.pe = undefined;
+  }
+  return true;
+}
+function clearPendingSources(e) {
+  e.Ie = undefined;
+  e.pe?.clear();
+  e.pe = undefined;
+}
+function setPendingError(e, t, n) {
+  if (!t) {
+    e.le = null;
+    return;
+  }
+  if (n instanceof NotReadyError && n.source === t) {
+    e.le = n;
+    return;
+  }
+  const i = e.le;
+  if (!(i instanceof NotReadyError) || i.source !== t) {
+    e.le = new NotReadyError(t);
+  }
+}
+function forEachDependent(e, t) {
+  for (let n = e.I; n !== null; n = n.p) t(n.h);
+  for (let n = e.A; n !== null; n = n.N) {
+    for (let e = n.I; e !== null; e = e.p) t(e.h);
+  }
+}
+function settlePendingSource(e) {
+  let t = false;
+  const n = new Set();
+  const settle = i => {
+    if (n.has(i) || !removePendingSource(i, e)) return;
+    n.add(i);
+    i.Ee = clock;
+    const r = i.Ie ?? i.pe?.values().next().value;
+    if (r) {
+      setPendingError(i, r);
+      updatePendingSignal(i);
+    } else {
+      i.Se &= ~STATUS_PENDING;
+      setPendingError(i);
+      updatePendingSignal(i);
+      if (i.he) {
+        if (i.W === EFFECT_TRACKED) {
+          const e = i;
+          if (!e.H) {
+            e.H = true;
+            e.F.enqueue(EFFECT_USER, e.M);
+          }
+        } else {
+          const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (e.P > i.o) e.P = i.o;
+          insertIntoHeap(i, e);
+        }
+        t = true;
+      }
+      i.he = false;
+    }
+    forEachDependent(i, settle);
+  };
+  forEachDependent(e, settle);
+  if (t) schedule();
 }
 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._e = null;
+    e.Ae = null;
     return t;
   }
-  e._e = t;
+  e.Ae = t;
   let s;
   const handleError = n => {
-    if (e._e !== t) return;
-    globalQueue.initTransition(e.ne);
+    if (e.Ae !== t) return;
+    globalQueue.initTransition(resolveTransition(e));
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.J = clock;
+    e.Ee = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e._e !== t) return;
+    if (e.Ae !== t) return;
     if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(e.ne);
+    globalQueue.initTransition(resolveTransition(e));
     clearStatus(e);
     const o = resolveLane(e);
-    if (o) o.U.delete(e);
+    if (o) o.k.delete(e);
     if (n) n(i);
-    else if (e.Te !== undefined) {
-      if (e.Te !== undefined && e.Te !== NOT_PENDING) e.le = i;
+    else if (e.ee !== undefined) {
+      if (e.ee !== undefined && e.ee !== NOT_PENDING) e.X = i;
       else {
-        e.fe = i;
+        e.J = i;
         insertSubs(e);
       }
-      e.J = clock;
+      e.Ee = clock;
     } else if (o) {
-      const t = e.fe;
-      const n = e.Ie;
+      const t = e.J;
+      const n = e.Ne;
       if (!n || !n(i, t)) {
-        e.fe = i;
-        e.J = clock;
-        if (e.pe) {
-          setSignal(e.pe, i);
+        e.J = i;
+        e.Ee = clock;
+        if (e.Pe) {
+          setSignal(e.Pe, i);
         }
         insertSubs(e, true);
       }
     } else {
       setSignal(e, () => i);
     }
+    settlePendingSource(e);
     schedule();
     flush();
     r?.();
@@ -618,7 +771,7 @@ function handleAsync(e, t, n) {
     );
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.ne);
+      globalQueue.initTransition(resolveTransition(e));
       throw new NotReadyError(context);
     }
   }
@@ -654,126 +807,92 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.ne);
+      globalQueue.initTransition(resolveTransition(e));
       throw new NotReadyError(context);
     }
   }
   return s;
 }
-function clearStatus(e) {
-  e.Ee = e.Ee & STATUS_UNINITIALIZED;
-  e.q = null;
+function clearStatus(e, t = false) {
+  clearPendingSources(e);
+  removeTransitionBlocker(e);
+  e.he = false;
+  e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
+  setPendingError(e);
   updatePendingSignal(e);
-  e.he?.();
+  e.ge?.();
 }
 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.source === e;
-  const s = t === STATUS_PENDING && e.Te !== undefined && !o;
-  const u = s && hasActiveOverride(e);
+  const o = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
+  const s = o === e;
+  const u = t === STATUS_PENDING && e.ee !== undefined && !s;
+  const c = u && hasActiveOverride(e);
   if (!i) {
-    e.Ee = t | (t !== STATUS_ERROR ? e.Ee & STATUS_UNINITIALIZED : 0);
-    e.q = n;
+    if (t === STATUS_PENDING && o) {
+      addPendingSource(e, o);
+      e.Se = STATUS_PENDING | (e.Se & STATUS_UNINITIALIZED);
+      setPendingError(e, e.Ie ?? e.pe?.values().next().value, n);
+      if (o === e) addTransitionBlocker(e);
+    } else {
+      clearPendingSources(e);
+      removeTransitionBlocker(e);
+      e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
+      e.le = n;
+    }
     updatePendingSignal(e);
   }
   if (r && !i) {
     assignOrMergeLane(e, r);
   }
-  if (u && activeTransition && n instanceof NotReadyError) {
-    const e = n.source;
-    if (!activeTransition.X.includes(e)) {
-      activeTransition.X.push(e);
-    }
-  }
-  const c = i || u;
-  const a = i || s ? undefined : r;
-  if (e.he) {
-    if (c) {
-      e.he(t, n);
+  const a = i || c;
+  const f = i || u ? undefined : r;
+  if (e.ge) {
+    if (a) {
+      e.ge(t, n);
     } else {
-      e.he();
+      e.ge();
     }
     return;
   }
-  for (let i = e.I; i !== null; i = i.p) {
-    i.h.J = clock;
-    if (i.h.q !== n) {
-      !i.h.ne && globalQueue.M.push(i.h);
-      notifyStatus(i.h, t, n, c, a);
-    }
-  }
-  for (let i = e.A; i !== null; i = i.N) {
-    for (let e = i.I; e !== null; e = e.p) {
-      e.h.J = clock;
-      if (e.h.q !== n) {
-        !e.h.ne && globalQueue.M.push(e.h);
-        notifyStatus(e.h, t, n, c, a);
-      }
-    }
-  }
-}
-function unlinkSubs(e) {
-  const t = e.m;
-  const n = e.D;
-  const i = e.p;
-  const r = e.Ae;
-  if (i !== null) i.Ae = r;
-  else t.Ne = r;
-  if (r !== null) r.p = i;
-  else {
-    t.I = i;
-    if (i === null) {
-      t.ge?.();
-      t.L && !t.Pe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
-    }
-  }
-  return n;
-}
-function unobserved(e) {
-  deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let t = e.C;
-  while (t !== null) {
-    t = unlinkSubs(t);
-  }
-  e.C = null;
-  disposeChildren(e, true);
-}
-function link(e, t) {
-  const n = t.Ce;
-  if (n !== null && n.m === e) return;
-  let i = null;
-  const r = t.O & REACTIVE_RECOMPUTING_DEPS;
-  if (r) {
-    i = n !== null ? n.D : t.C;
-    if (i !== null && i.m === e) {
-      t.Ce = i;
-      return;
+  forEachDependent(e, e => {
+    e.Ee = clock;
+    if (
+      (t === STATUS_PENDING && o && e.Ie !== o && !e.pe?.has(o)) ||
+      (t !== STATUS_PENDING && (e.le !== n || e.Ie || e.pe))
+    ) {
+      !e.K && globalQueue.oe.push(e);
+      notifyStatus(e, t, n, a, f);
     }
-  }
-  const o = e.Ne;
-  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
-  const s = (t.Ce = e.Ne = { m: e, h: t, D: i, Ae: o, p: null });
-  if (n !== null) n.D = s;
-  else t.C = s;
-  if (o !== null) o.p = s;
-  else e.I = s;
+  });
 }
-function isValidLink(e, t) {
-  const n = t.Ce;
-  if (n !== null) {
-    let i = t.C;
-    do {
-      if (i === e) return true;
-      if (i === n) break;
-      i = i.D;
-    } while (i !== null);
+let externalSourceConfig = null;
+function enableExternalSource(e) {
+  const { factory: t, untrack: n = e => e() } = e;
+  if (externalSourceConfig) {
+    const { factory: e, untrack: i } = externalSourceConfig;
+    externalSourceConfig = {
+      factory: (n, i) => {
+        const r = e(n, i);
+        const o = t(e => r.track(e), i);
+        return {
+          track: e => o.track(e),
+          dispose() {
+            o.dispose();
+            r.dispose();
+          }
+        };
+      },
+      untrack: e => i(() => n(e))
+    };
+  } else {
+    externalSourceConfig = { factory: t, untrack: n };
   }
-  return false;
 }
 const PENDING_OWNER = {};
 function markDisposal(e) {
-  let t = e.De;
+  let t = e.Ce;
   while (t) {
     t.O |= REACTIVE_ZOMBIE;
     if (t.O & REACTIVE_IN_HEAP) {
@@ -781,7 +900,7 @@ function markDisposal(e) {
       insertIntoHeap(t, zombieQueue);
     }
     markDisposal(t);
-    t = t.ye;
+    t = t.De;
   }
 }
 function dispose(e) {
@@ -790,15 +909,15 @@ function dispose(e) {
     t = unlinkSubs(t);
   } while (t !== null);
   e.C = null;
-  e.Ce = null;
+  e.ye = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
   if (e.O & REACTIVE_DISPOSED) return;
   if (t) e.O = REACTIVE_DISPOSED;
-  let i = n ? e.ve : e.De;
+  let i = n ? e.me : e.Ce;
   while (i) {
-    const e = i.ye;
+    const e = i.De;
     if (i.C) {
       const e = i;
       deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
@@ -807,21 +926,21 @@ function disposeChildren(e, t = false, n) {
         t = unlinkSubs(t);
       } while (t !== null);
       e.C = null;
-      e.Ce = null;
+      e.ye = null;
     }
     disposeChildren(i, true);
     i = e;
   }
   if (n) {
-    e.ve = null;
+    e.me = null;
   } else {
-    e.De = null;
-    e.we = 0;
+    e.Ce = null;
+    e.ve = 0;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.be : e.me;
+  let n = t ? e.we : e.be;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -831,12 +950,12 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.be = null) : (e.me = null);
+  t ? (e.we = null) : (e.be = null);
 }
 function childId(e, t) {
   let n = e;
   while (n.Ve && n.i) n = n.i;
-  if (n.id != null) return formatId(n.id, t ? n.we++ : n.we);
+  if (n.id != null) return formatId(n.id, t ? n.ve++ : n.ve);
   throw new Error("Cannot get child id from owner without an id");
 }
 function getNextChildId(e) {
@@ -857,11 +976,11 @@ function getObserver() {
 function getOwner() {
   return context;
 }
-function onCleanup(e) {
+function cleanup(e) {
   if (!context) return e;
-  if (!context.me) context.me = e;
-  else if (Array.isArray(context.me)) context.me.push(e);
-  else context.me = [context.me, e];
+  if (!context.be) context.be = e;
+  else if (Array.isArray(context.be)) context.be.push(e);
+  else context.be = [context.be, e];
   return e;
 }
 function isDisposed(e) {
@@ -875,26 +994,26 @@ function createOwner(e) {
     Ve: n || undefined,
     t: true,
     u: t?.t ? t.u : t,
+    Ce: null,
     De: null,
-    ye: null,
-    me: null,
-    ce: t?.ce ?? globalQueue,
-    Le: t?.Le || defaultContext,
-    we: 0,
     be: null,
-    ve: null,
+    F: t?.F ?? globalQueue,
+    Le: t?.Le || defaultContext,
+    ve: 0,
+    we: null,
+    me: null,
     i: t,
     dispose(e = true) {
       disposeChildren(i, e);
     }
   };
   if (t) {
-    const e = t.De;
+    const e = t.Ce;
     if (e === null) {
-      t.De = i;
+      t.Ce = i;
     } else {
-      i.ye = e;
-      t.De = i;
+      i.De = e;
+      t.Ce = i;
     }
   }
   return i;
@@ -903,115 +1022,66 @@ function createRoot(e, t) {
   const n = createOwner(t);
   return runWithOwner(n, () => e(n.dispose));
 }
-function effect(e, t, n, i, r) {
-  let o = false;
-  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
-    ...r,
-    equals: () => {
-      s.ue = !s.q;
-      if (o) s.ce.enqueue(s.se, runEffect.bind(s));
-      return false;
-    },
-    lazy: true
-  });
-  s.ke = i;
-  s.Ue = t;
-  s.xe = n;
-  s.We = undefined;
-  s.se = r?.render ? EFFECT_RENDER : EFFECT_USER;
-  s.he = (e, t) => {
-    const n = e !== undefined ? e : s.Ee;
-    const i = t !== undefined ? t : s.q;
-    if (n & STATUS_ERROR) {
-      let e = i;
-      s.ce.notify(s, STATUS_PENDING, 0);
-      if (s.se === EFFECT_USER) {
-        try {
-          return s.xe
-            ? s.xe(e, () => {
-                s.We?.();
-                s.We = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
-        }
-      }
-      if (!s.ce.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (s.se === EFFECT_RENDER) {
-      s.ce.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
+function unlinkSubs(e) {
+  const t = e.m;
+  const n = e.D;
+  const i = e.p;
+  const r = e.Ue;
+  if (i !== null) i.Ue = r;
+  else t.ke = r;
+  if (r !== null) r.p = i;
+  else {
+    t.I = i;
+    if (i === null) {
+      t.Ge?.();
+      t.L && !t.xe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
     }
-  };
-  recompute(s, true);
-  !r?.defer && (s.se === EFFECT_USER ? s.ce.enqueue(s.se, runEffect.bind(s)) : runEffect.call(s));
-  o = true;
-  onCleanup(() => s.We?.());
+  }
+  return n;
 }
-function runEffect() {
-  if (!this.ue || this.O & REACTIVE_DISPOSED) return;
-  this.We?.();
-  this.We = undefined;
-  try {
-    this.We = this.Ue(this.fe, this.ke);
-  } catch (e) {
-    this.q = new StatusError(this, e);
-    this.Ee |= STATUS_ERROR;
-    if (!this.ce.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-  } finally {
-    this.ke = this.fe;
-    this.ue = false;
+function unobserved(e) {
+  deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.C;
+  while (t !== null) {
+    t = unlinkSubs(t);
   }
+  e.C = null;
+  disposeChildren(e, true);
 }
-function trackedEffect(e, t) {
-  const run = () => {
-    if (!n.ue || n.O & REACTIVE_DISPOSED) return;
-    n.ue = false;
-    recompute(n);
-  };
-  const n = computed(
-    () => {
-      try {
-        n.We?.();
-        n.We = undefined;
-        n.We = staleValues(e) || undefined;
-      } finally {
-      }
-    },
-    undefined,
-    { ...t, lazy: true }
-  );
-  n.We = undefined;
-  n.ue = true;
-  n.se = EFFECT_TRACKED;
-  n.ae = run;
-  n.ce.enqueue(EFFECT_USER, run);
-  onCleanup(() => n.We?.());
+function link(e, t) {
+  const n = t.ye;
+  if (n !== null && n.m === e) return;
+  let i = null;
+  const r = t.O & REACTIVE_RECOMPUTING_DEPS;
+  if (r) {
+    i = n !== null ? n.D : t.C;
+    if (i !== null && i.m === e) {
+      t.ye = i;
+      return;
+    }
+  }
+  const o = e.ke;
+  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
+  const s = (t.ye = e.ke = { m: e, h: t, D: i, Ue: o, p: null });
+  if (n !== null) n.D = s;
+  else t.C = s;
+  if (o !== null) o.p = s;
+  else e.I = s;
 }
-let externalSourceConfig = null;
-function enableExternalSource(e) {
-  const { factory: t, untrack: n = e => e() } = e;
-  if (externalSourceConfig) {
-    const { factory: e, untrack: i } = externalSourceConfig;
-    externalSourceConfig = {
-      factory: (n, i) => {
-        const r = e(n, i);
-        const o = t(e => r.track(e), i);
-        return {
-          track: e => o.track(e),
-          dispose() {
-            o.dispose();
-            r.dispose();
-          }
-        };
-      },
-      untrack: e => i(() => n(e))
-    };
-  } else {
-    externalSourceConfig = { factory: t, untrack: n };
+function isValidLink(e, t) {
+  const n = t.ye;
+  if (n !== null) {
+    let i = t.C;
+    do {
+      if (i === e) return true;
+      if (i === n) break;
+      i = i.D;
+    } while (i !== null);
   }
+  return false;
 }
-GlobalQueue.K = recompute;
-GlobalQueue.Y = disposeChildren;
+GlobalQueue.se = recompute;
+GlobalQueue.ue = disposeChildren;
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -1024,7 +1094,7 @@ let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(e) {
   while (e) {
-    if (e.He) return true;
+    if (e.We) return true;
     e = e.i;
   }
   return false;
@@ -1034,23 +1104,23 @@ function setSnapshotCapture(e) {
   if (e && !snapshotSources) snapshotSources = new Set();
 }
 function markSnapshotScope(e) {
-  e.He = true;
+  e.We = true;
 }
 function releaseSnapshotScope(e) {
-  e.He = false;
+  e.We = false;
   releaseSubtree(e);
   schedule();
 }
 function releaseSubtree(e) {
-  let t = e.De;
+  let t = e.Ce;
   while (t) {
-    if (t.He) {
-      t = t.ye;
+    if (t.We) {
+      t = t.De;
       continue;
     }
     if (t.L) {
       const e = t;
-      e.oe = false;
+      e.de = false;
       if (e.O & REACTIVE_SNAPSHOT_STALE) {
         e.O &= ~REACTIVE_SNAPSHOT_STALE;
         e.O |= REACTIVE_DIRTY;
@@ -1059,13 +1129,13 @@ function releaseSubtree(e) {
       }
     }
     releaseSubtree(t);
-    t = t.ye;
+    t = t.De;
   }
 }
 function clearSnapshots() {
   if (snapshotSources) {
     for (const e of snapshotSources) {
-      delete e.re;
+      delete e.Te;
       delete e[STORE_SNAPSHOT_PROPS];
     }
     snapshotSources = null;
@@ -1073,33 +1143,33 @@ function clearSnapshots() {
   snapshotCaptureActive = false;
 }
 function recompute(e, t = false) {
-  const n = e.se;
+  const n = e.W;
   if (!t) {
-    if (e.ne && (!n || activeTransition) && activeTransition !== e.ne)
-      globalQueue.initTransition(e.ne);
+    if (e.K && (!n || activeTransition) && activeTransition !== e.K)
+      globalQueue.initTransition(e.K);
     deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.ne || n === EFFECT_TRACKED) disposeChildren(e);
+    if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
     else {
       markDisposal(e);
-      e.be = e.me;
-      e.ve = e.De;
-      e.me = null;
-      e.De = null;
-      e.we = 0;
+      e.we = e.be;
+      e.me = e.Ce;
+      e.be = null;
+      e.Ce = null;
+      e.ve = 0;
     }
   }
   const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = e.Te !== undefined && e.Te !== NOT_PENDING;
-  const o = !!(e.Ee & STATUS_PENDING);
+  const r = e.ee !== undefined && e.ee !== NOT_PENDING;
+  const o = !!(e.Se & STATUS_PENDING);
   const s = context;
   context = e;
-  e.Ce = null;
+  e.ye = null;
   e.O = REACTIVE_RECOMPUTING_DEPS;
-  e.J = clock;
-  let u = e.le === NOT_PENDING ? e.fe : e.le;
+  e.Ee = clock;
+  let u = e.X === NOT_PENDING ? e.J : e.X;
   let c = e.o;
   let a = tracking;
-  let l = currentOptimisticLane;
+  let f = currentOptimisticLane;
   tracking = true;
   if (i) {
     const t = resolveLane(e);
@@ -1107,35 +1177,36 @@ function recompute(e, t = false) {
   }
   try {
     u = handleAsync(e, e.L(u));
-    clearStatus(e);
-    const t = resolveLane(e);
-    if (t) {
-      t.U.delete(e);
-      updatePendingSignal(t.de);
+    clearStatus(e, t);
+    const n = resolveLane(e);
+    if (n) {
+      n.k.delete(e);
+      updatePendingSignal(n.te);
     }
   } catch (t) {
     if (t instanceof NotReadyError && currentOptimisticLane) {
       const t = findLane(currentOptimisticLane);
-      if (t.de !== e) {
-        t.U.add(e);
-        e.ie = t;
-        updatePendingSignal(t.de);
+      if (t.te !== e) {
+        t.k.add(e);
+        e.q = t;
+        updatePendingSignal(t.te);
       }
     }
+    if (t instanceof NotReadyError) e.he = true;
     notifyStatus(
       e,
       t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
       t,
       undefined,
-      t instanceof NotReadyError ? e.ie : undefined
+      t instanceof NotReadyError ? e.q : undefined
     );
   } finally {
     tracking = a;
     e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
     context = s;
   }
-  if (!e.q) {
-    const s = e.Ce;
+  if (!e.le) {
+    const s = e.ye;
     let a = s !== null ? s.D : e.C;
     if (a !== null) {
       do {
@@ -1144,30 +1215,30 @@ function recompute(e, t = false) {
       if (s !== null) s.D = null;
       else e.C = null;
     }
-    const l = r ? e.Te : e.le === NOT_PENDING ? e.fe : e.le;
-    const f = !e.Ie || !e.Ie(l, u);
-    if (f) {
-      const s = r ? e.Te : undefined;
-      if (t || (n && activeTransition !== e.ne) || i) {
-        e.fe = u;
+    const f = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
+    const l = !e.Ne || !e.Ne(f, u);
+    if (l) {
+      const s = r ? e.ee : undefined;
+      if (t || (n && activeTransition !== e.K) || i) {
+        e.J = u;
         if (r && i) {
-          e.Te = u;
-          e.le = u;
+          e.ee = u;
+          e.X = u;
         }
-      } else e.le = u;
-      if (r && !i && o && !e.Oe) e.Te = u;
-      if (!r || i || e.Te !== s) insertSubs(e, i || r);
+      } else e.X = u;
+      if (r && !i && o && !e._e) e.ee = u;
+      if (!r || i || e.ee !== s) insertSubs(e, i || r);
     } else if (r) {
-      e.le = u;
+      e.X = u;
     } else if (e.o != c) {
       for (let t = e.I; t !== null; t = t.p) {
         insertIntoHeapHeight(t.h, t.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       }
     }
   }
-  currentOptimisticLane = l;
-  (!t || e.Ee & STATUS_PENDING) && !e.ne && !(activeTransition && r) && globalQueue.M.push(e);
-  e.ne && n && activeTransition !== e.ne && runInTransition(e.ne, () => recompute(e));
+  currentOptimisticLane = f;
+  (!t || e.Se & STATUS_PENDING) && !e.K && !(activeTransition && r) && globalQueue.oe.push(e);
+  e.K && n && activeTransition !== e.K && runInTransition(e.K, () => recompute(e));
 }
 function updateIfNecessary(e) {
   if (e.O & REACTIVE_CHECK) {
@@ -1182,7 +1253,7 @@ function updateIfNecessary(e) {
       }
     }
   }
-  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.q && e.J < clock && !e._e)) {
+  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.le && e.Ee < clock && !e.Ae)) {
     recompute(e);
   }
   e.O = REACTIVE_NONE | (e.O & REACTIVE_SNAPSHOT_STALE);
@@ -1192,54 +1263,54 @@ function computed(e, t, n) {
   const r = {
     id: n?.id ?? (i ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
     Ve: i || undefined,
-    Ie: n?.equals != null ? n.equals : isEqual,
-    Ge: !!n?.pureWrite,
-    ge: n?.unobserved,
-    me: null,
-    ce: context?.ce ?? globalQueue,
+    Ne: n?.equals != null ? n.equals : isEqual,
+    fe: !!n?.pureWrite,
+    Ge: n?.unobserved,
+    be: null,
+    F: context?.F ?? globalQueue,
     Le: context?.Le ?? defaultContext,
-    we: 0,
+    ve: 0,
     L: e,
-    fe: t,
+    J: t,
     o: 0,
     A: null,
     S: undefined,
     T: null,
     C: null,
-    Ce: null,
+    ye: null,
     I: null,
-    Ne: null,
+    ke: null,
     i: context,
-    ye: null,
     De: null,
+    Ce: null,
     O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    Ee: STATUS_UNINITIALIZED,
-    J: clock,
-    le: NOT_PENDING,
-    be: null,
-    ve: null,
-    _e: null,
-    ne: null
+    Se: STATUS_UNINITIALIZED,
+    Ee: clock,
+    X: NOT_PENDING,
+    we: null,
+    me: null,
+    Ae: null,
+    K: null
   };
   r.T = r;
   const o = context?.t ? context.u : context;
   if (context) {
-    const e = context.De;
+    const e = context.Ce;
     if (e === null) {
-      context.De = r;
+      context.Ce = r;
     } else {
-      r.ye = e;
-      context.De = r;
+      r.De = e;
+      context.Ce = r;
     }
   }
   if (o) r.o = o.o + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.oe = true;
+  if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.de = true;
   if (externalSourceConfig) {
     const e = signal(undefined, { equals: false, pureWrite: true });
     const t = externalSourceConfig.factory(r.L, () => {
       setSignal(e, undefined);
     });
-    onCleanup(() => t.dispose());
+    cleanup(() => t.dispose());
     r.L = n => {
       read(e);
       return t.track(n);
@@ -1247,8 +1318,8 @@ function computed(e, t, n) {
   }
   !n?.lazy && recompute(r, true);
   if (snapshotCaptureActive && !n?.lazy) {
-    if (!(r.Ee & STATUS_PENDING)) {
-      r.re = r.fe === undefined ? NO_SNAPSHOT : r.fe;
+    if (!(r.Se & STATUS_PENDING)) {
+      r.Te = r.J === undefined ? NO_SNAPSHOT : r.J;
       snapshotSources.add(r);
     }
   }
@@ -1256,33 +1327,33 @@ function computed(e, t, n) {
 }
 function signal(e, t, n = null) {
   const i = {
-    Ie: t?.equals != null ? t.equals : isEqual,
-    Ge: !!t?.pureWrite,
-    Qe: !!t?.Qe,
-    ge: t?.unobserved,
-    fe: e,
+    Ne: t?.equals != null ? t.equals : isEqual,
+    fe: !!t?.pureWrite,
+    He: !!t?.He,
+    Ge: t?.unobserved,
+    J: e,
     I: null,
-    Ne: null,
-    J: clock,
+    ke: null,
+    Ee: clock,
     V: n,
     N: n?.A || null,
-    le: NOT_PENDING
+    X: NOT_PENDING
   };
   n && (n.A = i);
-  if (snapshotCaptureActive && !i.Qe && !((n?.Ee ?? 0) & STATUS_PENDING)) {
-    i.re = e === undefined ? NO_SNAPSHOT : e;
+  if (snapshotCaptureActive && !i.He && !((n?.Se ?? 0) & STATUS_PENDING)) {
+    i.Te = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources.add(i);
   }
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.Te = NOT_PENDING;
+  n.ee = NOT_PENDING;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const i = computed(e, t, n);
-  i.Te = NOT_PENDING;
+  i.ee = NOT_PENDING;
   return i;
 }
 function isEqual(e, t) {
@@ -1304,7 +1375,7 @@ function read(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     latestReadActive = false;
-    const i = e.Te !== undefined && e.Te !== NOT_PENDING ? e.Te : e.fe;
+    const i = e.ee !== undefined && e.ee !== NOT_PENDING ? e.ee : e.J;
     let r;
     try {
       r = read(t);
@@ -1314,26 +1385,30 @@ function read(e) {
     } finally {
       latestReadActive = n;
     }
-    if (t.Ee & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.ie) {
-      const e = findLane(t.ie);
+    if (t.Se & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.q) {
+      const e = findLane(t.q);
       const n = findLane(currentOptimisticLane);
-      if (e !== n && e.U.size > 0) {
+      if (e !== n && e.k.size > 0) {
         return i;
       }
     }
     return r;
   }
   if (pendingCheckActive) {
-    const t = e.V || e;
-    const n = getPendingSignal(t);
-    const i = pendingCheckActive;
+    const t = e.V;
+    const n = pendingCheckActive;
     pendingCheckActive = false;
-    if (read(n)) {
-      foundPending = true;
+    if (t && e.ee !== undefined) {
+      if (e.ee !== NOT_PENDING && (t.Ae || !!(t.Se & STATUS_PENDING))) {
+        foundPending = true;
+      }
+    } else {
+      if (read(getPendingSignal(e))) foundPending = true;
+      if (t && read(getPendingSignal(t))) foundPending = true;
     }
-    pendingCheckActive = i;
-    return e.fe;
+    pendingCheckActive = n;
+    return e.J;
   }
   let t = context;
   if (t?.t) t = t.u;
@@ -1359,56 +1434,57 @@ function read(e) {
       }
     }
   }
-  if (n.Ee & STATUS_PENDING) {
-    const i = n.q?.source;
-    if (i && !(i.Ee & STATUS_PENDING)) clearStatus(n);
-    else if (t && !(stale && n.ne && activeTransition !== n.ne)) {
+  if (n.Se & STATUS_PENDING) {
+    if (t && !(stale && n.K && activeTransition !== n.K)) {
       if (currentOptimisticLane) {
-        const i = n.ie;
+        const i = n.q;
         const r = findLane(currentOptimisticLane);
         if (i && findLane(i) === r && !hasActiveOverride(n)) {
           if (!tracking && e !== t) link(e, t);
-          throw n.q;
+          throw n.le;
         }
       } else {
         if (!tracking && e !== t) link(e, t);
-        throw n.q;
+        throw n.le;
       }
-    } else if (!t && n.Ee & STATUS_UNINITIALIZED) {
-      throw n.q;
+    } else if (!t && n.Se & STATUS_UNINITIALIZED) {
+      throw n.le;
     }
   }
-  if (e.L && e.Ee & STATUS_ERROR) {
-    if (e.J < clock) {
+  if (e.L && e.Se & STATUS_ERROR) {
+    if (e.Ee < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.q;
+    } else throw e.le;
   }
-  if (snapshotCaptureActive && t && t.oe) {
-    const n = e.re;
+  if (snapshotCaptureActive && t && t.de) {
+    const n = e.Te;
     if (n !== undefined) {
       const i = n === NO_SNAPSHOT ? undefined : n;
-      const r = e.le !== NOT_PENDING ? e.le : e.fe;
+      const r = e.X !== NOT_PENDING ? e.X : e.J;
       if (r !== i) t.O |= REACTIVE_SNAPSHOT_STALE;
       return i;
     }
   }
-  if (e.Te !== undefined && e.Te !== NOT_PENDING) return e.Te;
+  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
+    if (t && stale && shouldReadStashedOptimisticValue(e)) return e.J;
+    return e.ee;
+  }
   return !t ||
     (currentOptimisticLane !== null &&
-      (e.Te !== undefined || e.ie || (n === e && stale) || !!(n.Ee & STATUS_PENDING))) ||
-    e.le === NOT_PENDING ||
-    (stale && e.ne && activeTransition !== e.ne)
-    ? e.fe
-    : e.le;
+      (e.ee !== undefined || e.q || (n === e && stale) || !!(n.Se & STATUS_PENDING))) ||
+    e.X === NOT_PENDING ||
+    (stale && e.K && activeTransition !== e.K)
+    ? e.J
+    : e.X;
 }
 function setSignal(e, t) {
-  if (e.ne && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
-  const n = e.Te !== undefined && !projectionWriteActive;
-  const i = e.Te !== undefined && e.Te !== NOT_PENDING;
-  const r = n ? (i ? e.Te : e.fe) : e.le === NOT_PENDING ? e.fe : e.le;
+  if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
+  const n = e.ee !== undefined && !projectionWriteActive;
+  const i = e.ee !== undefined && e.ee !== NOT_PENDING;
+  const r = n ? (i ? e.ee : e.J) : e.X === NOT_PENDING ? e.J : e.X;
   if (typeof t === "function") t = t(r);
-  const o = !e.Ie || !e.Ie(r, t) || !!(e.Ee & STATUS_UNINITIALIZED);
+  const o = !e.Ne || !e.Ne(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
   if (!o) {
     if (n && i && e.L) {
       insertSubs(e, true);
@@ -1417,25 +1493,25 @@ function setSignal(e, t) {
     return t;
   }
   if (n) {
-    const n = e.Te === NOT_PENDING;
-    if (!n && e.ne) globalQueue.initTransition(e.ne);
+    const n = e.ee === NOT_PENDING;
+    if (!n) globalQueue.initTransition(resolveTransition(e));
     if (n) {
-      e.le = e.fe;
-      globalQueue.$.push(e);
+      e.X = e.J;
+      globalQueue.Y.push(e);
     }
-    e.Oe = true;
+    e._e = true;
     const i = getOrCreateLane(e);
-    e.ie = i;
-    e.Te = t;
+    e.q = i;
+    e.ee = t;
   } else {
-    if (e.le === NOT_PENDING) globalQueue.M.push(e);
-    e.le = t;
+    if (e.X === NOT_PENDING) globalQueue.oe.push(e);
+    e.X = t;
   }
   updatePendingSignal(e);
-  if (e.pe) {
-    setSignal(e.pe, t);
+  if (e.Pe) {
+    setSignal(e.Pe, t);
   }
-  e.J = clock;
+  e.Ee = clock;
   insertSubs(e, n);
   schedule();
   return t;
@@ -1453,61 +1529,68 @@ function runWithOwner(e, t) {
   }
 }
 function getPendingSignal(e) {
-  if (!e.Fe) {
-    e.Fe = optimisticSignal(false, { pureWrite: true });
-    if (e.Se) {
-      e.Fe.Se = e;
+  if (!e.Qe) {
+    e.Qe = optimisticSignal(false, { pureWrite: true });
+    if (e.Re) {
+      e.Qe.Re = e;
     }
-    if (computePendingState(e)) setSignal(e.Fe, true);
+    if (computePendingState(e)) setSignal(e.Qe, true);
   }
-  return e.Fe;
+  return e.Qe;
 }
 function computePendingState(e) {
   const t = e;
-  if (e.Te !== undefined && e.Te !== NOT_PENDING) {
-    if (t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
-    if (e.Se) {
-      const t = e.ie ? findLane(e.ie) : null;
-      return !!(t && t.U.size > 0);
+  const n = e.V;
+  if (n && e.X !== NOT_PENDING) {
+    return !n.Ae && !(n.Se & STATUS_PENDING);
+  }
+  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
+    if (t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+    if (e.Re) {
+      const t = e.q ? findLane(e.q) : null;
+      return !!(t && t.k.size > 0);
     }
     return true;
   }
-  if (e.le !== NOT_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED));
+  if (e.ee !== undefined && e.ee === NOT_PENDING && !e.Re) {
+    return false;
+  }
+  if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+  return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
 }
 function updatePendingSignal(e) {
-  if (e.Fe) {
+  if (e.Qe) {
     const t = computePendingState(e);
-    const n = e.Fe;
+    const n = e.Qe;
     setSignal(n, t);
-    if (!t && n.ie) {
+    if (!t && n.q) {
       const t = resolveLane(e);
-      if (t && t.U.size > 0) {
-        const e = findLane(n.ie);
+      if (t && t.k.size > 0) {
+        const e = findLane(n.q);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
       signalLanes.delete(n);
-      n.ie = undefined;
+      n.q = undefined;
     }
   }
 }
 function getLatestValueComputed(e) {
-  if (!e.pe) {
+  if (!e.Pe) {
     const t = latestReadActive;
     latestReadActive = false;
     const n = pendingCheckActive;
     pendingCheckActive = false;
     const i = context;
     context = null;
-    e.pe = optimisticComputed(() => read(e));
-    e.pe.Se = e;
+    e.Pe = optimisticComputed(() => read(e));
+    e.Pe.Re = e;
     context = i;
     pendingCheckActive = n;
     latestReadActive = t;
   }
-  return e.pe;
+  return e.Pe;
 }
 function staleValues(e, t = true) {
   const n = stale;
@@ -1586,6 +1669,96 @@ 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.H = !s.le;
+      if (o) s.F.enqueue(s.W, runEffect.bind(s));
+      return false;
+    },
+    lazy: true
+  });
+  s.Fe = i;
+  s.Me = t;
+  s.$e = n;
+  s.je = undefined;
+  s.W = r?.render ? EFFECT_RENDER : EFFECT_USER;
+  s.ge = (e, t) => {
+    const n = e !== undefined ? e : s.Se;
+    const i = t !== undefined ? t : s.le;
+    if (n & STATUS_ERROR) {
+      let e = i;
+      s.F.notify(s, STATUS_PENDING, 0);
+      if (s.W === EFFECT_USER) {
+        try {
+          return s.$e
+            ? s.$e(e, () => {
+                s.je?.();
+                s.je = undefined;
+              })
+            : console.error(e);
+        } catch (t) {
+          e = t;
+        }
+      }
+      if (!s.F.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
+    } else if (s.W === EFFECT_RENDER) {
+      s.F.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
+    }
+  };
+  recompute(s, true);
+  !r?.defer && (s.W === EFFECT_USER ? s.F.enqueue(s.W, runEffect.bind(s)) : runEffect.call(s));
+  o = true;
+  cleanup(() => s.je?.());
+}
+function runEffect() {
+  if (!this.H || this.O & REACTIVE_DISPOSED) return;
+  this.je?.();
+  this.je = undefined;
+  try {
+    this.je = this.Me(this.J, this.Fe);
+  } catch (e) {
+    this.le = new StatusError(this, e);
+    this.Se |= STATUS_ERROR;
+    if (!this.F.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+  } finally {
+    this.Fe = this.J;
+    this.H = false;
+  }
+}
+function trackedEffect(e, t) {
+  const run = () => {
+    if (!n.H || n.O & REACTIVE_DISPOSED) return;
+    n.H = false;
+    recompute(n);
+  };
+  const n = computed(
+    () => {
+      n.je?.();
+      n.je = undefined;
+      n.je = staleValues(e) || undefined;
+    },
+    undefined,
+    { ...t, lazy: true }
+  );
+  n.je = undefined;
+  n.Ke = true;
+  n.H = true;
+  n.W = EFFECT_TRACKED;
+  n.ge = (e, t) => {
+    const i = e !== undefined ? e : n.Se;
+    if (i & STATUS_ERROR) {
+      n.F.notify(n, STATUS_PENDING, 0);
+      const e = t !== undefined ? t : n.le;
+      if (!n.F.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
+    }
+  };
+  n.M = run;
+  n.F.enqueue(EFFECT_USER, run);
+  cleanup(() => n.je?.());
+}
 function restoreTransition(e, t) {
   globalQueue.initTransition(e);
   const n = t();
@@ -1598,11 +1771,11 @@ function action(e) {
       const r = e(...t);
       globalQueue.initTransition();
       let o = activeTransition;
-      o.ee.push(r);
+      o.j.push(r);
       const done = (e, t) => {
         o = currentTransition(o);
-        const s = o.ee.indexOf(r);
-        if (s >= 0) o.ee.splice(s, 1);
+        const s = o.j.indexOf(r);
+        if (s >= 0) o.j.splice(s, 1);
         setActiveTransition(o);
         schedule();
         t ? i(t) : n(e);
@@ -1630,6 +1803,9 @@ function action(e) {
       step();
     });
 }
+function onCleanup(e) {
+  return cleanup(e);
+}
 function accessor(e) {
   const t = read.bind(null, e);
   t.$r = true;
@@ -1658,7 +1834,7 @@ function createTrackedEffect(e, t) {
 }
 function createReaction(e, t) {
   let n = undefined;
-  onCleanup(() => n?.());
+  cleanup(() => n?.());
   const i = getOwner();
   return r => {
     runWithOwner(i, () => {
@@ -1696,7 +1872,8 @@ function createOptimistic(e, t, n) {
   return [accessor(i), setSignal.bind(null, i)];
 }
 function onSettled(e) {
-  getOwner()
+  const t = getOwner();
+  t && !t.Ke
     ? createTrackedEffect(() => untrack(e))
     : globalQueue.enqueue(EFFECT_USER, () => {
         const t = e();
@@ -1730,67 +1907,67 @@ function applyState(e, t, n) {
     let t = false;
     const c = getOverrideValue(r, o, u, "length", s);
     if (e.length && c && e[0] && n(e[0]) != null) {
-      let a, l, f, E, T, d, S, R;
+      let a, f, l, E, T, d, S, R;
       for (
-        f = 0, E = Math.min(c, e.length);
-        f < E &&
-        ((d = getOverrideValue(r, o, u, f, s)) === e[f] || (d && e[f] && n(d) === n(e[f])));
-        f++
+        l = 0, E = Math.min(c, e.length);
+        l < E &&
+        ((d = getOverrideValue(r, o, u, l, s)) === e[l] || (d && e[l] && n(d) === n(e[l])));
+        l++
       ) {
-        applyState(e[f], wrap(d, i), n);
+        applyState(e[l], wrap(d, i), n);
       }
       const O = new Array(e.length),
         _ = new Map();
       for (
         E = c - 1, T = e.length - 1;
-        E >= f &&
-        T >= f &&
+        E >= l &&
+        T >= l &&
         ((d = getOverrideValue(r, o, u, E, s)) === e[T] || (d && e[T] && n(d) === n(e[T])));
         E--, T--
       ) {
         O[T] = d;
       }
-      if (f > T || f > E) {
-        for (l = f; l <= T; l++) {
+      if (l > T || l > E) {
+        for (f = l; f <= T; f++) {
           t = true;
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
+          i[STORE_NODE][f] && setSignal(i[STORE_NODE][f], wrap(e[f], i));
         }
-        for (; l < e.length; l++) {
+        for (; f < e.length; f++) {
           t = true;
-          const r = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], r);
-          applyState(e[l], r, n);
+          const r = wrap(O[f], i);
+          i[STORE_NODE][f] && setSignal(i[STORE_NODE][f], r);
+          applyState(e[f], r, n);
         }
         t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
         c !== e.length && i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
         return;
       }
       S = new Array(T + 1);
-      for (l = T; l >= f; l--) {
-        d = e[l];
+      for (f = T; f >= l; f--) {
+        d = e[f];
         R = d ? n(d) : d;
         a = _.get(R);
-        S[l] = a === undefined ? -1 : a;
-        _.set(R, l);
+        S[f] = a === undefined ? -1 : a;
+        _.set(R, f);
       }
-      for (a = f; a <= E; a++) {
+      for (a = l; a <= E; a++) {
         d = getOverrideValue(r, o, u, a, s);
         R = d ? n(d) : d;
-        l = _.get(R);
-        if (l !== undefined && l !== -1) {
-          O[l] = d;
-          l = S[l];
-          _.set(R, l);
+        f = _.get(R);
+        if (f !== undefined && f !== -1) {
+          O[f] = d;
+          f = S[f];
+          _.set(R, f);
         }
       }
-      for (l = f; l < e.length; l++) {
-        if (l in O) {
-          const t = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], t);
-          applyState(e[l], t, n);
-        } else i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
+      for (f = l; f < e.length; f++) {
+        if (f in O) {
+          const t = wrap(O[f], i);
+          i[STORE_NODE][f] && setSignal(i[STORE_NODE][f], t);
+          applyState(e[f], t, n);
+        } else i[STORE_NODE][f] && setSignal(i[STORE_NODE][f], wrap(e[f], i));
       }
-      if (f < e.length) t = true;
+      if (l < e.length) t = true;
     } else if (e.length) {
       for (let t = 0, c = e.length; t < c; t++) {
         const c = getOverrideValue(r, o, u, t, s);
@@ -1809,15 +1986,15 @@ function applyState(e, t, n) {
   if (u) {
     const t = u[$TRACK];
     const c = t ? getAllKeys(r, o, e) : Object.keys(u);
-    for (let a = 0, l = c.length; a < l; a++) {
-      const l = c[a];
-      const f = u[l];
-      const E = unwrap(getOverrideValue(r, o, u, l, s));
-      let T = unwrap(e[l]);
+    for (let a = 0, f = c.length; a < f; a++) {
+      const f = c[a];
+      const l = u[f];
+      const E = unwrap(getOverrideValue(r, o, u, f, s));
+      let T = unwrap(e[f]);
       if (E === T) continue;
       if (!E || !isWrappable(E) || !isWrappable(T) || (n(E) != null && n(E) !== n(T))) {
         t && setSignal(t, void 0);
-        f && setSignal(f, isWrappable(T) ? wrap(T, i) : T);
+        l && setSignal(l, isWrappable(T) ? wrap(T, i) : T);
       } else applyState(T, wrap(E, i), n);
     }
   }
@@ -1862,55 +2039,68 @@ function createProjectionInternal(e, t = {}, n) {
   const o = wrapProjection(t);
   i = computed(() => {
     const t = getOwner();
-    storeSetter(new Proxy(o, writeTraps), i => {
-      const r = handleAsync(t, e(i), e => {
-        e !== i && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id"));
+    let i = false;
+    let r;
+    const s = new Proxy(
+      o,
+      createWriteTraps(() => !i || t.Ae === r)
+    );
+    storeSetter(s, s => {
+      r = e(s);
+      i = true;
+      const u = handleAsync(t, r, e => {
+        e !== s && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id"));
       });
-      r !== i && r !== undefined && reconcile(r, n?.key || "id")(o);
+      u !== s && u !== undefined && reconcile(u, n?.key || "id")(o);
     });
   });
-  i.Pe = true;
+  i.xe = true;
   return { store: o, node: i };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
 }
-const writeTraps = {
-  get(e, t) {
-    let n;
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      n = e[t];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return typeof n === "object" && n !== null ? new Proxy(n, writeTraps) : n;
-  },
-  set(e, t, n) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      e[t] = n;
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return true;
-  },
-  deleteProperty(e, t) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      delete e[t];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
+function createWriteTraps(e) {
+  const t = {
+    get(e, n) {
+      let i;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        i = e[n];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return typeof i === "object" && i !== null ? new Proxy(i, t) : i;
+    },
+    set(t, n, i) {
+      if (e && !e()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        t[n] = i;
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
+    },
+    deleteProperty(t, n) {
+      if (e && !e()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        delete t[n];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
     }
-    return true;
-  }
-};
+  };
+  return t;
+}
 const $TRACK = Symbol(0),
   $TARGET = Symbol(0),
   $PROXY = Symbol(0),
@@ -1968,11 +2158,11 @@ function getNode(e, t, n, i, r = isEqual, o, s) {
     i
   );
   if (o) {
-    u.Te = NOT_PENDING;
+    u.ee = NOT_PENDING;
   }
   if (s && t in s) {
     const e = s[t];
-    u.re = e === undefined ? NO_SNAPSHOT : e;
+    u.Te = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources?.add(u);
   }
   return (e[t] = u);
@@ -2029,11 +2219,11 @@ const storeTraps = {
     if (writeOnly(n)) {
       let n =
         r && (s || !u)
-          ? r.Te !== undefined && r.Te !== NOT_PENDING
-            ? r.Te
-            : r.le !== NOT_PENDING
-              ? r.le
-              : r.fe
+          ? r.ee !== undefined && r.ee !== NOT_PENDING
+            ? r.ee
+            : r.X !== NOT_PENDING
+              ? r.X
+              : r.J
           : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
@@ -2084,8 +2274,8 @@ const storeTraps = {
     if (writeOnly(i)) {
       if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.ne) {
-          globalQueue.initTransition(t.ne);
+        if (t?.K) {
+          globalQueue.initTransition(t.K);
         }
       }
       untrack(() => {
@@ -2094,7 +2284,7 @@ const storeTraps = {
         if (
           snapshotCaptureActive &&
           typeof t !== "symbol" &&
-          !((e[STORE_FIREWALL]?.Ee ?? 0) & STATUS_PENDING)
+          !((e[STORE_FIREWALL]?.Se ?? 0) & STATUS_PENDING)
         ) {
           if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
@@ -2115,19 +2305,19 @@ const storeTraps = {
               : o;
         const a = n?.[$TARGET]?.[STORE_VALUE] ?? n;
         if (c === a) return true;
-        const l = e[STORE_OPTIMISTIC_OVERRIDE]?.length || e[STORE_OVERRIDE]?.length || r.length;
+        const f = e[STORE_OPTIMISTIC_OVERRIDE]?.length || e[STORE_OVERRIDE]?.length || r.length;
         if (a !== undefined && a === o) delete e[u][t];
         else (e[u] || (e[u] = Object.create(null)))[t] = a;
-        const f = isWrappable(a);
+        const l = isWrappable(a);
         e[STORE_HAS]?.[t] && setSignal(e[STORE_HAS][t], true);
         const E = getNodes(e, STORE_NODE);
-        E[t] && setSignal(E[t], () => (f ? wrap(a, e) : a));
+        E[t] && setSignal(E[t], () => (l ? wrap(a, e) : a));
         if (Array.isArray(r)) {
           if (t === "length") {
             E.length && setSignal(E.length, a);
           } else {
             const e = parseInt(t) + 1;
-            if (e > l) E.length && setSignal(E.length, e);
+            if (e > f) E.length && setSignal(E.length, e);
           }
         }
         E[$TRACK] && setSignal(E[$TRACK], undefined);
@@ -2225,7 +2415,7 @@ function createStore(e, t, n) {
   return [r, e => storeSetter(r, e)];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.B ||= clearOptimisticStore;
+  GlobalQueue.ce ||= clearOptimisticStore;
   const i = typeof e === "function";
   const r = (i ? t : e) ?? {};
   const o = i ? e : undefined;
@@ -2242,7 +2432,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].ie = undefined;
+          i[e].q = 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;
@@ -2250,7 +2440,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].ie = undefined;
+        i[$TRACK].q = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2284,24 +2474,32 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
   if (e) {
     i = computed(() => {
       const t = getOwner();
+      let i = false;
+      let r;
+      const s = new Proxy(
+        o,
+        createWriteTraps(() => !i || t.Ae === r)
+      );
       setProjectionWriteActive(true);
       try {
-        storeSetter(new Proxy(o, writeTraps), i => {
-          const r = handleAsync(t, e(i), e => {
+        storeSetter(s, s => {
+          r = e(s);
+          i = true;
+          const u = handleAsync(t, r, e => {
             setProjectionWriteActive(true);
             try {
-              e !== i && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id"));
+              e !== s && e !== undefined && storeSetter(o, reconcile(e, n?.key || "id"));
             } finally {
               setProjectionWriteActive(false);
             }
           });
-          r !== i && r !== undefined && reconcile(r, n?.key || "id")(o);
+          u !== s && u !== undefined && reconcile(u, n?.key || "id")(o);
         });
       } finally {
         setProjectionWriteActive(false);
       }
     });
-    i.Pe = true;
+    i.xe = true;
   }
   return { store: o, node: i };
 }
@@ -2388,29 +2586,29 @@ function snapshotImpl(e, t, n, i) {
   }
   if (o) {
     const o = s?.length || e.length;
-    for (let l = 0; l < o; l++) {
-      a = s && l in s ? s[l] : e[l];
+    for (let f = 0; f < o; f++) {
+      a = s && f in s ? s[f] : e[f];
       if (a === $DELETED) continue;
       if (t && isWrappable(a)) wrap(a, r);
       if ((c = snapshotImpl(a, t, n, i)) !== a || u) {
         if (!u) n.set(e, (u = [...e]));
-        u[l] = c;
+        u[f] = c;
       }
     }
   } else {
     const o = getKeys(e, s);
-    for (let l = 0, f = o.length; l < f; l++) {
-      let f = o[l];
-      const E = getPropertyDescriptor(e, s, f);
+    for (let f = 0, l = o.length; f < l; f++) {
+      let l = o[f];
+      const E = getPropertyDescriptor(e, s, l);
       if (E.get) continue;
-      a = s && f in s ? s[f] : e[f];
+      a = s && l in s ? s[l] : e[l];
       if (t && isWrappable(a)) wrap(a, r);
-      if ((c = snapshotImpl(a, t, n, i)) !== e[f] || u) {
+      if ((c = snapshotImpl(a, t, n, i)) !== e[l] || u) {
         if (!u) {
           u = Object.create(Object.getPrototypeOf(e));
           Object.assign(u, e);
         }
-        u[f] = c;
+        u[l] = c;
       }
     }
   }
@@ -2558,221 +2756,221 @@ function mapArray(e, t, n) {
   const o = t;
   return createMemo(
     updateKeyedMap.bind({
-      Me: createOwner(),
-      $e: 0,
-      je: e,
-      Ke: [],
-      Ye: o,
-      Be: [],
-      Ze: [],
-      qe: i,
-      Xe: i || n?.keyed === false ? [] : undefined,
-      ze: r ? [] : undefined,
-      Je: n?.fallback
+      Ye: createOwner(),
+      Be: 0,
+      Ze: e,
+      qe: [],
+      ze: o,
+      Xe: [],
+      Je: [],
+      et: i,
+      tt: i || n?.keyed === false ? [] : undefined,
+      nt: r ? [] : undefined,
+      it: n?.fallback
     })
   );
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.je() || [],
+  const e = this.Ze() || [],
     t = e.length;
   e[$TRACK];
-  runWithOwner(this.Me, () => {
+  runWithOwner(this.Ye, () => {
     let n,
       i,
-      r = this.Xe
+      r = this.tt
         ? () => {
-            this.Xe[i] = signal(e[i], pureOptions);
-            this.ze && (this.ze[i] = signal(i, pureOptions));
-            return this.Ye(accessor(this.Xe[i]), this.ze ? accessor(this.ze[i]) : undefined);
+            this.tt[i] = signal(e[i], pureOptions);
+            this.nt && (this.nt[i] = signal(i, pureOptions));
+            return this.ze(accessor(this.tt[i]), this.nt ? accessor(this.nt[i]) : undefined);
           }
-        : this.ze
+        : this.nt
           ? () => {
               const t = e[i];
-              this.ze[i] = signal(i, pureOptions);
-              return this.Ye(() => t, accessor(this.ze[i]));
+              this.nt[i] = signal(i, pureOptions);
+              return this.ze(() => t, accessor(this.nt[i]));
             }
           : () => {
               const t = e[i];
-              return this.Ye(() => t);
+              return this.ze(() => t);
             };
     if (t === 0) {
-      if (this.$e !== 0) {
-        this.Me.dispose(false);
-        this.Ze = [];
-        this.Ke = [];
-        this.Be = [];
-        this.$e = 0;
-        this.Xe && (this.Xe = []);
-        this.ze && (this.ze = []);
-      }
-      if (this.Je && !this.Be[0]) {
-        this.Be[0] = runWithOwner((this.Ze[0] = createOwner()), this.Je);
-      }
-    } else if (this.$e === 0) {
-      if (this.Ze[0]) this.Ze[0].dispose();
-      this.Be = new Array(t);
+      if (this.Be !== 0) {
+        this.Ye.dispose(false);
+        this.Je = [];
+        this.qe = [];
+        this.Xe = [];
+        this.Be = 0;
+        this.tt && (this.tt = []);
+        this.nt && (this.nt = []);
+      }
+      if (this.it && !this.Xe[0]) {
+        this.Xe[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
+      }
+    } else if (this.Be === 0) {
+      if (this.Je[0]) this.Je[0].dispose();
+      this.Xe = new Array(t);
       for (i = 0; i < t; i++) {
-        this.Ke[i] = e[i];
-        this.Be[i] = runWithOwner((this.Ze[i] = createOwner()), r);
+        this.qe[i] = e[i];
+        this.Xe[i] = runWithOwner((this.Je[i] = createOwner()), r);
       }
-      this.$e = t;
+      this.Be = t;
     } else {
       let o,
         s,
         u,
         c,
         a,
-        l,
         f,
+        l,
         E = new Array(t),
         T = new Array(t),
-        d = this.Xe ? new Array(t) : undefined,
-        S = this.ze ? new Array(t) : undefined;
+        d = this.tt ? new Array(t) : undefined,
+        S = this.nt ? new Array(t) : undefined;
       for (
-        o = 0, s = Math.min(this.$e, t);
-        o < s && (this.Ke[o] === e[o] || (this.Xe && compare(this.qe, this.Ke[o], e[o])));
+        o = 0, s = Math.min(this.Be, t);
+        o < s && (this.qe[o] === e[o] || (this.tt && compare(this.et, this.qe[o], e[o])));
         o++
       ) {
-        if (this.Xe) setSignal(this.Xe[o], e[o]);
+        if (this.tt) setSignal(this.tt[o], e[o]);
       }
       for (
-        s = this.$e - 1, u = t - 1;
+        s = this.Be - 1, u = t - 1;
         s >= o &&
         u >= o &&
-        (this.Ke[s] === e[u] || (this.Xe && compare(this.qe, this.Ke[s], e[u])));
+        (this.qe[s] === e[u] || (this.tt && compare(this.et, this.qe[s], e[u])));
         s--, u--
       ) {
-        E[u] = this.Be[s];
-        T[u] = this.Ze[s];
-        d && (d[u] = this.Xe[s]);
-        S && (S[u] = this.ze[s]);
+        E[u] = this.Xe[s];
+        T[u] = this.Je[s];
+        d && (d[u] = this.tt[s]);
+        S && (S[u] = this.nt[s]);
       }
-      l = new Map();
-      f = new Array(u + 1);
+      f = new Map();
+      l = new Array(u + 1);
       for (i = u; i >= o; i--) {
         c = e[i];
-        a = this.qe ? this.qe(c) : c;
-        n = l.get(a);
-        f[i] = n === undefined ? -1 : n;
-        l.set(a, i);
+        a = this.et ? this.et(c) : c;
+        n = f.get(a);
+        l[i] = n === undefined ? -1 : n;
+        f.set(a, i);
       }
       for (n = o; n <= s; n++) {
-        c = this.Ke[n];
-        a = this.qe ? this.qe(c) : c;
-        i = l.get(a);
+        c = this.qe[n];
+        a = this.et ? this.et(c) : c;
+        i = f.get(a);
         if (i !== undefined && i !== -1) {
-          E[i] = this.Be[n];
-          T[i] = this.Ze[n];
-          d && (d[i] = this.Xe[n]);
-          S && (S[i] = this.ze[n]);
-          i = f[i];
-          l.set(a, i);
-        } else this.Ze[n].dispose();
+          E[i] = this.Xe[n];
+          T[i] = this.Je[n];
+          d && (d[i] = this.tt[n]);
+          S && (S[i] = this.nt[n]);
+          i = l[i];
+          f.set(a, i);
+        } else this.Je[n].dispose();
       }
       for (i = o; i < t; i++) {
         if (i in E) {
-          this.Be[i] = E[i];
-          this.Ze[i] = T[i];
+          this.Xe[i] = E[i];
+          this.Je[i] = T[i];
           if (d) {
-            this.Xe[i] = d[i];
-            setSignal(this.Xe[i], e[i]);
+            this.tt[i] = d[i];
+            setSignal(this.tt[i], e[i]);
           }
           if (S) {
-            this.ze[i] = S[i];
-            setSignal(this.ze[i], i);
+            this.nt[i] = S[i];
+            setSignal(this.nt[i], i);
           }
         } else {
-          this.Be[i] = runWithOwner((this.Ze[i] = createOwner()), r);
+          this.Xe[i] = runWithOwner((this.Je[i] = createOwner()), r);
         }
       }
-      this.Be = this.Be.slice(0, (this.$e = t));
-      this.Ke = e.slice(0);
+      this.Xe = this.Xe.slice(0, (this.Be = t));
+      this.qe = e.slice(0);
     }
   });
-  return this.Be;
+  return this.Xe;
 }
 function repeat(e, t, n) {
   const i = t;
   return updateRepeat.bind({
-    Me: createOwner(),
-    $e: 0,
-    et: 0,
-    tt: e,
-    Ye: i,
-    Ze: [],
-    Be: [],
-    nt: n?.from,
-    Je: n?.fallback
+    Ye: createOwner(),
+    Be: 0,
+    rt: 0,
+    ot: e,
+    ze: i,
+    Je: [],
+    Xe: [],
+    st: n?.from,
+    it: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.tt();
-  const t = this.nt?.() || 0;
-  runWithOwner(this.Me, () => {
+  const e = this.ot();
+  const t = this.st?.() || 0;
+  runWithOwner(this.Ye, () => {
     if (e === 0) {
-      if (this.$e !== 0) {
-        this.Me.dispose(false);
-        this.Ze = [];
-        this.Be = [];
-        this.$e = 0;
+      if (this.Be !== 0) {
+        this.Ye.dispose(false);
+        this.Je = [];
+        this.Xe = [];
+        this.Be = 0;
       }
-      if (this.Je && !this.Be[0]) {
-        this.Be[0] = runWithOwner((this.Ze[0] = createOwner()), this.Je);
+      if (this.it && !this.Xe[0]) {
+        this.Xe[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
       }
       return;
     }
     const n = t + e;
-    const i = this.et + this.$e;
-    if (this.$e === 0 && this.Ze[0]) this.Ze[0].dispose();
-    for (let e = n; e < i; e++) this.Ze[e - this.et].dispose();
-    if (this.et < t) {
-      let e = this.et;
-      while (e < t && e < this.$e) this.Ze[e++].dispose();
-      this.Ze.splice(0, t - this.et);
-      this.Be.splice(0, t - this.et);
-    } else if (this.et > t) {
-      let n = i - this.et - 1;
-      let r = this.et - t;
-      this.Ze.length = this.Be.length = e;
+    const i = this.rt + this.Be;
+    if (this.Be === 0 && this.Je[0]) this.Je[0].dispose();
+    for (let e = n; e < i; e++) this.Je[e - this.rt].dispose();
+    if (this.rt < t) {
+      let e = this.rt;
+      while (e < t && e < this.Be) this.Je[e++].dispose();
+      this.Je.splice(0, t - this.rt);
+      this.Xe.splice(0, t - this.rt);
+    } else if (this.rt > t) {
+      let n = i - this.rt - 1;
+      let r = this.rt - t;
+      this.Je.length = this.Xe.length = e;
       while (n >= r) {
-        this.Ze[n] = this.Ze[n - r];
-        this.Be[n] = this.Be[n - r];
+        this.Je[n] = this.Je[n - r];
+        this.Xe[n] = this.Xe[n - r];
         n--;
       }
       for (let e = 0; e < r; e++) {
-        this.Be[e] = runWithOwner((this.Ze[e] = createOwner()), () => this.Ye(e + t));
+        this.Xe[e] = runWithOwner((this.Je[e] = createOwner()), () => this.ze(e + t));
       }
     }
     for (let e = i; e < n; e++) {
-      this.Be[e - t] = runWithOwner((this.Ze[e - t] = createOwner()), () => this.Ye(e));
+      this.Xe[e - t] = runWithOwner((this.Je[e - t] = createOwner()), () => this.ze(e));
     }
-    this.Be = this.Be.slice(0, e);
-    this.et = t;
-    this.$e = e;
+    this.Xe = this.Xe.slice(0, e);
+    this.rt = t;
+    this.Be = e;
   });
-  return this.Be;
+  return this.Xe;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, { lazy: true });
-  n.he = (e, t) => {
-    const i = e !== undefined ? e : n.Ee;
-    const r = t !== undefined ? t : n.q;
-    n.Ee &= ~n.it;
-    n.ce.notify(n, n.it, i, r);
+  n.ge = (e, t) => {
+    const i = e !== undefined ? e : n.Se;
+    const r = t !== undefined ? t : n.le;
+    n.Se &= ~n.ut;
+    n.F.notify(n, n.ut, i, r);
   };
-  n.it = t;
-  n.Pe = true;
+  n.ut = t;
+  n.xe = true;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.ce;
-  r.addChild((e.ce = n));
-  onCleanup(() => r.removeChild(e.ce));
+  const r = e.F;
+  r.addChild((e.F = n));
+  cleanup(() => r.removeChild(e.F));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
@@ -2780,57 +2978,61 @@ function createBoundChildren(e, t, n, i) {
 }
 const ON_INIT = Symbol();
 class CollectionQueue extends Queue {
-  rt;
-  ot = new Set();
-  st = signal(false, { pureWrite: true, Qe: true });
-  ut = false;
   ct;
-  lt = ON_INIT;
+  ft = new Set();
+  lt = signal(false, { pureWrite: true, He: true });
+  Et = false;
+  Tt;
+  dt = ON_INIT;
   constructor(e) {
     super();
-    this.rt = e;
+    this.ct = e;
   }
   run(e) {
-    if (!e || read(this.st)) return;
+    if (!e || read(this.lt)) return;
     return super.run(e);
   }
   notify(e, t, n, i) {
-    if (!(t & this.rt)) return super.notify(e, t, n, i);
-    if (this.ut && this.ct) {
+    if (!(t & this.ct)) return super.notify(e, t, n, i);
+    if (this.Et && this.Tt) {
       const e = untrack(() => {
         try {
-          return this.ct();
+          return this.Tt();
         } catch {
           return ON_INIT;
         }
       });
-      if (e !== this.lt) {
-        this.lt = e;
-        this.ut = false;
-        this.ot.clear();
+      if (e !== this.dt) {
+        this.dt = e;
+        this.Et = false;
+        this.ft.clear();
       }
     }
-    if (this.rt & STATUS_PENDING && this.ut) return super.notify(e, t, n, i);
-    if (n & this.rt) {
-      const t = i?.source || e.q?.source;
+    if (this.ct & STATUS_PENDING && this.Et) return super.notify(e, t, n, i);
+    if (this.ct & STATUS_PENDING && n & STATUS_ERROR) {
+      return super.notify(e, STATUS_ERROR, n, i);
+    }
+    if (n & this.ct) {
+      const t = i?.source || e.le?.source;
       if (t) {
-        const e = this.ot.size === 0;
-        this.ot.add(t);
-        if (e) setSignal(this.st, true);
+        const e = this.ft.size === 0;
+        this.ft.add(t);
+        if (e) setSignal(this.lt, true);
       }
     }
-    t &= ~this.rt;
+    t &= ~this.ct;
     return t ? super.notify(e, t, n, i) : true;
   }
   checkSources() {
-    for (const e of this.ot) {
-      if (!(e.Ee & this.rt)) this.ot.delete(e);
+    for (const e of this.ft) {
+      if (!(e.Se & this.ct) && !(this.ct & STATUS_ERROR && e.Se & STATUS_PENDING))
+        this.ft.delete(e);
     }
-    if (!this.ot.size) {
-      setSignal(this.st, false);
-      if (this.ct) {
+    if (!this.ft.size) {
+      setSignal(this.lt, false);
+      if (this.Tt) {
         try {
-          this.lt = untrack(() => this.ct());
+          this.dt = untrack(() => this.Tt());
         } catch {}
       }
     }
@@ -2839,13 +3041,13 @@ class CollectionQueue extends Queue {
 function createCollectionBoundary(e, t, n, i) {
   const r = createOwner();
   const o = new CollectionQueue(e);
-  if (i) o.ct = i;
+  if (i) o.Tt = i;
   const s = createBoundChildren(r, t, o, e);
   const u = computed(() => {
-    if (!read(o.st)) {
+    if (!read(o.lt)) {
       const e = read(s);
-      if (!untrack(() => read(o.st))) {
-        o.ut = true;
+      if (!untrack(() => read(o.lt))) {
+        o.Et = true;
         return e;
       }
     }
@@ -2858,10 +3060,10 @@ function createLoadingBoundary(e, t, n) {
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.ot.values().next().value;
-    const i = n.q?.cause ?? n.q;
+    let n = e.ft.values().next().value;
+    const i = n.le?.cause ?? n.le;
     return t(i, () => {
-      for (const t of e.ot) recompute(t);
+      for (const t of e.ft) recompute(t);
       schedule();
     });
   });