@solidjs/signals 0.9.0 → 0.9.2

package/dist/prod.js

@@ -40,56 +40,56 @@ function actualInsertIntoHeap(e, t) {
   if (r === undefined) t.l[i] = e;
   else {
     const t = r.T;
-    t.h = e;
+    t.R = e;
     e.T = t;
     r.T = e;
   }
-  if (i > t.R) t.R = i;
+  if (i > t.h) t.h = i;
 }
 function insertIntoHeap(e, t) {
-  let n = e._;
+  let n = e.S;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
   if (n & REACTIVE_CHECK) {
-    e._ = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else e._ = n | REACTIVE_IN_HEAP;
+    e.S = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e.S = n | REACTIVE_IN_HEAP;
   if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e._;
+  let n = e.S;
   if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
-  e._ = n | REACTIVE_IN_HEAP_HEIGHT;
+  e.S = n | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e._;
+  const n = e.S;
   if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  e._ = n & -25;
+  e.S = n & -25;
   const i = e.o;
   if (e.T === e) t.l[i] = undefined;
   else {
-    const n = e.h;
+    const n = e.R;
     const r = t.l[i];
     const s = n ?? r;
     if (e === r) t.l[i] = n;
-    else e.T.h = n;
+    else e.T.R = n;
     s.T = e.T;
   }
   e.T = e;
-  e.h = undefined;
+  e.R = undefined;
 }
 function markHeap(e) {
-  if (e.S) return;
-  e.S = true;
-  for (let t = 0; t <= e.R; t++) {
-    for (let n = e.l[t]; n !== undefined; n = n.h) {
-      if (n._ & REACTIVE_IN_HEAP) markNode(n);
+  if (e._) return;
+  e._ = true;
+  for (let t = 0; t <= e.h; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.R) {
+      if (n.S & REACTIVE_IN_HEAP) markNode(n);
     }
   }
 }
 function markNode(e, t = REACTIVE_DIRTY) {
-  const n = e._;
+  const n = e.S;
   if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-  e._ = (n & -4) | t;
+  e.S = (n & -4) | t;
   for (let t = e.O; t !== null; t = t.p) {
     markNode(t.A, REACTIVE_CHECK);
   }
@@ -102,24 +102,24 @@ function markNode(e, t = REACTIVE_DIRTY) {
   }
 }
 function runHeap(e, t) {
-  e.S = false;
-  for (e.C = 0; e.C <= e.R; e.C++) {
+  e._ = false;
+  for (e.C = 0; e.C <= e.h; e.C++) {
     let n = e.l[e.C];
     while (n !== undefined) {
-      if (n._ & REACTIVE_IN_HEAP) t(n);
+      if (n.S & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
       n = e.l[e.C];
     }
   }
-  e.R = 0;
+  e.h = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
   let n = e.o;
   for (let t = e.D; t; t = t.P) {
     const e = t.V;
-    const i = e.U || e;
-    if (i.m && i.o >= n) n = i.o + 1;
+    const i = e.m || e;
+    if (i.U && i.o >= n) n = i.o + 1;
   }
   if (e.o !== n) {
     e.o = n;
@@ -129,8 +129,9 @@ function adjustHeight(e, t) {
   }
 }
 const transitions = new Set();
-const dirtyQueue = { l: new Array(2e3).fill(undefined), S: false, C: 0, R: 0 };
-const zombieQueue = { l: new Array(2e3).fill(undefined), S: false, C: 0, R: 0 };
+let optimisticRun = false;
+const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, h: 0 };
+const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, C: 0, h: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
@@ -200,40 +201,34 @@ class Queue {
 class GlobalQueue extends Queue {
   k = false;
   $ = [];
-  static L;
+  L = [];
   static F;
+  static W;
   flush() {
     if (this.k) return;
     this.k = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.L);
+      runHeap(dirtyQueue, GlobalQueue.F);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, GlobalQueue.L);
+          let e = activeTransition;
+          runHeap(zombieQueue, GlobalQueue.F);
           this.$ = [];
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
-          runPending(activeTransition.pendingNodes, true);
+          runTransitionPending(activeTransition.pendingNodes, true);
           activeTransition = null;
+          runOptimistic(e);
           return;
         }
         this.$.push(...activeTransition.pendingNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        if (runPending(this.$, false)) runHeap(dirtyQueue, GlobalQueue.L);
-      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.L);
-      for (let e = 0; e < this.$.length; e++) {
-        const t = this.$[e];
-        if (t.W !== NOT_PENDING) {
-          t.j = t.W;
-          t.W = NOT_PENDING;
-          if (t.K) t.M = true;
-        }
-        if (t.m) GlobalQueue.F(t, false, true);
-      }
-      this.$.length = 0;
+        runTransitionPending(this.$, false);
+      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.F);
+      runOptimistic();
       clock++;
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -245,8 +240,8 @@ class GlobalQueue extends Queue {
   notify(e, t, n) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(e.Y.cause)) {
-          activeTransition.asyncNodes.push(e.Y.cause);
+        if (activeTransition && !activeTransition.asyncNodes.includes(e.j.cause)) {
+          activeTransition.asyncNodes.push(e.j.cause);
           schedule();
         }
       }
@@ -257,40 +252,78 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = e.B ?? {
+      activeTransition = e.K ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { G: [[], []], H: [] }
+        optimisticNodes: [],
+        queueStash: { G: [[], []], H: [] },
+        done: false
       };
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
     for (let e = 0; e < this.$.length; e++) {
       const t = this.$[e];
-      t.B = activeTransition;
+      t.K = activeTransition;
       activeTransition.pendingNodes.push(t);
     }
+    for (let e = 0; e < this.L.length; e++) {
+      const t = this.L[e];
+      t.K = activeTransition;
+      activeTransition.optimisticNodes.push(t);
+    }
     this.$ = activeTransition.pendingNodes;
+    this.L = activeTransition.optimisticNodes;
+  }
+}
+function notifySubs(e) {
+  for (let t = e.O; t !== null; t = t.p) {
+    const e = t.A.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (e.C > t.A.o) e.C = t.A.o;
+    insertIntoHeap(t.A, e);
   }
 }
-function runPending(e, t) {
-  let n = false;
-  const i = e.slice();
-  for (let e = 0; e < i.length; e++) {
-    const r = i[e];
-    r.B = activeTransition;
-    if (r.X) {
-      r.X.q(t);
-      n = true;
+function runOptimistic(e = null) {
+  let t = !e;
+  const n = globalQueue.L;
+  optimisticRun = true;
+  for (let t = 0; t < n.length; t++) {
+    const i = n[t];
+    if (!e && (!i.K || i.K.done) && i.M !== NOT_PENDING) {
+      i.Y = i.M;
+      i.M = NOT_PENDING;
     }
-    if (r.Z && r.Z.W !== NOT_PENDING) {
-      r.Z.q(r.Z.W);
-      r.Z.W = NOT_PENDING;
-      n = true;
+    i.K = e;
+    notifySubs(i);
+  }
+  globalQueue.L = [];
+  if (dirtyQueue.h >= dirtyQueue.C) {
+    t = true;
+    runHeap(dirtyQueue, GlobalQueue.F);
+  }
+  optimisticRun = false;
+  t && runPending(globalQueue.$);
+}
+function runPending(e) {
+  for (let t = 0; t < e.length; t++) {
+    const n = e[t];
+    if (n.M !== NOT_PENDING) {
+      n.Y = n.M;
+      n.M = NOT_PENDING;
+      if (n.B) n.X = true;
     }
+    if (n.U) GlobalQueue.W(n, false, true);
+  }
+  e.length = 0;
+}
+function runTransitionPending(e, t) {
+  const n = e.slice();
+  for (let e = 0; e < n.length; e++) {
+    const i = n[e];
+    i.K = activeTransition;
+    if (i.q) i.q.Z(t);
   }
-  return n;
 }
 const globalQueue = new GlobalQueue();
 function flush() {
@@ -302,6 +335,7 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
+  if (e.done) return true;
   let t = true;
   for (let n = 0; n < e.asyncNodes.length; n++) {
     if (e.asyncNodes[n].J & STATUS_PENDING) {
@@ -309,35 +343,29 @@ function transitionComplete(e) {
       break;
     }
   }
+  t && (e.done = true);
   return t;
 }
 function runInTransition(e, t) {
   const n = activeTransition;
-  activeTransition = e.B;
+  activeTransition = e.K;
   t(e);
   activeTransition = n;
 }
-GlobalQueue.L = recompute;
-GlobalQueue.F = disposeChildren;
+GlobalQueue.F = recompute;
+GlobalQueue.W = disposeChildren;
 let tracking = false;
 let stale = false;
 let pendingValueCheck = false;
 let pendingCheck = null;
 let refreshing = false;
 let context = null;
-function notifySubs(e) {
-  for (let t = e.O; t !== null; t = t.p) {
-    const e = t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (e.C > t.A.o) e.C = t.A.o;
-    insertIntoHeap(t.A, e);
-  }
-}
 function recompute(e, t = false) {
-  const n = e.K && e.B != activeTransition;
+  const n = e.B && e.K != activeTransition;
   if (!t) {
-    if (e.B && activeTransition !== e.B && !n) globalQueue.initTransition(e);
-    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.B) disposeChildren(e);
+    if (e.K && activeTransition !== e.K && !n) globalQueue.initTransition(e);
+    deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (e.K) disposeChildren(e);
     else {
       markDisposal(e);
       e.ee = e.te;
@@ -349,17 +377,17 @@ function recompute(e, t = false) {
   const i = context;
   context = e;
   e.re = null;
-  e._ = REACTIVE_RECOMPUTING_DEPS;
+  e.S = REACTIVE_RECOMPUTING_DEPS;
   e.se = clock;
-  let r = e.W === NOT_PENDING ? e.j : e.W;
+  let r = e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M;
   let s = e.o;
   let o = e.J;
-  let u = e.Y;
+  let u = e.j;
   let l = tracking;
   setStatusFlags(e, STATUS_NONE | (o & STATUS_UNINITIALIZED));
   tracking = true;
   try {
-    r = handleAsync(e, e.m(r));
+    r = handleAsync(e, e.U(r));
     e.J &= ~STATUS_UNINITIALIZED;
   } catch (t) {
     if (t instanceof NotReadyError) {
@@ -369,7 +397,7 @@ function recompute(e, t = false) {
   } finally {
     tracking = l;
   }
-  e._ = REACTIVE_NONE;
+  e.S = REACTIVE_NONE;
   context = i;
   if (!(e.J & STATUS_PENDING)) {
     const t = e.re;
@@ -382,45 +410,42 @@ function recompute(e, t = false) {
       else e.D = null;
     }
   }
-  const c = !e.oe || !e.oe(e.W === NOT_PENDING || e.ue || n ? e.j : e.W, r);
-  const a = e.J !== o || e.Y !== u;
+  const c = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe || n ? e.Y : e.M, r);
+  const a = e.J !== o || e.j !== u;
   e.le?.(a, o);
   if (c || a) {
     if (c) {
-      if (t || e.ue || n) e.j = r;
-      else e.W = r;
-      if (e.Z) e.Z.W = r;
-    }
-    for (let t = e.O; t !== null; t = t.p) {
-      const n = t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-      if (t.A.o < e.o && n.C > t.A.o) n.C = t.A.o;
-      insertIntoHeap(t.A, n);
+      if (t || e.oe || n) e.Y = r;
+      else e.M = r;
+      if (e.ce) setSignal(e.ce, r);
     }
+    (!e.oe || optimisticRun) && notifySubs(e);
   } else if (e.o != s) {
     for (let t = e.O; t !== null; t = t.p) {
-      insertIntoHeapHeight(t.A, t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      insertIntoHeapHeight(t.A, t.A.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
-  if ((!t || e.J & STATUS_PENDING) && !e.ue && !e.B) globalQueue.$.push(e);
-  if (e.B && n) runInTransition(e, recompute);
+  e.oe && !optimisticRun && globalQueue.L.push(e);
+  (!t || e.J & STATUS_PENDING) && !e.K && globalQueue.$.push(e);
+  e.K && n && runInTransition(e, recompute);
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
   const r = i && t instanceof Promise;
   const s = i && untrack(() => t[Symbol.asyncIterator]);
   if (!r && !s) {
-    e.ce = null;
+    e.ae = null;
     return t;
   }
-  e.ce = t;
+  e.ae = t;
   if (r) {
     t.then(i => {
-      if (e.ce !== t) return;
+      if (e.ae !== t) return;
       globalQueue.initTransition(e);
       n?.(i) ?? setSignal(e, () => i);
       flush();
     }).catch(n => {
-      if (e.ce !== t) return;
+      if (e.ae !== t) return;
       globalQueue.initTransition(e);
       setStatusFlags(e, STATUS_ERROR, n);
       e.se = clock;
@@ -432,13 +457,13 @@ function handleAsync(e, t, n) {
     (async () => {
       try {
         for await (let i of t) {
-          if (e.ce !== t) return;
+          if (e.ae !== t) return;
           globalQueue.initTransition(e);
           n?.(i) ?? setSignal(e, () => i);
           flush();
         }
       } catch (n) {
-        if (e.ce !== t) return;
+        if (e.ae !== t) return;
         globalQueue.initTransition(e);
         setStatusFlags(e, STATUS_ERROR, n);
         e.se = clock;
@@ -452,42 +477,42 @@ function handleAsync(e, t, n) {
   throw new NotReadyError(context);
 }
 function updateIfNecessary(e) {
-  if (e._ & REACTIVE_CHECK) {
+  if (e.S & REACTIVE_CHECK) {
     for (let t = e.D; t; t = t.P) {
       const n = t.V;
-      const i = n.U || n;
-      if (i.m) {
+      const i = n.m || n;
+      if (i.U) {
         updateIfNecessary(i);
       }
-      if (e._ & REACTIVE_DIRTY) {
+      if (e.S & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (e._ & REACTIVE_DIRTY) {
+  if (e.S & REACTIVE_DIRTY) {
     recompute(e);
   }
-  e._ = REACTIVE_NONE;
+  e.S = REACTIVE_NONE;
 }
 function unlinkSubs(e) {
   const t = e.V;
   const n = e.P;
   const i = e.p;
-  const r = e.ae;
-  if (i !== null) i.ae = r;
-  else t.fe = r;
+  const r = e.fe;
+  if (i !== null) i.fe = r;
+  else t.Ee = r;
   if (r !== null) r.p = i;
   else {
     t.O = i;
     if (i === null) {
-      t.Ee?.();
-      t.m && !t.de && unobserved(t);
+      t.de?.();
+      t.U && !t.Te && unobserved(t);
     }
   }
   return n;
 }
 function unobserved(e) {
-  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
   let t = e.D;
   while (t !== null) {
     t = unlinkSubs(t);
@@ -499,7 +524,7 @@ function link(e, t) {
   const n = t.re;
   if (n !== null && n.V === e) return;
   let i = null;
-  const r = t._ & REACTIVE_RECOMPUTING_DEPS;
+  const r = t.S & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
     i = n !== null ? n.P : t.D;
     if (i !== null && i.V === e) {
@@ -507,9 +532,9 @@ function link(e, t) {
       return;
     }
   }
-  const s = e.fe;
+  const s = e.Ee;
   if (s !== null && s.A === t && (!r || isValidLink(s, t))) return;
-  const o = (t.re = e.fe = { V: e, A: t, P: i, ae: s, p: null });
+  const o = (t.re = e.Ee = { V: e, A: t, P: i, fe: s, p: null });
   if (n !== null) n.P = o;
   else t.D = o;
   if (s !== null) s.p = o;
@@ -529,18 +554,18 @@ function isValidLink(e, t) {
 }
 function setStatusFlags(e, t, n = null) {
   e.J = t;
-  e.Y = n;
+  e.j = n;
 }
 function markDisposal(e) {
   let t = e.ie;
   while (t) {
-    t._ |= REACTIVE_ZOMBIE;
-    if (t._ & REACTIVE_IN_HEAP) {
+    t.S |= REACTIVE_ZOMBIE;
+    if (t.S & REACTIVE_IN_HEAP) {
       deleteFromHeap(t, dirtyQueue);
       insertIntoHeap(t, zombieQueue);
     }
     markDisposal(t);
-    t = t.Te;
+    t = t.Re;
   }
 }
 function dispose(e) {
@@ -553,14 +578,14 @@ function dispose(e) {
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e._ & REACTIVE_DISPOSED) return;
-  if (t) e._ = REACTIVE_DISPOSED;
+  if (e.S & REACTIVE_DISPOSED) return;
+  if (t) e.S = REACTIVE_DISPOSED;
   let i = n ? e.ne : e.ie;
   while (i) {
-    const e = i.Te;
+    const e = i.Re;
     if (i.D) {
       const e = i;
-      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      deleteFromHeap(e, e.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       let t = e.D;
       do {
         t = unlinkSubs(t);
@@ -575,7 +600,7 @@ function disposeChildren(e, t = false, n) {
     e.ne = null;
   } else {
     e.ie = null;
-    e.Te = null;
+    e.Re = null;
   }
   runDisposal(e, n);
 }
@@ -604,36 +629,36 @@ function formatId(e, t) {
 function computed(e, t, n) {
   const i = {
     id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    oe: n?.equals != null ? n.equals : isEqual,
-    Re: !!n?.pureWrite,
-    Ee: n?.unobserved,
+    ue: n?.equals != null ? n.equals : isEqual,
+    Se: !!n?.pureWrite,
+    de: n?.unobserved,
     te: null,
     _e: context?._e ?? globalQueue,
-    Se: context?.Se ?? defaultContext,
+    Oe: context?.Oe ?? defaultContext,
     he: 0,
-    m: e,
-    j: t,
+    U: e,
+    Y: t,
     o: 0,
     N: null,
-    h: undefined,
+    R: undefined,
     T: null,
     D: null,
     re: null,
     O: null,
-    fe: null,
+    Ee: null,
     i: context,
-    Te: null,
+    Re: null,
     ie: null,
-    _: REACTIVE_NONE,
+    S: REACTIVE_NONE,
     J: STATUS_UNINITIALIZED,
     se: clock,
-    W: NOT_PENDING,
+    M: NOT_PENDING,
     ee: null,
     ne: null,
-    ce: null,
-    B: null
+    ae: null,
+    K: null
   };
-  if (n?.Oe) Object.assign(i, n.Oe);
+  if (n?.pe) Object.assign(i, n.pe);
   i.T = i;
   const r = context?.t ? context.u : context;
   if (context) {
@@ -641,28 +666,28 @@ function computed(e, t, n) {
     if (e === null) {
       context.ie = i;
     } else {
-      i.Te = e;
+      i.Re = e;
       context.ie = i;
     }
   }
   if (r) i.o = r.o + 1;
-  recompute(i, true);
+  !n?.lazy && recompute(i, true);
   return i;
 }
 function signal(e, t, n = null) {
   const i = {
     id: t?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    oe: t?.equals != null ? t.equals : isEqual,
-    Re: !!t?.pureWrite,
-    Ee: t?.unobserved,
-    j: e,
+    ue: t?.equals != null ? t.equals : isEqual,
+    Se: !!t?.pureWrite,
+    de: t?.unobserved,
+    Y: e,
     O: null,
-    fe: null,
+    Ee: null,
     J: STATUS_NONE,
     se: clock,
-    U: n,
+    m: n,
     I: n?.N || null,
-    W: NOT_PENDING
+    M: NOT_PENDING
   };
   n && (n.N = i);
   return i;
@@ -682,13 +707,13 @@ function untrack(e) {
 function read(e) {
   let t = context;
   if (t?.t) t = t.u;
-  if (refreshing && e.m) recompute(e);
+  if (refreshing && e.U) recompute(e);
   if (t && tracking && !pendingCheck && !pendingValueCheck) {
-    if (e.m && e._ & REACTIVE_DISPOSED) recompute(e);
+    if (e.U && e.S & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    const n = e.U || e;
-    if (n.m) {
-      const i = e._ & REACTIVE_ZOMBIE;
+    const n = e.m || e;
+    if (n.U) {
+      const i = e.S & REACTIVE_ZOMBIE;
       if (n.o >= (i ? zombieQueue.C : dirtyQueue.C)) {
         markNode(t);
         markHeap(i ? zombieQueue : dirtyQueue);
@@ -701,33 +726,32 @@ function read(e) {
     }
   }
   if (pendingCheck) {
-    if (!e.X) {
-      e.X = signal(false);
-      e.X.ue = true;
-      e.X.q = t => setSignal(e.X, t);
+    if (!e.q) {
+      e.q = signal(false);
+      e.q.oe = true;
+      e.q.Z = t => setSignal(e.q, t);
     }
     const t = pendingCheck;
     pendingCheck = null;
-    t.j = read(e.X) || t.j;
+    t.Y = read(e.q) || t.Y;
     pendingCheck = t;
   }
   if (pendingValueCheck) {
-    if (!e.Z) {
-      e.Z = signal(e.j);
-      e.Z.ue = true;
-      e.Z.q = t => setSignal(e.Z, t);
+    if (!e.ce) {
+      e.ce = signal(e.Y);
+      e.ce.oe = true;
     }
     pendingValueCheck = false;
     try {
-      return read(e.Z);
+      return read(e.ce);
     } finally {
       pendingValueCheck = true;
     }
   }
   if (e.J & STATUS_PENDING && !pendingCheck) {
-    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.Y;
+    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.j;
     else if (t && stale) {
-      setStatusFlags(t, t.J | 1, e.Y);
+      setStatusFlags(t, t.J | 1, e.j);
     }
   }
   if (e.J & STATUS_ERROR) {
@@ -735,33 +759,33 @@ function read(e) {
       recompute(e, true);
       return read(e);
     } else {
-      throw e.Y;
+      throw e.j;
     }
   }
   return !t ||
-    e.ue ||
-    e.W === NOT_PENDING ||
-    (stale && !pendingCheck && e.B && activeTransition !== e.B)
-    ? e.j
-    : e.W;
+    e.oe ||
+    e.M === NOT_PENDING ||
+    (stale && !pendingCheck && (t.oe || (e.K && activeTransition !== e.K)))
+    ? e.Y
+    : e.M;
 }
 function setSignal(e, t) {
   if (typeof t === "function") {
-    t = t(e.W === NOT_PENDING ? e.j : e.W);
+    t = t(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M);
   }
-  const n = !e.oe || !e.oe(e.W === NOT_PENDING || e.ue ? e.j : e.W, t);
+  const n = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe ? e.Y : e.M, t);
   if (!n && !e.J) return t;
   if (n) {
-    if (e.ue) e.j = t;
+    if (e.oe) e.Y = t;
     else {
-      if (e.W === NOT_PENDING) globalQueue.$.push(e);
-      e.W = t;
+      if (e.M === NOT_PENDING) globalQueue.$.push(e);
+      e.M = t;
     }
-    if (e.Z) e.Z.W = t;
+    if (e.ce) setSignal(e.ce, t);
   }
   setStatusFlags(e, STATUS_NONE);
   e.se = clock;
-  notifySubs(e);
+  e.oe && !optimisticRun ? globalQueue.L.push(e) : notifySubs(e);
   schedule();
   return t;
 }
@@ -789,11 +813,11 @@ function createOwner(e) {
     t: true,
     u: t?.t ? t.u : t,
     ie: null,
-    Te: null,
+    Re: null,
     te: null,
     id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
     _e: t?._e ?? globalQueue,
-    Se: t?.Se || defaultContext,
+    Oe: t?.Oe || defaultContext,
     he: 0,
     ee: null,
     ne: null,
@@ -807,7 +831,7 @@ function createOwner(e) {
     if (e === null) {
       t.ie = n;
     } else {
-      n.Te = e;
+      n.Re = e;
       t.ie = n;
     }
   }
@@ -846,10 +870,10 @@ function pending(e) {
 }
 function isPending(e) {
   const t = pendingCheck;
-  pendingCheck = { j: false };
+  pendingCheck = { Y: false };
   try {
     staleValues(e);
-    return pendingCheck.j;
+    return pendingCheck.Y;
   } catch (e) {
     if (!(e instanceof NotReadyError)) return false;
     throw e;
@@ -880,7 +904,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.Se[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.Oe[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -890,10 +914,10 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.Se = { ...n.Se, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.Oe = { ...n.Oe, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.Se[e.id]);
+  return !isUndefined(t?.Oe[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
@@ -902,23 +926,23 @@ function effect(e, t, n, i, r) {
   let s = false;
   const o = computed(e, i, {
     ...r,
-    Oe: {
-      M: true,
-      pe: i,
-      Ae: t,
+    pe: {
+      X: true,
+      Ae: i,
+      ge: t,
       Ne: n,
       Ie: undefined,
-      K: r?.render ? EFFECT_RENDER : EFFECT_USER,
+      B: r?.render ? EFFECT_RENDER : EFFECT_USER,
       le(e, t) {
         if (s) {
           const n = this.J && this.J === t && e;
-          this.M = !(this.J & STATUS_ERROR) && !(this.J & STATUS_PENDING & ~t) && !n;
-          if (this.M) this._e.enqueue(this.K, runEffect.bind(this));
+          this.X = !(this.J & STATUS_ERROR) && !(this.J & STATUS_PENDING & ~t) && !n;
+          if (this.X) this._e.enqueue(this.B, runEffect.bind(this));
         }
         if (this.J & STATUS_ERROR) {
-          let e = this.Y;
+          let e = this.j;
           this._e.notify(this, STATUS_PENDING, 0);
-          if (this.K === EFFECT_USER) {
+          if (this.B === EFFECT_USER) {
             try {
               return this.Ne
                 ? this.Ne(e, () => {
@@ -931,30 +955,30 @@ function effect(e, t, n, i, r) {
             }
           }
           if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-        } else if (this.K === EFFECT_RENDER) {
+        } else if (this.B === EFFECT_RENDER) {
           this._e.notify(this, STATUS_PENDING | STATUS_ERROR, this.J);
         }
       }
     }
   });
   s = true;
-  if (o.K === EFFECT_RENDER) o.m = t => staleValues(() => e(t));
+  if (o.B === EFFECT_RENDER) o.U = t => staleValues(() => e(t));
   !r?.defer &&
     !(o.J & (STATUS_ERROR | STATUS_PENDING)) &&
-    (o.K === EFFECT_USER ? o._e.enqueue(o.K, runEffect.bind(o)) : runEffect.call(o));
+    (o.B === EFFECT_USER ? o._e.enqueue(o.B, runEffect.bind(o)) : runEffect.call(o));
   onCleanup(() => o.Ie?.());
 }
 function runEffect() {
-  if (!this.M || this._ & REACTIVE_DISPOSED) return;
+  if (!this.X || this.S & REACTIVE_DISPOSED) return;
   this.Ie?.();
   this.Ie = undefined;
   try {
-    this.Ie = this.Ae(this.j, this.pe);
+    this.Ie = this.ge(this.Y, this.Ae);
   } catch (e) {
     if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.pe = this.j;
-    this.M = false;
+    this.Ae = this.Y;
+    this.X = false;
   }
 }
 function createSignal(e, t, n) {
@@ -1014,7 +1038,30 @@ function resolve(e) {
   });
 }
 function createOptimistic(e, t, n) {
-  return {};
+  if (typeof e === "function") {
+    const i = computed(
+      t => {
+        let n = i || getOwner();
+        n.M = e(t);
+        return t;
+      },
+      t,
+      n
+    );
+    i.oe = true;
+    return [read.bind(null, i), setSignal.bind(null, i)];
+  }
+  const i = getOwner();
+  const r = i?.id != null;
+  const s = signal(e, r ? { id: getNextChildId(i), ...t } : t);
+  s.oe = true;
+  return [
+    read.bind(null, s),
+    t => {
+      s.M = e;
+      return setSignal(s, t);
+    }
+  ];
 }
 function onSettled(e) {
   let t;
@@ -1050,7 +1097,7 @@ function applyState(e, t, n, i) {
     let t = false;
     const l = getOverrideValue(s, o, u, "length");
     if (e.length && l && e[0] && n(e[0]) != null) {
-      let c, a, f, E, d, T, h, R;
+      let c, a, f, E, d, T, R, h;
       for (
         f = 0, E = Math.min(l, e.length);
         f < E && ((T = getOverrideValue(s, o, u, f)) === e[f] || (T && e[f] && n(T) === n(e[f])));
@@ -1058,8 +1105,8 @@ function applyState(e, t, n, i) {
       ) {
         applyState(e[f], wrap(T, r), n, i);
       }
-      const _ = new Array(e.length),
-        S = new Map();
+      const S = new Array(e.length),
+        _ = new Map();
       for (
         E = l - 1, d = e.length - 1;
         E >= f &&
@@ -1067,7 +1114,7 @@ function applyState(e, t, n, i) {
         ((T = getOverrideValue(s, o, u, E)) === e[d] || (T && e[d] && n(T) === n(e[d])));
         E--, d--
       ) {
-        _[d] = T;
+        S[d] = T;
       }
       if (f > d || f > E) {
         for (a = f; a <= d; a++) {
@@ -1076,7 +1123,7 @@ function applyState(e, t, n, i) {
         }
         for (; a < e.length; a++) {
           t = true;
-          const s = wrap(_[a], r);
+          const s = wrap(S[a], r);
           r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], s);
           applyState(e[a], s, n, i);
         }
@@ -1084,27 +1131,27 @@ function applyState(e, t, n, i) {
         l !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
         return;
       }
-      h = new Array(d + 1);
+      R = new Array(d + 1);
       for (a = d; a >= f; a--) {
         T = e[a];
-        R = T ? n(T) : T;
-        c = S.get(R);
-        h[a] = c === undefined ? -1 : c;
-        S.set(R, a);
+        h = T ? n(T) : T;
+        c = _.get(h);
+        R[a] = c === undefined ? -1 : c;
+        _.set(h, a);
       }
       for (c = f; c <= E; c++) {
         T = getOverrideValue(s, o, u, c);
-        R = T ? n(T) : T;
-        a = S.get(R);
+        h = T ? n(T) : T;
+        a = _.get(h);
         if (a !== undefined && a !== -1) {
-          _[a] = T;
-          a = h[a];
-          S.set(R, a);
+          S[a] = T;
+          a = R[a];
+          _.set(h, a);
         }
       }
       for (a = f; a < e.length; a++) {
-        if (a in _) {
-          const t = wrap(_[a], r);
+        if (a in S) {
+          const t = wrap(S[a], r);
           r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], t);
           applyState(e[a], t, n, i);
         } else r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
@@ -1279,7 +1326,7 @@ const storeTraps = {
       if (e && e.get) return e.get.call(n);
     }
     if (Writing?.has(n)) {
-      let n = r && (s || !o) ? (r.W !== NOT_PENDING ? r.W : r.j) : u[t];
+      let n = r && (s || !o) ? (r.M !== NOT_PENDING ? r.M : r.Y) : u[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
@@ -1639,68 +1686,68 @@ function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      ge: createOwner(),
-      ye: 0,
-      Ce: e,
-      De: [],
-      Pe: t,
-      we: [],
+      ye: createOwner(),
+      Ce: 0,
+      De: e,
+      Pe: [],
+      we: t,
       be: [],
-      Ve: i,
+      Ve: [],
+      me: i,
       Ue: i || n?.keyed === false ? [] : undefined,
-      me: t.length > 1 ? [] : undefined,
-      ke: n?.fallback
+      ke: t.length > 1 ? [] : undefined,
+      ve: n?.fallback
     })
   );
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.Ce() || [],
+  const e = this.De() || [],
     t = e.length;
   e[$TRACK];
-  runWithOwner(this.ge, () => {
+  runWithOwner(this.ye, () => {
     let n,
       i,
       r = this.Ue
         ? () => {
             this.Ue[i] = signal(e[i], pureOptions);
-            this.me && (this.me[i] = signal(i, pureOptions));
-            return this.Pe(
+            this.ke && (this.ke[i] = signal(i, pureOptions));
+            return this.we(
               read.bind(null, this.Ue[i]),
-              this.me ? read.bind(null, this.me[i]) : undefined
+              this.ke ? read.bind(null, this.ke[i]) : undefined
             );
           }
-        : this.me
+        : this.ke
           ? () => {
               const t = e[i];
-              this.me[i] = signal(i, pureOptions);
-              return this.Pe(() => t, read.bind(null, this.me[i]));
+              this.ke[i] = signal(i, pureOptions);
+              return this.we(() => t, read.bind(null, this.ke[i]));
             }
           : () => {
               const t = e[i];
-              return this.Pe(() => t);
+              return this.we(() => t);
             };
     if (t === 0) {
-      if (this.ye !== 0) {
-        this.ge.dispose(false);
+      if (this.Ce !== 0) {
+        this.ye.dispose(false);
+        this.Ve = [];
+        this.Pe = [];
         this.be = [];
-        this.De = [];
-        this.we = [];
-        this.ye = 0;
+        this.Ce = 0;
         this.Ue && (this.Ue = []);
-        this.me && (this.me = []);
+        this.ke && (this.ke = []);
       }
-      if (this.ke && !this.we[0]) {
-        this.we[0] = runWithOwner((this.be[0] = createOwner()), this.ke);
+      if (this.ve && !this.be[0]) {
+        this.be[0] = runWithOwner((this.Ve[0] = createOwner()), this.ve);
       }
-    } else if (this.ye === 0) {
-      if (this.be[0]) this.be[0].dispose();
-      this.we = new Array(t);
+    } else if (this.Ce === 0) {
+      if (this.Ve[0]) this.Ve[0].dispose();
+      this.be = new Array(t);
       for (i = 0; i < t; i++) {
-        this.De[i] = e[i];
-        this.we[i] = runWithOwner((this.be[i] = createOwner()), r);
+        this.Pe[i] = e[i];
+        this.be[i] = runWithOwner((this.Ve[i] = createOwner()), r);
       }
-      this.ye = t;
+      this.Ce = t;
     } else {
       let s,
         o,
@@ -1712,149 +1759,149 @@ function updateKeyedMap() {
         E = new Array(t),
         d = new Array(t),
         T = this.Ue ? new Array(t) : undefined,
-        h = this.me ? new Array(t) : undefined;
+        R = this.ke ? new Array(t) : undefined;
       for (
-        s = 0, o = Math.min(this.ye, t);
-        s < o && (this.De[s] === e[s] || (this.Ue && compare(this.Ve, this.De[s], e[s])));
+        s = 0, o = Math.min(this.Ce, t);
+        s < o && (this.Pe[s] === e[s] || (this.Ue && compare(this.me, this.Pe[s], e[s])));
         s++
       ) {
         if (this.Ue) setSignal(this.Ue[s], e[s]);
       }
       for (
-        o = this.ye - 1, u = t - 1;
+        o = this.Ce - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.De[o] === e[u] || (this.Ue && compare(this.Ve, this.De[o], e[u])));
+        (this.Pe[o] === e[u] || (this.Ue && compare(this.me, this.Pe[o], e[u])));
         o--, u--
       ) {
-        E[u] = this.we[o];
-        d[u] = this.be[o];
+        E[u] = this.be[o];
+        d[u] = this.Ve[o];
         T && (T[u] = this.Ue[o]);
-        h && (h[u] = this.me[o]);
+        R && (R[u] = this.ke[o]);
       }
       a = new Map();
       f = new Array(u + 1);
       for (i = u; i >= s; i--) {
         l = e[i];
-        c = this.Ve ? this.Ve(l) : l;
+        c = this.me ? this.me(l) : l;
         n = a.get(c);
         f[i] = n === undefined ? -1 : n;
         a.set(c, i);
       }
       for (n = s; n <= o; n++) {
-        l = this.De[n];
-        c = this.Ve ? this.Ve(l) : l;
+        l = this.Pe[n];
+        c = this.me ? this.me(l) : l;
         i = a.get(c);
         if (i !== undefined && i !== -1) {
-          E[i] = this.we[n];
-          d[i] = this.be[n];
+          E[i] = this.be[n];
+          d[i] = this.Ve[n];
           T && (T[i] = this.Ue[n]);
-          h && (h[i] = this.me[n]);
+          R && (R[i] = this.ke[n]);
           i = f[i];
           a.set(c, i);
-        } else this.be[n].dispose();
+        } else this.Ve[n].dispose();
       }
       for (i = s; i < t; i++) {
         if (i in E) {
-          this.we[i] = E[i];
-          this.be[i] = d[i];
+          this.be[i] = E[i];
+          this.Ve[i] = d[i];
           if (T) {
             this.Ue[i] = T[i];
             setSignal(this.Ue[i], e[i]);
           }
-          if (h) {
-            this.me[i] = h[i];
-            setSignal(this.me[i], i);
+          if (R) {
+            this.ke[i] = R[i];
+            setSignal(this.ke[i], i);
           }
         } else {
-          this.we[i] = runWithOwner((this.be[i] = createOwner()), r);
+          this.be[i] = runWithOwner((this.Ve[i] = createOwner()), r);
         }
       }
-      this.we = this.we.slice(0, (this.ye = t));
-      this.De = e.slice(0);
+      this.be = this.be.slice(0, (this.Ce = t));
+      this.Pe = e.slice(0);
     }
   });
-  return this.we;
+  return this.be;
 }
 function repeat(e, t, n) {
   return updateRepeat.bind({
-    ge: createOwner(),
-    ye: 0,
-    ve: 0,
-    xe: e,
-    Pe: t,
+    ye: createOwner(),
+    Ce: 0,
+    xe: 0,
+    Ge: e,
+    we: t,
+    Ve: [],
     be: [],
-    we: [],
-    Ge: n?.from,
-    ke: n?.fallback
+    He: n?.from,
+    ve: n?.fallback
   });
 }
 function updateRepeat() {
-  const e = this.xe();
-  const t = this.Ge?.() || 0;
-  runWithOwner(this.ge, () => {
+  const e = this.Ge();
+  const t = this.He?.() || 0;
+  runWithOwner(this.ye, () => {
     if (e === 0) {
-      if (this.ye !== 0) {
-        this.ge.dispose(false);
+      if (this.Ce !== 0) {
+        this.ye.dispose(false);
+        this.Ve = [];
         this.be = [];
-        this.we = [];
-        this.ye = 0;
+        this.Ce = 0;
       }
-      if (this.ke && !this.we[0]) {
-        this.we[0] = runWithOwner((this.be[0] = createOwner()), this.ke);
+      if (this.ve && !this.be[0]) {
+        this.be[0] = runWithOwner((this.Ve[0] = createOwner()), this.ve);
       }
       return;
     }
     const n = t + e;
-    const i = this.ve + this.ye;
-    if (this.ye === 0 && this.be[0]) this.be[0].dispose();
-    for (let e = n; e < i; e++) this.be[e - this.ve].dispose();
-    if (this.ve < t) {
-      let e = this.ve;
-      while (e < t && e < this.ye) this.be[e++].dispose();
-      this.be.splice(0, t - this.ve);
-      this.we.splice(0, t - this.ve);
-    } else if (this.ve > t) {
-      let n = i - this.ve - 1;
-      let r = this.ve - t;
-      this.be.length = this.we.length = e;
+    const i = this.xe + this.Ce;
+    if (this.Ce === 0 && this.Ve[0]) this.Ve[0].dispose();
+    for (let e = n; e < i; e++) this.Ve[e - this.xe].dispose();
+    if (this.xe < t) {
+      let e = this.xe;
+      while (e < t && e < this.Ce) this.Ve[e++].dispose();
+      this.Ve.splice(0, t - this.xe);
+      this.be.splice(0, t - this.xe);
+    } else if (this.xe > t) {
+      let n = i - this.xe - 1;
+      let r = this.xe - t;
+      this.Ve.length = this.be.length = e;
       while (n >= r) {
+        this.Ve[n] = this.Ve[n - r];
         this.be[n] = this.be[n - r];
-        this.we[n] = this.we[n - r];
         n--;
       }
       for (let e = 0; e < r; e++) {
-        this.we[e] = runWithOwner((this.be[e] = createOwner()), () => this.Pe(e + t));
+        this.be[e] = runWithOwner((this.Ve[e] = createOwner()), () => this.we(e + t));
       }
     }
     for (let e = i; e < n; e++) {
-      this.we[e - t] = runWithOwner((this.be[e - t] = createOwner()), () => this.Pe(e));
+      this.be[e - t] = runWithOwner((this.Ve[e - t] = createOwner()), () => this.we(e));
     }
-    this.we = this.we.slice(0, e);
-    this.ve = t;
-    this.ye = e;
+    this.be = this.be.slice(0, e);
+    this.xe = t;
+    this.Ce = e;
   });
-  return this.we;
+  return this.be;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, {
-    Oe: {
+    pe: {
       le() {
         let e = this.J;
-        this.J &= ~this.He;
-        if (this.He & STATUS_PENDING && !(this.J & STATUS_UNINITIALIZED)) {
+        this.J &= ~this.Qe;
+        if (this.Qe & STATUS_PENDING && !(this.J & STATUS_UNINITIALIZED)) {
           e &= ~STATUS_PENDING;
         }
-        this._e.notify(this, this.He, e);
+        this._e.notify(this, this.Qe, e);
       },
-      He: t
+      Qe: t
     }
   });
-  n.He = t;
-  n.de = true;
+  n.Qe = t;
+  n.Te = true;
   return n;
 }
 function createBoundChildren(e, t, n, i) {
@@ -1867,19 +1914,19 @@ function createBoundChildren(e, t, n, i) {
   });
 }
 class ConditionalQueue extends Queue {
-  Qe;
-  $e = new Set();
+  $e;
+  Le = new Set();
   $ = new Set();
   constructor(e) {
     super();
-    this.Qe = e;
+    this.$e = e;
   }
   run(e) {
-    if (!e || read(this.Qe)) return;
+    if (!e || read(this.$e)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (read(this.Qe)) {
+    if (read(this.$e)) {
       if (t & STATUS_PENDING) {
         if (n & STATUS_PENDING) {
           this.$.add(e);
@@ -1888,37 +1935,37 @@ class ConditionalQueue extends Queue {
       }
       if (t & STATUS_ERROR) {
         if (n & STATUS_ERROR) {
-          this.$e.add(e);
+          this.Le.add(e);
           t &= ~STATUS_ERROR;
-        } else if (this.$e.delete(e)) t &= ~STATUS_ERROR;
+        } else if (this.Le.delete(e)) t &= ~STATUS_ERROR;
       }
     }
     return t ? super.notify(e, t, n) : true;
   }
 }
 class CollectionQueue extends Queue {
-  Le;
-  be = new Set();
-  Qe = signal(false, { pureWrite: true });
-  Fe = false;
+  Fe;
+  Ve = new Set();
+  $e = signal(false, { pureWrite: true });
+  We = false;
   constructor(e) {
     super();
-    this.Le = e;
+    this.Fe = e;
   }
   run(e) {
-    if (!e || read(this.Qe)) return;
+    if (!e || read(this.$e)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (!(t & this.Le) || (this.Le & STATUS_PENDING && this.Fe)) return super.notify(e, t, n);
-    if (n & this.Le) {
-      this.be.add(e);
-      if (this.be.size === 1) setSignal(this.Qe, true);
-    } else if (this.be.size > 0) {
-      this.be.delete(e);
-      if (this.be.size === 0) setSignal(this.Qe, false);
-    }
-    t &= ~this.Le;
+    if (!(t & this.Fe) || (this.Fe & STATUS_PENDING && this.We)) return super.notify(e, t, n);
+    if (n & this.Fe) {
+      this.Ve.add(e);
+      if (this.Ve.size === 1) setSignal(this.$e, true);
+    } else if (this.Ve.size > 0) {
+      this.Ve.delete(e);
+      if (this.Ve.size === 0) setSignal(this.$e, false);
+    }
+    t &= ~this.Fe;
     return t ? super.notify(e, t, n) : true;
   }
 }
@@ -1932,25 +1979,25 @@ function createBoundary(e, t) {
   const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
   const r = createBoundChildren(n, e, i, 0);
   computed(() => {
-    const e = read(i.Qe);
-    r.He = e ? STATUS_ERROR | STATUS_PENDING : 0;
+    const e = read(i.$e);
+    r.Qe = e ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!e) {
       i.$.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
-      i.$e.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
+      i.Le.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
       i.$.clear();
-      i.$e.clear();
+      i.Le.clear();
     }
   });
-  return () => (read(i.Qe) ? undefined : read(r));
+  return () => (read(i.$e) ? undefined : read(r));
 }
 function createCollectionBoundary(e, t, n) {
   const i = createOwner();
   const r = new CollectionQueue(e);
   const s = createBoundChildren(i, t, r, e);
   const o = computed(() => {
-    if (!read(r.Qe)) {
+    if (!read(r.$e)) {
       const e = read(s);
-      if (!untrack(() => read(r.Qe))) r.Fe = true;
+      if (!untrack(() => read(r.$e))) r.We = true;
       return e;
     }
     return n(r);
@@ -1975,10 +2022,10 @@ function collectErrorSources(e, t) {
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.be.values().next().value;
-    return t(n.Y, () => {
+    let n = e.Ve.values().next().value;
+    return t(n.j, () => {
       const t = [];
-      for (const n of e.be) collectErrorSources(n, t);
+      for (const n of e.Ve) collectErrorSources(n, t);
       for (const e of t) recompute(e);
       schedule();
     });