@solidjs/signals 0.9.1 → 0.9.3

package/dist/prod.js

@@ -32,6 +32,7 @@ const EFFECT_USER = 2;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
+const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
   const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
   if (n >= e.o) e.o = n + 1;
@@ -40,56 +41,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 +103,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,15 +130,16 @@ 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;
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.k) queueMicrotask(flush);
+  if (!globalQueue.k) Promise.resolve().then(() => queueMicrotask(flush));
 }
 class Queue {
   i = null;
@@ -200,36 +202,36 @@ 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;
           runTransitionPending(activeTransition.pendingNodes, true);
           activeTransition = null;
+          runOptimistic(e);
           return;
         }
         this.$.push(...activeTransition.pendingNodes);
+        this.L !== activeTransition.optimisticNodes &&
+          this.L.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
         runTransitionPending(this.$, false);
-        dirtyQueue.R >= dirtyQueue.C && runHeap(dirtyQueue, GlobalQueue.L);
-      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.L);
-      runPending(this.$);
-      while (dirtyQueue.R >= dirtyQueue.C) {
-        runHeap(dirtyQueue, GlobalQueue.L);
-        runPending(this.$);
-      }
+      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.F);
+      runOptimistic();
       clock++;
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -241,8 +243,8 @@ class GlobalQueue extends Queue {
   notify(e, t, n) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(e.W.cause)) {
-          activeTransition.asyncNodes.push(e.W.cause);
+        if (activeTransition && !activeTransition.asyncNodes.includes(e.j.cause)) {
+          activeTransition.asyncNodes.push(e.j.cause);
           schedule();
         }
       }
@@ -253,33 +255,69 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = e.j ?? {
+      activeTransition = e?.K ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { G: [[], []], H: [] }
+        optimisticNodes: [],
+        actions: [],
+        queueStash: { G: [[], []], H: [] },
+        done: false
       };
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
     for (let e = 0; e < this.$.length; e++) {
       const t = this.$[e];
-      t.j = 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 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;
+    }
+    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.K !== NOT_PENDING) {
-      n.M = n.K;
-      n.K = NOT_PENDING;
-      if (n.Y) n.B = true;
+    if (n.M !== NOT_PENDING) {
+      n.Y = n.M;
+      n.M = NOT_PENDING;
+      if (n.B) n.X = true;
     }
-    if (n.X && n.X.K !== NOT_PENDING) n.X.q(n.X.K);
-    if (n.m) GlobalQueue.F(n, false, true);
+    if (n.U) GlobalQueue.W(n, false, true);
   }
   e.length = 0;
 }
@@ -287,12 +325,8 @@ function runTransitionPending(e, t) {
   const n = e.slice();
   for (let e = 0; e < n.length; e++) {
     const i = n[e];
-    i.j = activeTransition;
-    if (i.Z) i.Z.q(t);
-    if (i.X && i.X.K !== NOT_PENDING) {
-      i.X.q(i.X.K);
-      i.X.K = NOT_PENDING;
-    }
+    i.K = activeTransition;
+    if (i.q) i.q.Z(t);
   }
 }
 const globalQueue = new GlobalQueue();
@@ -305,6 +339,8 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
+  if (e.done) return true;
+  if (e.actions.length) return false;
   let t = true;
   for (let n = 0; n < e.asyncNodes.length; n++) {
     if (e.asyncNodes[n].J & STATUS_PENDING) {
@@ -312,35 +348,58 @@ function transitionComplete(e) {
       break;
     }
   }
+  t && (e.done = true);
   return t;
 }
 function runInTransition(e, t) {
   const n = activeTransition;
-  activeTransition = e.j;
-  t(e);
-  activeTransition = n;
+  try {
+    activeTransition = e;
+    return t();
+  } finally {
+    activeTransition = n;
+  }
+}
+function action(e) {
+  return (...t) => {
+    const n = e(...t);
+    globalQueue.initTransition();
+    let i = activeTransition;
+    i.actions.push(n);
+    const step = e => {
+      let t = n.next(e);
+      if (t instanceof Promise) return t.then(process);
+      process(t);
+    };
+    const process = e => {
+      if (e.done) {
+        i.actions.splice(i.actions.indexOf(n), 1);
+        activeTransition = i;
+        schedule();
+        flush();
+        return;
+      }
+      const t = e.value;
+      if (t instanceof Promise) return t.then(step);
+      runInTransition(i, () => step(t));
+    };
+    runInTransition(i, () => step());
+  };
 }
-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.Y && e.j != activeTransition;
+  const n = e.B && e.K != activeTransition;
   if (!t) {
-    if (e.j && activeTransition !== e.j && !n) globalQueue.initTransition(e);
-    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.j) 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;
@@ -352,17 +411,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.K === NOT_PENDING ? e.M : e.K;
+  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.W;
+  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) {
@@ -372,7 +431,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;
@@ -385,45 +444,42 @@ function recompute(e, t = false) {
       else e.D = null;
     }
   }
-  const c = !e.oe || !e.oe(e.K === NOT_PENDING || e.ue || n ? e.M : e.K, r);
-  const a = e.J !== o || e.W !== u;
+  const c = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) || 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.M = r;
-      else e.K = r;
-      if (e.X) e.X.K = 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.j) globalQueue.$.push(e);
-  if (e.j && 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.K, () => recompute(e));
 }
 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;
@@ -435,13 +491,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;
@@ -455,42 +511,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);
@@ -502,7 +558,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) {
@@ -510,9 +566,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;
@@ -532,18 +588,18 @@ function isValidLink(e, t) {
 }
 function setStatusFlags(e, t, n = null) {
   e.J = t;
-  e.W = 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) {
@@ -556,14 +612,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);
@@ -578,7 +634,7 @@ function disposeChildren(e, t = false, n) {
     e.ne = null;
   } else {
     e.ie = null;
-    e.Te = null;
+    e.Re = null;
   }
   runDisposal(e, n);
 }
@@ -607,36 +663,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,
-    M: 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,
-    K: NOT_PENDING,
+    M: NOT_PENDING,
     ee: null,
     ne: null,
-    ce: null,
-    j: 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) {
@@ -644,28 +700,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,
-    M: 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,
-    K: NOT_PENDING
+    M: NOT_PENDING
   };
   n && (n.N = i);
   return i;
@@ -685,13 +741,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);
@@ -703,34 +759,34 @@ function read(e) {
       }
     }
   }
-  if (pendingCheck) {
-    if (!e.Z) {
-      e.Z = signal(false);
-      e.Z.ue = true;
-      e.Z.q = t => setSignal(e.Z, t);
-    }
-    const t = pendingCheck;
-    pendingCheck = null;
-    t.M = read(e.Z) || t.M;
-    pendingCheck = t;
-  }
   if (pendingValueCheck) {
-    if (!e.X) {
-      e.X = signal(e.M);
-      e.X.ue = true;
-      e.X.q = t => setSignal(e.X, t);
+    if (!e.ce) {
+      e.ce = signal(e.Y);
+      e.ce.oe = true;
     }
     pendingValueCheck = false;
     try {
-      return read(e.X);
+      return read(e.ce);
     } finally {
       pendingValueCheck = true;
     }
   }
-  if (e.J & STATUS_PENDING && !pendingCheck) {
-    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.W;
+  const n = e.m || e;
+  if (pendingCheck) {
+    if (!n.q) {
+      n.q = signal(false);
+      n.q.oe = true;
+      n.q.Z = e => setSignal(n.q, e);
+    }
+    const e = pendingCheck;
+    pendingCheck = null;
+    e.Y = read(n.q) || e.Y;
+    pendingCheck = e;
+  }
+  if (!pendingCheck && n.J & STATUS_PENDING) {
+    if ((t && !stale) || n.J & STATUS_UNINITIALIZED || e.m) throw n.j;
     else if (t && stale) {
-      setStatusFlags(t, t.J | 1, e.W);
+      setStatusFlags(t, t.J | STATUS_PENDING, n.j);
     }
   }
   if (e.J & STATUS_ERROR) {
@@ -738,33 +794,33 @@ function read(e) {
       recompute(e, true);
       return read(e);
     } else {
-      throw e.W;
+      throw e.j;
     }
   }
   return !t ||
-    e.ue ||
-    e.K === NOT_PENDING ||
-    (stale && !pendingCheck && e.j && activeTransition !== e.j)
-    ? e.M
-    : e.K;
+    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.K === NOT_PENDING ? e.M : e.K);
+    t = t(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M);
   }
-  const n = !e.oe || !e.oe(e.K === NOT_PENDING || e.ue ? e.M : e.K, t);
+  const n = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M, t);
   if (!n && !e.J) return t;
   if (n) {
-    if (e.ue) e.M = t;
+    if (e.oe) e.Y = t;
     else {
-      if (e.K === NOT_PENDING) globalQueue.$.push(e);
-      e.K = t;
+      if (e.M === NOT_PENDING) globalQueue.$.push(e);
+      e.M = t;
     }
-    if (e.X) e.X.K = 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;
 }
@@ -792,11 +848,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,
@@ -810,7 +866,7 @@ function createOwner(e) {
     if (e === null) {
       t.ie = n;
     } else {
-      n.Te = e;
+      n.Re = e;
       t.ie = n;
     }
   }
@@ -849,10 +905,10 @@ function pending(e) {
 }
 function isPending(e) {
   const t = pendingCheck;
-  pendingCheck = { M: false };
+  pendingCheck = { Y: false };
   try {
     staleValues(e);
-    return pendingCheck.M;
+    return pendingCheck.Y;
   } catch (e) {
     if (!(e instanceof NotReadyError)) return false;
     throw e;
@@ -864,6 +920,10 @@ function refresh(e) {
   let t = refreshing;
   refreshing = true;
   try {
+    if (typeof e !== "function") {
+      recompute(e[$REFRESH]);
+      return e;
+    }
     return untrack(e);
   } finally {
     refreshing = t;
@@ -883,7 +943,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();
   }
@@ -893,10 +953,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";
@@ -905,23 +965,23 @@ function effect(e, t, n, i, r) {
   let s = false;
   const o = computed(e, i, {
     ...r,
-    Oe: {
-      B: true,
-      pe: i,
-      Ae: t,
+    pe: {
+      X: true,
+      Ae: i,
+      ge: t,
       Ne: n,
       Ie: undefined,
-      Y: 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.B = !(this.J & STATUS_ERROR) && !(this.J & STATUS_PENDING & ~t) && !n;
-          if (this.B) this._e.enqueue(this.Y, 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.W;
+          let e = this.j;
           this._e.notify(this, STATUS_PENDING, 0);
-          if (this.Y === EFFECT_USER) {
+          if (this.B === EFFECT_USER) {
             try {
               return this.Ne
                 ? this.Ne(e, () => {
@@ -934,30 +994,30 @@ function effect(e, t, n, i, r) {
             }
           }
           if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-        } else if (this.Y === EFFECT_RENDER) {
+        } else if (this.B === EFFECT_RENDER) {
           this._e.notify(this, STATUS_PENDING | STATUS_ERROR, this.J);
         }
       }
     }
   });
   s = true;
-  if (o.Y === 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.Y === EFFECT_USER ? o._e.enqueue(o.Y, 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.B || this._ & REACTIVE_DISPOSED) return;
+  if (!this.X || this.S & REACTIVE_DISPOSED) return;
   this.Ie?.();
   this.Ie = undefined;
   try {
-    this.Ie = this.Ae(this.M, 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.M;
-    this.B = false;
+    this.Ae = this.Y;
+    this.X = false;
   }
 }
 function createSignal(e, t, n) {
@@ -1017,7 +1077,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;
@@ -1032,7 +1115,7 @@ function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
 }
 function getOverrideValue(e, t, n, i) {
-  return n && i in n ? read(n[i]) : t && i in t ? t[i] : e[i];
+  return t && i in t ? t[i] : e[i];
 }
 function getAllKeys(e, t, n) {
   const i = getKeys(e, t);
@@ -1053,7 +1136,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])));
@@ -1061,8 +1144,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 &&
@@ -1070,7 +1153,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++) {
@@ -1079,7 +1162,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);
         }
@@ -1087,36 +1170,38 @@ 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));
       }
       if (f < e.length) t = true;
-    } else if (l && e.length) {
+    } else if (e.length) {
       for (let t = 0, l = e.length; t < l; t++) {
         const l = getOverrideValue(s, o, u, t);
-        isWrappable(l) && applyState(e[t], wrap(l, r), n, i);
+        isWrappable(l)
+          ? applyState(e[t], wrap(l, r), n, i)
+          : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
       }
     }
     if (l !== e.length) {
@@ -1162,34 +1247,70 @@ function reconcile(e, t, n = false) {
 function createProjectionInternal(e, t = {}, n) {
   let i;
   const r = new WeakMap();
+  const wrapper = e => {
+    e[STORE_WRAP] = wrapProjection;
+    e[STORE_LOOKUP] = r;
+    Object.defineProperty(e, STORE_FIREWALL, {
+      get() {
+        return i;
+      },
+      configurable: true
+    });
+  };
   const wrapProjection = e => {
     if (r.has(e)) return r.get(e);
     if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-    const t = createStoreProxy(e, storeTraps, {
-      [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: r,
-      [STORE_FIREWALL]() {
-        return i;
-      }
-    });
+    const t = createStoreProxy(e, storeTraps, wrapper);
     r.set(e, t);
     return t;
   };
   const s = wrapProjection(t);
   i = computed(() => {
     const t = i || getOwner();
-    storeSetter(s, i => {
-      const r = handleAsync(t, e(i), e => {
-        e !== i && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+    storeSetter(new Proxy(s, writeTraps), r => {
+      const o = handleAsync(t, e(r), e => {
+        e !== s && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        setSignal(i, undefined);
       });
-      r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(i);
+      o !== s && o !== undefined && reconcile(o, n?.key || "id", n?.all)(s);
     });
   });
+  i.Te = true;
   return { store: s, node: i };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
 }
+const writeTraps = {
+  get(e, t) {
+    let n;
+    setWriteOverride(true);
+    try {
+      n = e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return typeof n === "object" && n !== null ? new Proxy(n, writeTraps) : n;
+  },
+  set(e, t, n) {
+    setWriteOverride(true);
+    try {
+      e[t] = n;
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  },
+  deleteProperty(e, t) {
+    setWriteOverride(true);
+    try {
+      delete e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  }
+};
 const $TRACK = Symbol(0),
   $DEEP = Symbol(0),
   $TARGET = Symbol(0),
@@ -1209,7 +1330,7 @@ function createStoreProxy(e, t = storeTraps, n) {
     i = [];
     i.v = e;
   } else i = { v: e };
-  n && Object.assign(i, n);
+  n && n(i);
   return (i[$PROXY] = new Proxy(i, t));
 }
 const storeLookup = new WeakMap();
@@ -1222,6 +1343,13 @@ function wrap(e, t) {
 function isWrappable(e) {
   return e != null && typeof e === "object" && !Object.isFrozen(e);
 }
+let writeOverride = false;
+function setWriteOverride(e) {
+  writeOverride = e;
+}
+function writeOnly(e) {
+  return writeOverride || !!Writing?.has(e);
+}
 function getNodes(e, t) {
   let n = e[t];
   if (!n) e[t] = n = Object.create(null);
@@ -1241,8 +1369,7 @@ function getNode(e, t, n, i, r = isEqual) {
   ));
 }
 function trackSelf(e, t = $TRACK) {
-  getObserver() &&
-    read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL]?.(), false));
+  getObserver() && read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false));
 }
 function getKeys(e, t, n = true) {
   const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -1268,6 +1395,7 @@ const storeTraps = {
   get(e, t, n) {
     if (t === $TARGET) return e;
     if (t === $PROXY) return n;
+    if (t === $REFRESH) return e[STORE_FIREWALL];
     if (t === $TRACK || t === $DEEP) {
       trackSelf(e, t);
       return n;
@@ -1281,12 +1409,12 @@ const storeTraps = {
       const e = Object.getOwnPropertyDescriptor(u, t);
       if (e && e.get) return e.get.call(n);
     }
-    if (Writing?.has(n)) {
-      let n = r && (s || !o) ? (r.K !== NOT_PENDING ? r.K : r.M) : u[t];
+    if (writeOnly(n)) {
+      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);
-      Writing.add(i);
+      Writing?.add(i);
       return i;
     }
     let l = r ? (s || !o ? read(i[t]) : (read(i[t]), u[t])) : u[t];
@@ -1300,7 +1428,7 @@ const storeTraps = {
           ? l.bind(u)
           : l;
       } else if (getObserver()) {
-        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]?.()));
+        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]));
       }
     }
     return isWrappable(l) ? wrap(l, e) : l;
@@ -1311,12 +1439,12 @@ const storeTraps = {
       e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
         ? e[STORE_OVERRIDE][t] !== $DELETED
         : t in e[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]?.()));
+    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]));
     return n;
   },
   set(e, t, n) {
     const i = e[$PROXY];
-    if (Writing?.has(e[$PROXY])) {
+    if (writeOnly(i)) {
       untrack(() => {
         const r = e[STORE_VALUE];
         const s = r[t];
@@ -1345,7 +1473,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(e, t) {
-    if (Writing?.has(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
+    if (writeOnly(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
       untrack(() => {
         const n =
           e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : e[STORE_VALUE][t];
@@ -1642,68 +1770,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,
@@ -1715,149 +1843,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) {
@@ -1870,19 +1998,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);
@@ -1891,37 +2019,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;
   }
 }
@@ -1935,25 +2063,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);
@@ -1978,10 +2106,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.W, () => {
+    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();
     });
@@ -2044,6 +2172,7 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
+  action,
   createBoundary,
   createContext,
   createEffect,