@solidjs/signals 0.9.10 → 0.10.0

package/dist/prod.js

@@ -102,8 +102,8 @@ function markNode(e, t = REACTIVE_DIRTY) {
   for (let t = e.p; t !== null; t = t.h) {
     markNode(t.A, REACTIVE_CHECK);
   }
-  if (e.N !== null) {
-    for (let t = e.N; t !== null; t = t.P) {
+  if (e.P !== null) {
+    for (let t = e.P; t !== null; t = t.C) {
       for (let e = t.p; e !== null; e = e.h) {
         markNode(e.A, REACTIVE_CHECK);
       }
@@ -112,12 +112,12 @@ function markNode(e, t = REACTIVE_DIRTY) {
 }
 function runHeap(e, t) {
   e.I = false;
-  for (e.C = 0; e.C <= e.S; e.C++) {
-    let n = e.T[e.C];
+  for (e.N = 0; e.N <= e.S; e.N++) {
+    let n = e.T[e.N];
     while (n !== undefined) {
       if (n._ & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
-      n = e.T[e.C];
+      n = e.T[e.N];
     }
   }
   e.S = 0;
@@ -125,10 +125,10 @@ function runHeap(e, t) {
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
   let n = e.u;
-  for (let t = e.D; t; t = t.m) {
-    const e = t.V;
+  for (let t = e.D; t; t = t.V) {
+    const e = t.m;
     const i = e.L || e;
-    if (i.U && i.u >= n) n = i.u + 1;
+    if (i.k && i.u >= n) n = i.u + 1;
   }
   if (e.u !== n) {
     e.u = n;
@@ -138,88 +138,18 @@ function adjustHeight(e, t) {
   }
 }
 const transitions = new Set();
-const dirtyQueue = { T: new Array(2e3).fill(undefined), I: false, C: 0, S: 0 };
-const zombieQueue = { T: new Array(2e3).fill(undefined), I: false, C: 0, S: 0 };
+const dirtyQueue = { T: new Array(2e3).fill(undefined), I: false, N: 0, S: 0 };
+const zombieQueue = { T: new Array(2e3).fill(undefined), I: false, N: 0, S: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
-const signalLanes = new WeakMap();
-const activeLanes = new Set();
-let currentOptimisticLane = null;
-function setCurrentOptimisticLane(e) {
-  currentOptimisticLane = e;
-}
-function getOrCreateLane(e) {
-  let t = signalLanes.get(e);
-  if (t) {
-    return findLane(t);
-  }
-  const n = e.k;
-  const i = n?.W ? findLane(n.W) : null;
-  t = { t: e, G: new Set(), M: [[], []], F: null, $: activeTransition, H: i };
-  signalLanes.set(e, t);
-  activeLanes.add(t);
-  e.j = e.K || 0;
-  return t;
-}
-function findLane(e) {
-  while (e.F) e = e.F;
-  return e;
-}
-function mergeLanes(e, t) {
-  e = findLane(e);
-  t = findLane(t);
-  if (e === t) return e;
-  t.F = e;
-  for (const n of t.G) e.G.add(n);
-  e.M[0].push(...t.M[0]);
-  e.M[1].push(...t.M[1]);
-  return e;
-}
-function clearLaneEntry(e) {
-  signalLanes.delete(e);
-}
-function resolveLane(e) {
-  const t = e.W;
-  if (!t) return undefined;
-  const n = findLane(t);
-  if (activeLanes.has(n)) return n;
-  e.W = undefined;
-  return undefined;
-}
-function hasActiveOverride(e) {
-  return !!(e.Y && e.B !== NOT_PENDING);
-}
-function assignOrMergeLane(e, t) {
-  const n = findLane(t);
-  const i = e.W;
-  if (i) {
-    if (i.F) {
-      e.W = t;
-      return;
-    }
-    const r = findLane(i);
-    if (activeLanes.has(r)) {
-      if (r !== n && !hasActiveOverride(e)) {
-        if (n.H && findLane(n.H) === r) {
-          e.W = t;
-        } else if (r.H && findLane(r.H) === n);
-        else {
-          mergeLanes(n, r);
-        }
-      }
-      return;
-    }
-  }
-  e.W = t;
-}
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.F || t.G.size > 0) continue;
-    const n = t.M[e - 1];
+    if (t.U || t.W.size > 0) continue;
+    const n = t.F[e - 1];
     if (n.length) {
-      t.M[e - 1] = [];
+      t.F[e - 1] = [];
       runQueue(n, e);
     }
   }
@@ -230,21 +160,21 @@ function setProjectionWriteActive(e) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.X) queueMicrotask(flush);
+  if (!globalQueue.G) queueMicrotask(flush);
 }
 class Queue {
   o = null;
-  q = [[], []];
-  Z = [];
+  M = [[], []];
+  $ = [];
   created = clock;
   addChild(e) {
-    this.Z.push(e);
+    this.$.push(e);
     e.o = this;
   }
   removeChild(e) {
-    const t = this.Z.indexOf(e);
+    const t = this.$.indexOf(e);
     if (t >= 0) {
-      this.Z.splice(t, 1);
+      this.$.splice(t, 1);
       e.o = null;
     }
   }
@@ -253,106 +183,106 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.q[e - 1].length) {
-      const t = this.q[e - 1];
-      this.q[e - 1] = [];
+    if (this.M[e - 1].length) {
+      const t = this.M[e - 1];
+      this.M[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.Z.length; t++) this.Z[t].run?.(e);
+    for (let t = 0; t < this.$.length; t++) this.$[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.M[e - 1].push(t);
+        n.F[e - 1].push(t);
       } else {
-        this.q[e - 1].push(t);
+        this.M[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.q[0].push(...this.q[0]);
-    e.q[1].push(...this.q[1]);
-    this.q = [[], []];
-    for (let t = 0; t < this.Z.length; t++) {
-      let n = this.Z[t];
-      let i = e.Z[t];
+    e.M[0].push(...this.M[0]);
+    e.M[1].push(...this.M[1]);
+    this.M = [[], []];
+    for (let t = 0; t < this.$.length; t++) {
+      let n = this.$[t];
+      let i = e.$[t];
       if (!i) {
-        i = { q: [[], []], Z: [] };
-        e.Z[t] = i;
+        i = { M: [[], []], $: [] };
+        e.$[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.q[0].push(...e.q[0]);
-    this.q[1].push(...e.q[1]);
-    for (let t = 0; t < e.Z.length; t++) {
-      const n = e.Z[t];
-      let i = this.Z[t];
+    this.M[0].push(...e.M[0]);
+    this.M[1].push(...e.M[1]);
+    for (let t = 0; t < e.$.length; t++) {
+      const n = e.$[t];
+      let i = this.$[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  X = false;
-  J = [];
-  ee = [];
-  te = new Set();
-  static ne;
-  static ie;
-  static re = null;
+  G = false;
+  H = [];
+  j = [];
+  K = new Set();
+  static Y;
+  static B;
+  static X = null;
   flush() {
-    if (this.X) return;
-    this.X = true;
+    if (this.G) return;
+    this.G = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.ne);
+      runHeap(dirtyQueue, GlobalQueue.Y);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
           let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.ne);
-          this.J = [];
-          this.ee = [];
-          this.te = new Set();
+          runHeap(zombieQueue, GlobalQueue.Y);
+          this.H = [];
+          this.j = [];
+          this.K = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition.oe);
+          this.stashQueues(activeTransition.q);
           clock++;
-          scheduled = dirtyQueue.S >= dirtyQueue.C;
-          reassignPendingTransition(activeTransition.J);
+          scheduled = dirtyQueue.S >= dirtyQueue.N;
+          reassignPendingTransition(activeTransition.H);
           activeTransition = null;
           finalizePureQueue(null, true);
           return;
         }
-        this.J !== activeTransition.J && this.J.push(...activeTransition.J);
-        this.restoreQueues(activeTransition.oe);
+        this.H !== activeTransition.H && this.H.push(...activeTransition.H);
+        this.restoreQueues(activeTransition.q);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.J);
+        reassignPendingTransition(this.H);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.ne);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.Y);
         finalizePureQueue();
       }
       clock++;
-      scheduled = dirtyQueue.S >= dirtyQueue.C;
+      scheduled = dirtyQueue.S >= dirtyQueue.N;
       runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.X = false;
+      this.G = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.se;
-        if (activeTransition && t && !activeTransition.ue.includes(t.t)) {
-          activeTransition.ue.push(t.t);
+        const t = i !== undefined ? i : e.Z;
+        if (activeTransition && t && !activeTransition.J.includes(t.t)) {
+          activeTransition.J.push(t.t);
           schedule();
         }
       }
@@ -363,143 +293,143 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.ce === clock) return;
+    if (!e && activeTransition && activeTransition.ee === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        ce: clock,
+        ee: clock,
+        H: [],
         J: [],
-        ue: [],
-        ee: [],
-        te: new Set(),
-        le: [],
-        oe: { q: [[], []], Z: [] },
-        ae: false
+        j: [],
+        K: new Set(),
+        te: [],
+        q: { M: [[], []], $: [] },
+        ne: false
       };
     } else if (e) {
       const t = activeTransition;
-      t.ae = e;
-      e.le.push(...t.le);
+      t.ne = e;
+      e.te.push(...t.te);
       for (const n of activeLanes) {
-        if (n.$ === t) n.$ = e;
+        if (n.ie === t) n.ie = e;
       }
-      e.ee.push(...t.ee);
-      for (const n of t.te) {
-        e.te.add(n);
+      e.j.push(...t.j);
+      for (const n of t.K) {
+        e.K.add(n);
       }
       transitions.delete(t);
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.ce = clock;
-    for (let e = 0; e < this.J.length; e++) {
-      const t = this.J[e];
-      t.$ = activeTransition;
-      activeTransition.J.push(t);
-    }
-    this.J = activeTransition.J;
-    for (let e = 0; e < this.ee.length; e++) {
-      const t = this.ee[e];
-      t.$ = activeTransition;
-      activeTransition.ee.push(t);
-    }
-    this.ee = activeTransition.ee;
+    activeTransition.ee = clock;
+    for (let e = 0; e < this.H.length; e++) {
+      const t = this.H[e];
+      t.ie = activeTransition;
+      activeTransition.H.push(t);
+    }
+    this.H = activeTransition.H;
+    for (let e = 0; e < this.j.length; e++) {
+      const t = this.j[e];
+      t.ie = activeTransition;
+      activeTransition.j.push(t);
+    }
+    this.j = activeTransition.j;
     for (const e of activeLanes) {
-      if (!e.$) e.$ = activeTransition;
+      if (!e.ie) e.ie = activeTransition;
     }
-    for (const e of this.te) activeTransition.te.add(e);
-    this.te = activeTransition.te;
+    for (const e of this.K) activeTransition.K.add(e);
+    this.K = activeTransition.K;
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.W || currentOptimisticLane;
+  const n = e.re || currentOptimisticLane;
   for (let i = e.p; i !== null; i = i.h) {
     if (t && n) {
       i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
       assignOrMergeLane(i.A, n);
     } else if (t) {
       i.A._ |= REACTIVE_OPTIMISTIC_DIRTY;
-      i.A.W = undefined;
+      i.A.re = undefined;
     }
     const e = i.A;
-    if (e.fe === EFFECT_TRACKED) {
-      if (!e.Ee) {
-        e.Ee = true;
-        e.Te.enqueue(EFFECT_USER, e.de);
+    if (e.oe === EFFECT_TRACKED) {
+      if (!e.se) {
+        e.se = true;
+        e.ue.enqueue(EFFECT_USER, e.ce);
       }
       continue;
     }
     const r = i.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (r.C > i.A.u) r.C = i.A.u;
+    if (r.N > i.A.u) r.N = i.A.u;
     insertIntoHeap(i.A, r);
   }
 }
 function finalizePureQueue(e = null, t = false) {
   let n = !t;
   if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.S >= dirtyQueue.C) runHeap(dirtyQueue, GlobalQueue.ne);
+  if (dirtyQueue.S >= dirtyQueue.N) runHeap(dirtyQueue, GlobalQueue.Y);
   if (n) {
-    const t = globalQueue.J;
+    const t = globalQueue.H;
     for (let e = 0; e < t.length; e++) {
       const n = t[e];
-      if (n.B !== NOT_PENDING) {
-        n.Re = n.B;
-        n.B = NOT_PENDING;
-        if (n.fe && n.fe !== EFFECT_TRACKED) n.Ee = true;
+      if (n.le !== NOT_PENDING) {
+        n.ae = n.le;
+        n.le = NOT_PENDING;
+        if (n.oe && n.oe !== EFFECT_TRACKED) n.se = true;
       }
-      n.Oe &= ~STATUS_UNINITIALIZED;
-      if (n.U) GlobalQueue.ie(n, false, true);
+      n.fe &= ~STATUS_UNINITIALIZED;
+      if (n.k) GlobalQueue.B(n, false, true);
     }
     t.length = 0;
-    const n = e ? e.ee : globalQueue.ee;
+    const n = e ? e.j : globalQueue.j;
     for (let e = 0; e < n.length; e++) {
       const t = n[e];
-      const i = t.B;
-      t.W = undefined;
-      if (i !== NOT_PENDING && t.Re !== i) {
-        t.Re = i;
+      const i = t.le;
+      t.re = undefined;
+      if (i !== NOT_PENDING && t.ae !== i) {
+        t.ae = i;
         insertSubs(t, true);
       }
-      t.B = NOT_PENDING;
-      t.$ = null;
+      t.le = NOT_PENDING;
+      t.ie = null;
     }
     n.length = 0;
-    const i = e ? e.te : globalQueue.te;
-    if (GlobalQueue.re && i.size) {
+    const i = e ? e.K : globalQueue.K;
+    if (GlobalQueue.X && i.size) {
       for (const e of i) {
-        GlobalQueue.re(e);
+        GlobalQueue.X(e);
       }
       i.clear();
       schedule();
     }
     for (const t of activeLanes) {
-      const n = e ? t.$ === e : !t.$;
+      const n = e ? t.ie === e : !t.ie;
       if (!n) continue;
-      if (!t.F) {
-        if (t.M[0].length) runQueue(t.M[0], EFFECT_RENDER);
-        if (t.M[1].length) runQueue(t.M[1], EFFECT_USER);
-      }
-      if (t.t.W === t) t.t.W = undefined;
-      t.G.clear();
-      t.M[0].length = 0;
-      t.M[1].length = 0;
+      if (!t.U) {
+        if (t.F[0].length) runQueue(t.F[0], EFFECT_RENDER);
+        if (t.F[1].length) runQueue(t.F[1], EFFECT_USER);
+      }
+      if (t.t.re === t) t.t.re = undefined;
+      t.W.clear();
+      t.F[0].length = 0;
+      t.F[1].length = 0;
       activeLanes.delete(t);
       signalLanes.delete(t.t);
     }
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.Z) {
+  for (const t of e.$) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.te.add(e);
+  globalQueue.K.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].$ = activeTransition;
+    e[t].ie = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -512,23 +442,26 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.ae) return true;
-  if (e.le.length) return false;
+  if (e.ne) return true;
+  if (e.te.length) return false;
   let t = true;
-  for (let n = 0; n < e.ue.length; n++) {
-    const i = e.ue[n];
-    if (i.Oe & STATUS_PENDING && i.se?.t === i) {
+  for (let n = 0; n < e.J.length; n++) {
+    const i = e.J[n];
+    if (i.fe & STATUS_PENDING && i.Z?.t === i) {
       t = false;
       break;
     }
   }
-  t && (e.ae = true);
+  t && (e.ne = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.ae && typeof e.ae === "object") e = e.ae;
+  while (e.ne && typeof e.ne === "object") e = e.ne;
   return e;
 }
+function setActiveTransition(e) {
+  activeTransition = e;
+}
 function runInTransition(e, t) {
   const n = activeTransition;
   try {
@@ -538,196 +471,107 @@ function runInTransition(e, t) {
     activeTransition = n;
   }
 }
-function restoreTransition(e, t) {
-  globalQueue.initTransition(e);
-  const n = t();
-  flush();
-  return n;
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(e) {
+  let t = signalLanes.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.Ee;
+  const i = n?.re ? findLane(n.re) : null;
+  t = { t: e, W: new Set(), F: [[], []], U: null, ie: activeTransition, Te: i };
+  signalLanes.set(e, t);
+  activeLanes.add(t);
+  e.de = e.Re || 0;
+  return t;
 }
-function action(e) {
-  return (...t) =>
-    new Promise((n, i) => {
-      const r = e(...t);
-      globalQueue.initTransition();
-      let o = activeTransition;
-      o.le.push(r);
-      const done = (e, t) => {
-        o = currentTransition(o);
-        const s = o.le.indexOf(r);
-        if (s >= 0) o.le.splice(s, 1);
-        activeTransition = o;
-        schedule();
-        t ? i(t) : n(e);
-      };
-      const step = (e, t) => {
-        let n;
-        try {
-          n = t ? r.throw(e) : r.next(e);
-        } catch (e) {
-          return done(undefined, e);
-        }
-        if (n instanceof Promise)
-          return void n.then(run, e => restoreTransition(o, () => step(e, true)));
-        run(n);
-      };
-      const run = e => {
-        if (e.done) return done(e.value);
-        if (e.value instanceof Promise)
-          return void e.value.then(
-            e => restoreTransition(o, () => step(e)),
-            e => restoreTransition(o, () => step(e, true))
-          );
-        restoreTransition(o, () => step(e.value));
-      };
-      step();
-    });
+function findLane(e) {
+  while (e.U) e = e.U;
+  return e;
 }
-GlobalQueue.ne = recompute;
-GlobalQueue.ie = disposeChildren;
-let tracking = false;
-let stale = false;
-let refreshing = false;
-let pendingCheckActive = false;
-let foundPending = false;
-let pendingReadActive = false;
-let context = null;
-function recompute(e, t = false) {
-  const n = e.fe;
-  if (!t) {
-    if (e.$ && (!n || activeTransition) && activeTransition !== e.$)
-      globalQueue.initTransition(e.$);
-    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.$ || n === EFFECT_TRACKED) disposeChildren(e);
-    else {
-      markDisposal(e);
-      e.Se = e._e;
-      e.Ie = e.pe;
-      e._e = null;
-      e.pe = null;
-    }
-  }
-  const i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = hasActiveOverride(e);
-  const o = !!(e.Oe & STATUS_PENDING);
-  const s = context;
-  context = e;
-  e.he = null;
-  e._ = REACTIVE_RECOMPUTING_DEPS;
-  e.ce = clock;
-  let u = e.B === NOT_PENDING ? e.Re : e.B;
-  let c = e.u;
-  let l = tracking;
-  let a = currentOptimisticLane;
-  tracking = true;
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.U = e;
+  for (const n of t.W) e.W.add(n);
+  e.F[0].push(...t.F[0]);
+  e.F[1].push(...t.F[1]);
+  return e;
+}
+function resolveLane(e) {
+  const t = e.re;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (activeLanes.has(n)) return n;
+  e.re = undefined;
+  return undefined;
+}
+function hasActiveOverride(e) {
+  return !!(e.Oe && e.le !== NOT_PENDING);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const i = e.re;
   if (i) {
-    const t = resolveLane(e);
-    if (t) setCurrentOptimisticLane(t);
-  }
-  try {
-    u = handleAsync(e, e.U(u));
-    clearStatus(e);
-    const t = resolveLane(e);
-    if (t) {
-      t.G.delete(e);
-      updatePendingSignal(t.t);
-    }
-  } catch (t) {
-    if (t instanceof NotReadyError && currentOptimisticLane) {
-      const t = findLane(currentOptimisticLane);
-      if (t.t !== e) {
-        t.G.add(e);
-        e.W = t;
-        updatePendingSignal(t.t);
-      }
-    }
-    notifyStatus(
-      e,
-      t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
-      t,
-      undefined,
-      t instanceof NotReadyError ? e.W : undefined
-    );
-  } finally {
-    tracking = l;
-    e._ = REACTIVE_NONE;
-    context = s;
-  }
-  if (!e.se) {
-    const s = e.he;
-    let l = s !== null ? s.m : e.D;
-    if (l !== null) {
-      do {
-        l = unlinkSubs(l);
-      } while (l !== null);
-      if (s !== null) s.m = null;
-      else e.D = null;
+    if (i.U) {
+      e.re = t;
+      return;
     }
-    const a = r ? e.Re : e.B === NOT_PENDING ? e.Re : e.B;
-    const f = !e.Ae || !e.Ae(a, u);
-    if (f) {
-      const s = r ? e.Re : undefined;
-      if (t || (n && activeTransition !== e.$) || i) e.Re = u;
-      else e.B = u;
-      if (r && !i && o) {
-        const t = e.K || 0;
-        const n = e.j || 0;
-        if (t <= n) e.Re = u;
-      }
-      if (!r || i || e.Re !== s) {
-        insertSubs(e, i || r);
-      }
-    } else if (r) {
-      e.B = u;
-    } else if (e.u != c) {
-      for (let t = e.p; t !== null; t = t.h) {
-        insertIntoHeapHeight(t.A, t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    const r = findLane(i);
+    if (activeLanes.has(r)) {
+      if (r !== n && !hasActiveOverride(e)) {
+        if (n.Te && findLane(n.Te) === r) {
+          e.re = t;
+        } else if (r.Te && findLane(r.Te) === n);
+        else mergeLanes(n, r);
       }
+      return;
     }
   }
-  setCurrentOptimisticLane(a);
-  (!t || e.Oe & STATUS_PENDING) && !e.$ && !(activeTransition && e.Y) && globalQueue.J.push(e);
-  e.$ && n && activeTransition !== e.$ && runInTransition(e.$, () => recompute(e));
+  e.re = t;
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
   const r = i && untrack(() => t[Symbol.asyncIterator]);
   const o = !r && i && untrack(() => typeof t.then === "function");
   if (!o && !r) {
-    e.ge = null;
+    e.Se = null;
     return t;
   }
-  e.ge = t;
+  e.Se = t;
   let s;
   const handleError = n => {
-    if (e.ge !== t) return;
-    globalQueue.initTransition(e.$);
+    if (e.Se !== t) return;
+    globalQueue.initTransition(e.ie);
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.ce = clock;
+    e.ee = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e.ge !== t) return;
+    if (e.Se !== t) return;
     if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(e.$);
+    globalQueue.initTransition(e.ie);
     clearStatus(e);
     const o = resolveLane(e);
-    if (o) o.G.delete(e);
+    if (o) o.W.delete(e);
     if (n) n(i);
-    else if (e.Y) {
-      const t = e.B !== NOT_PENDING;
-      if (e.U) e.B = i;
+    else if (e.Oe) {
+      const t = e.le !== NOT_PENDING;
+      if (e.k) e.le = i;
       if (!t) {
-        e.Re = i;
+        e.ae = i;
         insertSubs(e);
       }
-      e.ce = clock;
+      e.ee = clock;
     } else if (o) {
-      const t = e.Re;
-      const n = e.Ae;
+      const t = e.ae;
+      const n = e._e;
       if (!n || !n(i, t)) {
-        e.Re = i;
-        e.ce = clock;
-        if (e.Ne) {
-          setSignal(e.Ne, i);
+        e.ae = i;
+        e.ee = clock;
+        if (e.Ie) {
+          setSignal(e.Ie, i);
         }
         insertSubs(e, true);
       }
@@ -754,7 +598,7 @@ function handleAsync(e, t, n) {
     );
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.$);
+      globalQueue.initTransition(e.ie);
       throw new NotReadyError(context);
     }
   }
@@ -786,27 +630,27 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.$);
+      globalQueue.initTransition(e.ie);
       throw new NotReadyError(context);
     }
   }
   return s;
 }
 function clearStatus(e) {
-  e.Oe = e.Oe & STATUS_UNINITIALIZED;
-  e.se = null;
+  e.fe = e.fe & STATUS_UNINITIALIZED;
+  e.Z = null;
   updatePendingSignal(e);
-  e.Pe?.();
+  e.pe?.();
 }
 function notifyStatus(e, t, n, i, r) {
   if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
     n = new StatusError(e, n);
   const o = n instanceof NotReadyError && n.t === e;
-  const s = t === STATUS_PENDING && e.Y && !o;
+  const s = t === STATUS_PENDING && e.Oe && !o;
   const u = s && hasActiveOverride(e);
   if (!i) {
-    e.Oe = t | (t !== STATUS_ERROR ? e.Oe & STATUS_UNINITIALIZED : 0);
-    e.se = n;
+    e.fe = t | (t !== STATUS_ERROR ? e.fe & STATUS_UNINITIALIZED : 0);
+    e.Z = n;
     updatePendingSignal(e);
   }
   if (r && !i) {
@@ -814,68 +658,249 @@ function notifyStatus(e, t, n, i, r) {
   }
   if (u && activeTransition && n instanceof NotReadyError) {
     const e = n.t;
-    if (!activeTransition.ue.includes(e)) {
-      activeTransition.ue.push(e);
+    if (!activeTransition.J.includes(e)) {
+      activeTransition.J.push(e);
     }
   }
   const c = i || u;
   const l = i || s ? undefined : r;
-  if (e.Pe) {
+  if (e.pe) {
     if (c) {
-      e.Pe(t, n);
+      e.pe(t, n);
     } else {
-      e.Pe();
+      e.pe();
     }
     return;
   }
   for (let i = e.p; i !== null; i = i.h) {
-    i.A.ce = clock;
-    if (i.A.se !== n) {
-      !i.A.$ && globalQueue.J.push(i.A);
+    i.A.ee = clock;
+    if (i.A.Z !== n) {
+      !i.A.ie && globalQueue.H.push(i.A);
       notifyStatus(i.A, t, n, c, l);
     }
   }
-  for (let i = e.N; i !== null; i = i.P) {
+  for (let i = e.P; i !== null; i = i.C) {
     for (let e = i.p; e !== null; e = e.h) {
-      e.A.ce = clock;
-      if (e.A.se !== n) {
-        !e.A.$ && globalQueue.J.push(e.A);
+      e.A.ee = clock;
+      if (e.A.Z !== n) {
+        !e.A.ie && globalQueue.H.push(e.A);
         notifyStatus(e.A, t, n, c, l);
       }
     }
   }
 }
-function updateIfNecessary(e) {
-  if (e._ & REACTIVE_CHECK) {
-    for (let t = e.D; t; t = t.m) {
-      const n = t.V;
-      const i = n.L || n;
-      if (i.U) {
-        updateIfNecessary(i);
+function effect(e, t, n, i, r) {
+  let o = false;
+  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
+    ...r,
+    equals: () => {
+      s.se = !s.Z;
+      if (o) s.ue.enqueue(s.oe, runEffect.bind(s));
+      return false;
+    },
+    lazy: true
+  });
+  s.he = i;
+  s.Ae = t;
+  s.ge = n;
+  s.Pe = undefined;
+  s.oe = r?.render ? EFFECT_RENDER : EFFECT_USER;
+  s.pe = (e, t) => {
+    const n = e !== undefined ? e : s.fe;
+    const i = t !== undefined ? t : s.Z;
+    if (n & STATUS_ERROR) {
+      let e = i;
+      s.ue.notify(s, STATUS_PENDING, 0);
+      if (s.oe === EFFECT_USER) {
+        try {
+          return s.ge
+            ? s.ge(e, () => {
+                s.Pe?.();
+                s.Pe = undefined;
+              })
+            : console.error(e);
+        } catch (t) {
+          e = t;
+        }
       }
-      if (e._ & REACTIVE_DIRTY) {
-        break;
+      if (!s.ue.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
+    } else if (s.oe === EFFECT_RENDER) s.ue.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
+  };
+  recompute(s, true);
+  !r?.defer && (s.oe === EFFECT_USER ? s.ue.enqueue(s.oe, runEffect.bind(s)) : runEffect.call(s));
+  o = true;
+  onCleanup(() => s.Pe?.());
+}
+function runEffect() {
+  if (!this.se || this._ & REACTIVE_DISPOSED) return;
+  this.Pe?.();
+  this.Pe = undefined;
+  try {
+    this.Pe = this.Ae(this.ae, this.he);
+  } catch (e) {
+    if (!this.ue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+  } finally {
+    this.he = this.ae;
+    this.se = false;
+  }
+}
+function trackedEffect(e, t) {
+  const run = () => {
+    if (!n.se || n._ & REACTIVE_DISPOSED) return;
+    n.se = false;
+    recompute(n);
+  };
+  const n = computed(
+    () => {
+      try {
+        n.Pe?.();
+        n.Pe = undefined;
+        n.Pe = staleValues(e) || undefined;
+      } finally {
       }
+    },
+    undefined,
+    { ...t, lazy: true, pureWrite: true }
+  );
+  n.Pe = undefined;
+  n.se = true;
+  n.oe = EFFECT_TRACKED;
+  n.ce = run;
+  n.ue.enqueue(EFFECT_USER, run);
+  onCleanup(() => n.Pe?.());
+}
+const PENDING_OWNER = {};
+function markDisposal(e) {
+  let t = e.Ce;
+  while (t) {
+    t._ |= REACTIVE_ZOMBIE;
+    if (t._ & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
     }
+    markDisposal(t);
+    t = t.Ne;
   }
-  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.se && e.ce < clock)) {
-    recompute(e);
+}
+function dispose(e) {
+  let t = e.D || null;
+  do {
+    t = unlinkSubs(t);
+  } while (t !== null);
+  e.D = null;
+  e.ye = null;
+  disposeChildren(e, true);
+}
+function disposeChildren(e, t = false, n) {
+  if (e._ & REACTIVE_DISPOSED) return;
+  if (t) e._ = REACTIVE_DISPOSED;
+  let i = n ? e.De : e.Ce;
+  while (i) {
+    const e = i.Ne;
+    if (i.D) {
+      const e = i;
+      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.D;
+      do {
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.D = null;
+      e.ye = null;
+    }
+    disposeChildren(i, true);
+    i = e;
   }
-  e._ = REACTIVE_NONE;
+  if (n) {
+    e.De = null;
+  } else {
+    e.Ce = null;
+    e.Ne = null;
+  }
+  runDisposal(e, n);
+}
+function runDisposal(e, t) {
+  let n = t ? e.ve : e.we;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      t.call(t);
+    }
+  } else {
+    n.call(n);
+  }
+  t ? (e.ve = null) : (e.we = null);
+}
+function getNextChildId(e) {
+  if (e.id != null) return formatId(e.id, e.be++);
+  throw new Error("Cannot get child id from owner without an id");
+}
+function formatId(e, t) {
+  const n = t.toString(36),
+    i = n.length - 1;
+  return e + (i ? String.fromCharCode(64 + i) : "") + n;
+}
+function getObserver() {
+  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
+  return tracking ? context : null;
+}
+function getOwner() {
+  return context;
+}
+function onCleanup(e) {
+  if (!context) return e;
+  if (!context.we) context.we = e;
+  else if (Array.isArray(context.we)) context.we.push(e);
+  else context.we = [context.we, e];
+  return e;
+}
+function createOwner(e) {
+  const t = context;
+  const n = {
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
+    i: true,
+    l: t?.i ? t.l : t,
+    Ce: null,
+    Ne: null,
+    we: null,
+    ue: t?.ue ?? globalQueue,
+    Ve: t?.Ve || defaultContext,
+    be: 0,
+    ve: null,
+    De: null,
+    o: t,
+    dispose(e = true) {
+      disposeChildren(n, e);
+    }
+  };
+  if (t) {
+    const e = t.Ce;
+    if (e === null) {
+      t.Ce = n;
+    } else {
+      n.Ne = e;
+      t.Ce = n;
+    }
+  }
+  return n;
+}
+function createRoot(e, t) {
+  const n = createOwner(t);
+  return runWithOwner(n, () => e(n.dispose));
 }
 function unlinkSubs(e) {
-  const t = e.V;
-  const n = e.m;
+  const t = e.m;
+  const n = e.V;
   const i = e.h;
-  const r = e.Ce;
-  if (i !== null) i.Ce = r;
-  else t.ye = r;
+  const r = e.me;
+  if (i !== null) i.me = r;
+  else t.Le = r;
   if (r !== null) r.h = i;
   else {
     t.p = i;
     if (i === null) {
-      t.De?.();
-      t.U && !t.ve && unobserved(t);
+      t.ke?.();
+      t.k && !t.Ue && unobserved(t);
     }
   }
   return n;
@@ -890,148 +915,203 @@ function unobserved(e) {
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.he;
-  if (n !== null && n.V === e) return;
+  const n = t.ye;
+  if (n !== null && n.m === e) return;
   let i = null;
   const r = t._ & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
-    i = n !== null ? n.m : t.D;
-    if (i !== null && i.V === e) {
-      t.he = i;
+    i = n !== null ? n.V : t.D;
+    if (i !== null && i.m === e) {
+      t.ye = i;
       return;
     }
   }
-  const o = e.ye;
+  const o = e.Le;
   if (o !== null && o.A === t && (!r || isValidLink(o, t))) return;
-  const s = (t.he = e.ye = { V: e, A: t, m: i, Ce: o, h: null });
-  if (n !== null) n.m = s;
+  const s = (t.ye = e.Le = { m: e, A: t, V: i, me: o, h: null });
+  if (n !== null) n.V = s;
   else t.D = s;
   if (o !== null) o.h = s;
   else e.p = s;
 }
 function isValidLink(e, t) {
-  const n = t.he;
+  const n = t.ye;
   if (n !== null) {
     let i = t.D;
     do {
       if (i === e) return true;
       if (i === n) break;
-      i = i.m;
+      i = i.V;
     } while (i !== null);
   }
   return false;
 }
-function markDisposal(e) {
-  let t = e.pe;
-  while (t) {
-    t._ |= REACTIVE_ZOMBIE;
-    if (t._ & REACTIVE_IN_HEAP) {
-      deleteFromHeap(t, dirtyQueue);
-      insertIntoHeap(t, zombieQueue);
+GlobalQueue.Y = recompute;
+GlobalQueue.B = disposeChildren;
+let tracking = false;
+let stale = false;
+let refreshing = false;
+let pendingCheckActive = false;
+let foundPending = false;
+let pendingReadActive = false;
+let context = null;
+let currentOptimisticLane = null;
+function recompute(e, t = false) {
+  const n = e.oe;
+  if (!t) {
+    if (e.ie && (!n || activeTransition) && activeTransition !== e.ie)
+      globalQueue.initTransition(e.ie);
+    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (e.ie || n === EFFECT_TRACKED) disposeChildren(e);
+    else {
+      markDisposal(e);
+      e.ve = e.we;
+      e.De = e.Ce;
+      e.we = null;
+      e.Ce = null;
     }
-    markDisposal(t);
-    t = t.we;
   }
-}
-function dispose(e) {
-  let t = e.D || null;
-  do {
-    t = unlinkSubs(t);
-  } while (t !== null);
-  e.D = null;
-  e.he = null;
-  disposeChildren(e, true);
-}
-function disposeChildren(e, t = false, n) {
-  if (e._ & REACTIVE_DISPOSED) return;
-  if (t) e._ = REACTIVE_DISPOSED;
-  let i = n ? e.Ie : e.pe;
-  while (i) {
-    const e = i.we;
-    if (i.D) {
-      const e = i;
-      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.D;
+  const i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = hasActiveOverride(e);
+  const o = !!(e.fe & STATUS_PENDING);
+  const s = context;
+  context = e;
+  e.ye = null;
+  e._ = REACTIVE_RECOMPUTING_DEPS;
+  e.ee = clock;
+  let u = e.le === NOT_PENDING ? e.ae : e.le;
+  let c = e.u;
+  let l = tracking;
+  let a = currentOptimisticLane;
+  tracking = true;
+  if (i) {
+    const t = resolveLane(e);
+    if (t) currentOptimisticLane = t;
+  }
+  try {
+    u = handleAsync(e, e.k(u));
+    clearStatus(e);
+    const t = resolveLane(e);
+    if (t) {
+      t.W.delete(e);
+      updatePendingSignal(t.t);
+    }
+  } catch (t) {
+    if (t instanceof NotReadyError && currentOptimisticLane) {
+      const t = findLane(currentOptimisticLane);
+      if (t.t !== e) {
+        t.W.add(e);
+        e.re = t;
+        updatePendingSignal(t.t);
+      }
+    }
+    notifyStatus(
+      e,
+      t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      t,
+      undefined,
+      t instanceof NotReadyError ? e.re : undefined
+    );
+  } finally {
+    tracking = l;
+    e._ = REACTIVE_NONE;
+    context = s;
+  }
+  if (!e.Z) {
+    const s = e.ye;
+    let l = s !== null ? s.V : e.D;
+    if (l !== null) {
       do {
-        t = unlinkSubs(t);
-      } while (t !== null);
-      e.D = null;
-      e.he = null;
+        l = unlinkSubs(l);
+      } while (l !== null);
+      if (s !== null) s.V = null;
+      else e.D = null;
+    }
+    const a = r ? e.ae : e.le === NOT_PENDING ? e.ae : e.le;
+    const f = !e._e || !e._e(a, u);
+    if (f) {
+      const s = r ? e.ae : undefined;
+      if (t || (n && activeTransition !== e.ie) || i) e.ae = u;
+      else e.le = u;
+      if (r && !i && o) {
+        const t = e.Re || 0;
+        const n = e.de || 0;
+        if (t <= n) e.ae = u;
+      }
+      if (!r || i || e.ae !== s) {
+        insertSubs(e, i || r);
+      }
+    } else if (r) {
+      e.le = u;
+    } else if (e.u != c) {
+      for (let t = e.p; t !== null; t = t.h) {
+        insertIntoHeapHeight(t.A, t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
     }
-    disposeChildren(i, true);
-    i = e;
-  }
-  if (n) {
-    e.Ie = null;
-  } else {
-    e.pe = null;
-    e.we = null;
   }
-  runDisposal(e, n);
+  currentOptimisticLane = a;
+  (!t || e.fe & STATUS_PENDING) && !e.ie && !(activeTransition && e.Oe) && globalQueue.H.push(e);
+  e.ie && n && activeTransition !== e.ie && runInTransition(e.ie, () => recompute(e));
 }
-function runDisposal(e, t) {
-  let n = t ? e.Se : e._e;
-  if (!n) return;
-  if (Array.isArray(n)) {
-    for (let e = 0; e < n.length; e++) {
-      const t = n[e];
-      t.call(t);
+function updateIfNecessary(e) {
+  if (e._ & REACTIVE_CHECK) {
+    for (let t = e.D; t; t = t.V) {
+      const n = t.m;
+      const i = n.L || n;
+      if (i.k) {
+        updateIfNecessary(i);
+      }
+      if (e._ & REACTIVE_DIRTY) {
+        break;
+      }
     }
-  } else {
-    n.call(n);
   }
-  t ? (e.Se = null) : (e._e = null);
-}
-function getNextChildId(e) {
-  if (e.id != null) return formatId(e.id, e.be++);
-  throw new Error("Cannot get child id from owner without an id");
-}
-function formatId(e, t) {
-  const n = t.toString(36),
-    i = n.length - 1;
-  return e + (i ? String.fromCharCode(64 + i) : "") + n;
+  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.Z && e.ee < clock)) {
+    recompute(e);
+  }
+  e._ = REACTIVE_NONE;
 }
 function computed(e, t, n) {
   const i = {
     id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
-    Ae: n?.equals != null ? n.equals : isEqual,
-    me: !!n?.pureWrite,
-    De: n?.unobserved,
-    _e: null,
-    Te: context?.Te ?? globalQueue,
+    _e: n?.equals != null ? n.equals : isEqual,
+    We: !!n?.pureWrite,
+    ke: n?.unobserved,
+    we: null,
+    ue: context?.ue ?? globalQueue,
     Ve: context?.Ve ?? defaultContext,
     be: 0,
-    U: e,
-    Re: t,
+    k: e,
+    ae: t,
     u: 0,
-    N: null,
+    P: null,
     O: undefined,
     R: null,
     D: null,
-    he: null,
-    p: null,
     ye: null,
+    p: null,
+    Le: null,
     o: context,
-    we: null,
-    pe: null,
+    Ne: null,
+    Ce: null,
     _: REACTIVE_NONE,
-    Oe: STATUS_UNINITIALIZED,
-    ce: clock,
-    B: NOT_PENDING,
+    fe: STATUS_UNINITIALIZED,
+    ee: clock,
+    le: NOT_PENDING,
+    ve: null,
+    De: null,
     Se: null,
-    Ie: null,
-    ge: null,
-    $: null
+    ie: null
   };
   i.R = i;
   const r = context?.i ? context.l : context;
   if (context) {
-    const e = context.pe;
+    const e = context.Ce;
     if (e === null) {
-      context.pe = i;
+      context.Ce = i;
     } else {
-      i.we = e;
-      context.pe = i;
+      i.Ne = e;
+      context.Ce = i;
     }
   }
   if (r) i.u = r.u + 1;
@@ -1040,87 +1120,30 @@ function computed(e, t, n) {
 }
 function signal(e, t, n = null) {
   const i = {
-    Ae: t?.equals != null ? t.equals : isEqual,
-    me: !!t?.pureWrite,
-    De: t?.unobserved,
-    Re: e,
+    _e: t?.equals != null ? t.equals : isEqual,
+    We: !!t?.pureWrite,
+    ke: t?.unobserved,
+    ae: e,
     p: null,
-    ye: null,
-    ce: clock,
+    Le: null,
+    ee: clock,
     L: n,
-    P: n?.N || null,
-    B: NOT_PENDING
+    C: n?.P || null,
+    le: NOT_PENDING
   };
-  n && (n.N = i);
+  n && (n.P = i);
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.Y = true;
+  n.Oe = true;
   return n;
 }
 function optimisticComputed(e, t, n) {
   const i = computed(e, t, n);
-  i.Y = true;
+  i.Oe = true;
   return i;
 }
-function getPendingSignal(e) {
-  if (!e.Le) {
-    e.Le = optimisticSignal(false, { pureWrite: true });
-    if (e.k) {
-      e.Le.k = e;
-    }
-    if (computePendingState(e)) setSignal(e.Le, true);
-  }
-  return e.Le;
-}
-function computePendingState(e) {
-  const t = e;
-  if (e.Y && e.B !== NOT_PENDING) {
-    if (t.Oe & STATUS_PENDING && !(t.Oe & STATUS_UNINITIALIZED)) return true;
-    if (e.k) {
-      const t = e.W ? findLane(e.W) : null;
-      return !!(t && t.G.size > 0);
-    }
-    return true;
-  }
-  if (e.B !== NOT_PENDING && !(t.Oe & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Oe & STATUS_PENDING && !(t.Oe & STATUS_UNINITIALIZED));
-}
-function getPendingValueComputed(e) {
-  if (!e.Ne) {
-    const t = pendingReadActive;
-    pendingReadActive = false;
-    const n = pendingCheckActive;
-    pendingCheckActive = false;
-    const i = context;
-    context = null;
-    e.Ne = optimisticComputed(() => read(e));
-    e.Ne.k = e;
-    context = i;
-    pendingCheckActive = n;
-    pendingReadActive = t;
-  }
-  return e.Ne;
-}
-function updatePendingSignal(e) {
-  if (e.Le) {
-    const t = computePendingState(e);
-    const n = e.Le;
-    setSignal(n, t);
-    if (!t && n.W) {
-      const t = resolveLane(e);
-      if (t && t.G.size > 0) {
-        const e = findLane(n.W);
-        if (e !== t) {
-          mergeLanes(t, e);
-        }
-      }
-      clearLaneEntry(n);
-      n.W = undefined;
-    }
-  }
-}
 function isEqual(e, t) {
   return e === t;
 }
@@ -1140,12 +1163,12 @@ function read(e) {
     pendingReadActive = false;
     const i = read(t);
     pendingReadActive = n;
-    if (t.Oe & STATUS_PENDING) return e.Re;
-    if (stale && currentOptimisticLane && t.W) {
-      const n = findLane(t.W);
+    if (t.fe & STATUS_PENDING) return e.ae;
+    if (stale && currentOptimisticLane && t.re) {
+      const n = findLane(t.re);
       const i = findLane(currentOptimisticLane);
-      if (n !== i && n.G.size > 0) {
-        return e.Re;
+      if (n !== i && n.W.size > 0) {
+        return e.ae;
       }
     }
     return i;
@@ -1159,18 +1182,18 @@ function read(e) {
       foundPending = true;
     }
     pendingCheckActive = i;
-    return e.Re;
+    return e.ae;
   }
   let t = context;
   if (t?.i) t = t.l;
-  if (refreshing && e.U) recompute(e);
+  if (refreshing && e.k) recompute(e);
   if (t && tracking) {
-    if (e.U && e._ & REACTIVE_DISPOSED) recompute(e);
+    if (e.k && e._ & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
     const n = e.L || e;
-    if (n.U) {
+    if (n.k) {
       const i = e._ & REACTIVE_ZOMBIE;
-      if (n.u >= (i ? zombieQueue.C : dirtyQueue.C)) {
+      if (n.u >= (i ? zombieQueue.N : dirtyQueue.N)) {
         markNode(t);
         markHeap(i ? zombieQueue : dirtyQueue);
         updateIfNecessary(n);
@@ -1182,122 +1205,73 @@ function read(e) {
     }
   }
   const n = e.L || e;
-  if (t && n.Oe & STATUS_PENDING && !(stale && n.$ && activeTransition !== n.$)) {
+  if (t && n.fe & STATUS_PENDING && !(stale && n.ie && activeTransition !== n.ie)) {
     if (currentOptimisticLane) {
-      const i = n.W;
+      const i = n.re;
       const r = findLane(currentOptimisticLane);
       if (i && findLane(i) === r && !hasActiveOverride(n)) {
         if (!tracking) link(e, t);
-        throw n.se;
+        throw n.Z;
       }
     } else {
       if (!tracking) link(e, t);
-      throw n.se;
+      throw n.Z;
     }
   }
-  if (e.U && e.Oe & STATUS_ERROR) {
-    if (e.ce < clock) {
+  if (e.k && e.fe & STATUS_ERROR) {
+    if (e.ee < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.se;
+    } else throw e.Z;
   }
   return !t ||
     currentOptimisticLane !== null ||
-    e.B === NOT_PENDING ||
-    (stale && e.$ && activeTransition !== e.$)
-    ? e.Re
-    : e.B;
+    e.le === NOT_PENDING ||
+    (stale && e.ie && activeTransition !== e.ie)
+    ? e.ae
+    : e.le;
 }
 function setSignal(e, t) {
-  if (e.$ && activeTransition !== e.$) globalQueue.initTransition(e.$);
-  const n = e.Y && !projectionWriteActive;
-  const i = n ? e.Re : e.B === NOT_PENDING ? e.Re : e.B;
+  if (e.ie && activeTransition !== e.ie) globalQueue.initTransition(e.ie);
+  const n = e.Oe && !projectionWriteActive;
+  const i = n ? e.ae : e.le === NOT_PENDING ? e.ae : e.le;
   if (typeof t === "function") t = t(i);
-  const r = !e.Ae || !e.Ae(i, t);
+  const r = !e._e || !e._e(i, t);
   if (!r) {
-    if (n && e.B !== NOT_PENDING && e.U) {
+    if (n && e.le !== NOT_PENDING && e.k) {
       insertSubs(e, true);
       schedule();
     }
     return t;
   }
   if (n) {
-    const n = globalQueue.ee.includes(e);
-    if (e.$ && n) {
-      globalQueue.initTransition(e.$);
+    const n = globalQueue.j.includes(e);
+    if (e.ie && n) {
+      globalQueue.initTransition(e.ie);
     }
-    if (e.B === NOT_PENDING) {
-      e.B = e.Re;
+    if (e.le === NOT_PENDING) {
+      e.le = e.ae;
     }
     if (!n) {
-      globalQueue.ee.push(e);
+      globalQueue.j.push(e);
     }
-    e.K = (e.K || 0) + 1;
+    e.Re = (e.Re || 0) + 1;
     const i = getOrCreateLane(e);
-    e.W = i;
-    e.Re = t;
+    e.re = i;
+    e.ae = t;
   } else {
-    if (e.B === NOT_PENDING) globalQueue.J.push(e);
-    e.B = t;
+    if (e.le === NOT_PENDING) globalQueue.H.push(e);
+    e.le = t;
   }
   updatePendingSignal(e);
-  if (e.Ne) {
-    setSignal(e.Ne, t);
+  if (e.Ie) {
+    setSignal(e.Ie, t);
   }
-  e.ce = clock;
+  e.ee = clock;
   insertSubs(e, n);
   schedule();
   return t;
 }
-const PENDING_OWNER = {};
-function getObserver() {
-  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
-  return tracking ? context : null;
-}
-function getOwner() {
-  return context;
-}
-function onCleanup(e) {
-  if (!context) return e;
-  if (!context._e) context._e = e;
-  else if (Array.isArray(context._e)) context._e.push(e);
-  else context._e = [context._e, e];
-  return e;
-}
-function createOwner(e) {
-  const t = context;
-  const n = {
-    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
-    i: true,
-    l: t?.i ? t.l : t,
-    pe: null,
-    we: null,
-    _e: null,
-    Te: t?.Te ?? globalQueue,
-    Ve: t?.Ve || defaultContext,
-    be: 0,
-    Se: null,
-    Ie: null,
-    o: t,
-    dispose(e = true) {
-      disposeChildren(n, e);
-    }
-  };
-  if (t) {
-    const e = t.pe;
-    if (e === null) {
-      t.pe = n;
-    } else {
-      n.we = e;
-      t.pe = n;
-    }
-  }
-  return n;
-}
-function createRoot(e, t) {
-  const n = createOwner(t);
-  return runWithOwner(n, () => e(n.dispose));
-}
 function runWithOwner(e, t) {
   const n = context;
   const i = tracking;
@@ -1310,6 +1284,63 @@ function runWithOwner(e, t) {
     tracking = i;
   }
 }
+function getPendingSignal(e) {
+  if (!e.Qe) {
+    e.Qe = optimisticSignal(false, { pureWrite: true });
+    if (e.Ee) {
+      e.Qe.Ee = e;
+    }
+    if (computePendingState(e)) setSignal(e.Qe, true);
+  }
+  return e.Qe;
+}
+function computePendingState(e) {
+  const t = e;
+  if (e.Oe && e.le !== NOT_PENDING) {
+    if (t.fe & STATUS_PENDING && !(t.fe & STATUS_UNINITIALIZED)) return true;
+    if (e.Ee) {
+      const t = e.re ? findLane(e.re) : null;
+      return !!(t && t.W.size > 0);
+    }
+    return true;
+  }
+  if (e.le !== NOT_PENDING && !(t.fe & STATUS_UNINITIALIZED)) return true;
+  return !!(t.fe & STATUS_PENDING && !(t.fe & STATUS_UNINITIALIZED));
+}
+function updatePendingSignal(e) {
+  if (e.Qe) {
+    const t = computePendingState(e);
+    const n = e.Qe;
+    setSignal(n, t);
+    if (!t && n.re) {
+      const t = resolveLane(e);
+      if (t && t.W.size > 0) {
+        const e = findLane(n.re);
+        if (e !== t) {
+          mergeLanes(t, e);
+        }
+      }
+      signalLanes.delete(n);
+      n.re = undefined;
+    }
+  }
+}
+function getPendingValueComputed(e) {
+  if (!e.Ie) {
+    const t = pendingReadActive;
+    pendingReadActive = false;
+    const n = pendingCheckActive;
+    pendingCheckActive = false;
+    const i = context;
+    context = null;
+    e.Ie = optimisticComputed(() => read(e));
+    e.Ie.Ee = e;
+    context = i;
+    pendingCheckActive = n;
+    pendingReadActive = t;
+  }
+  return e.Ie;
+}
 function staleValues(e, t = true) {
   const n = stale;
   stale = t;
@@ -1387,85 +1418,49 @@ function hasContext(e, t) {
 function isUndefined(e) {
   return typeof e === "undefined";
 }
-function effect(e, t, n, i, r) {
-  let o = false;
-  const s = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
-    ...r,
-    equals: () => {
-      s.Ee = !s.se;
-      if (o) s.Te.enqueue(s.fe, runEffect.bind(s));
-      return false;
-    },
-    lazy: true
-  });
-  s.Ue = i;
-  s.ke = t;
-  s.We = n;
-  s.Qe = undefined;
-  s.fe = r?.render ? EFFECT_RENDER : EFFECT_USER;
-  s.Pe = (e, t) => {
-    const n = e !== undefined ? e : s.Oe;
-    const i = t !== undefined ? t : s.se;
-    if (n & STATUS_ERROR) {
-      let e = i;
-      s.Te.notify(s, STATUS_PENDING, 0);
-      if (s.fe === EFFECT_USER) {
+function restoreTransition(e, t) {
+  globalQueue.initTransition(e);
+  const n = t();
+  flush();
+  return n;
+}
+function action(e) {
+  return (...t) =>
+    new Promise((n, i) => {
+      const r = e(...t);
+      globalQueue.initTransition();
+      let o = activeTransition;
+      o.te.push(r);
+      const done = (e, t) => {
+        o = currentTransition(o);
+        const s = o.te.indexOf(r);
+        if (s >= 0) o.te.splice(s, 1);
+        setActiveTransition(o);
+        schedule();
+        t ? i(t) : n(e);
+      };
+      const step = (e, t) => {
+        let n;
         try {
-          return s.We
-            ? s.We(e, () => {
-                s.Qe?.();
-                s.Qe = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
+          n = t ? r.throw(e) : r.next(e);
+        } catch (e) {
+          return done(undefined, e);
         }
-      }
-      if (!s.Te.notify(s, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (s.fe === EFFECT_RENDER) s.Te.notify(s, STATUS_PENDING | STATUS_ERROR, n, i);
-  };
-  recompute(s, true);
-  !r?.defer && (s.fe === EFFECT_USER ? s.Te.enqueue(s.fe, runEffect.bind(s)) : runEffect.call(s));
-  o = true;
-  onCleanup(() => s.Qe?.());
-}
-function runEffect() {
-  if (!this.Ee || this._ & REACTIVE_DISPOSED) return;
-  this.Qe?.();
-  this.Qe = undefined;
-  try {
-    this.Qe = this.ke(this.Re, this.Ue);
-  } catch (e) {
-    if (!this.Te.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-  } finally {
-    this.Ue = this.Re;
-    this.Ee = false;
-  }
-}
-function trackedEffect(e, t) {
-  const run = () => {
-    if (!n.Ee || n._ & REACTIVE_DISPOSED) return;
-    n.Ee = false;
-    recompute(n);
-  };
-  const n = computed(
-    () => {
-      try {
-        n.Qe?.();
-        n.Qe = undefined;
-        n.Qe = staleValues(e) || undefined;
-      } finally {
-      }
-    },
-    undefined,
-    { ...t, lazy: true, pureWrite: true }
-  );
-  n.Qe = undefined;
-  n.Ee = true;
-  n.fe = EFFECT_TRACKED;
-  n.de = run;
-  n.Te.enqueue(EFFECT_USER, run);
-  onCleanup(() => n.Qe?.());
+        if (n instanceof Promise)
+          return void n.then(run, e => restoreTransition(o, () => step(e, true)));
+        run(n);
+      };
+      const run = e => {
+        if (e.done) return done(e.value);
+        if (e.value instanceof Promise)
+          return void e.value.then(
+            e => restoreTransition(o, () => step(e)),
+            e => restoreTransition(o, () => step(e, true))
+          );
+        restoreTransition(o, () => step(e.value));
+      };
+      step();
+    });
 }
 function createSignal(e, t, n) {
   if (typeof e === "function") {
@@ -1644,7 +1639,7 @@ function applyState(e, t, n, i) {
       const E = unwrap(getOverrideValue(o, s, u, a));
       let T = unwrap(e[a]);
       if (E === T) continue;
-      if (!E || !isWrappable(E) || (n(E) != null && n(E) !== n(T))) {
+      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, r) : T);
       } else applyState(T, wrap(E, r), n, i);
@@ -1699,7 +1694,7 @@ function createProjectionInternal(e, t = {}, n) {
       r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(o);
     });
   });
-  i.ve = true;
+  i.Ue = true;
   return { store: o, node: i };
 }
 function createProjection(e, t = {}, n) {
@@ -1799,7 +1794,7 @@ function getNode(e, t, n, i, r = isEqual, o) {
     },
     i
   );
-  if (o) s.Y = true;
+  if (o) s.Oe = true;
   return (e[t] = s);
 }
 function trackSelf(e, t = $TRACK) {
@@ -1852,7 +1847,7 @@ const storeTraps = {
       if (e && e.get) return e.get.call(n);
     }
     if (writeOnly(n)) {
-      let n = r && (s || !u) ? (r.B !== NOT_PENDING ? (r.Y ? r.Re : r.B) : r.Re) : c[t];
+      let n = r && (s || !u) ? (r.le !== NOT_PENDING ? (r.Oe ? r.ae : r.le) : r.ae) : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
@@ -1901,8 +1896,8 @@ const storeTraps = {
     if (writeOnly(i)) {
       if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.$) {
-          globalQueue.initTransition(t.$);
+        if (t?.ie) {
+          globalQueue.initTransition(t.ie);
         }
       }
       untrack(() => {
@@ -2091,7 +2086,7 @@ function deep(e) {
   return e[$DEEP];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.re ||= clearOptimisticStore;
+  GlobalQueue.X ||= clearOptimisticStore;
   const i = typeof e === "function";
   const r = (i ? t : e) ?? {};
   const o = i ? e : undefined;
@@ -2108,7 +2103,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].W = undefined;
+          i[e].re = 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;
@@ -2116,7 +2111,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].W = undefined;
+        i[$TRACK].re = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2167,7 +2162,7 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
         setProjectionWriteActive(false);
       }
     });
-    i.ve = true;
+    i.Ue = true;
   }
   return { store: o, node: i };
 }
@@ -2352,9 +2347,9 @@ function mapArray(e, t, n) {
   return createMemo(
     updateKeyedMap.bind({
       xe: createOwner(),
-      Ge: 0,
-      Me: e,
-      Fe: [],
+      Fe: 0,
+      Ge: e,
+      Me: [],
       $e: t,
       He: [],
       je: [],
@@ -2367,7 +2362,7 @@ function mapArray(e, t, n) {
 }
 const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const e = this.Me() || [],
+  const e = this.Ge() || [],
     t = e.length;
   e[$TRACK];
   runWithOwner(this.xe, () => {
@@ -2393,26 +2388,26 @@ function updateKeyedMap() {
               return this.$e(() => t);
             };
     if (t === 0) {
-      if (this.Ge !== 0) {
+      if (this.Fe !== 0) {
         this.xe.dispose(false);
         this.je = [];
-        this.Fe = [];
+        this.Me = [];
         this.He = [];
-        this.Ge = 0;
+        this.Fe = 0;
         this.Ye && (this.Ye = []);
         this.Be && (this.Be = []);
       }
       if (this.Xe && !this.He[0]) {
         this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
       }
-    } else if (this.Ge === 0) {
+    } else if (this.Fe === 0) {
       if (this.je[0]) this.je[0].dispose();
       this.He = new Array(t);
       for (i = 0; i < t; i++) {
-        this.Fe[i] = e[i];
+        this.Me[i] = e[i];
         this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
       }
-      this.Ge = t;
+      this.Fe = t;
     } else {
       let o,
         s,
@@ -2426,17 +2421,17 @@ function updateKeyedMap() {
         d = this.Ye ? new Array(t) : undefined,
         R = this.Be ? new Array(t) : undefined;
       for (
-        o = 0, s = Math.min(this.Ge, t);
-        o < s && (this.Fe[o] === e[o] || (this.Ye && compare(this.Ke, this.Fe[o], e[o])));
+        o = 0, s = Math.min(this.Fe, t);
+        o < s && (this.Me[o] === e[o] || (this.Ye && compare(this.Ke, this.Me[o], e[o])));
         o++
       ) {
         if (this.Ye) setSignal(this.Ye[o], e[o]);
       }
       for (
-        s = this.Ge - 1, u = t - 1;
+        s = this.Fe - 1, u = t - 1;
         s >= o &&
         u >= o &&
-        (this.Fe[s] === e[u] || (this.Ye && compare(this.Ke, this.Fe[s], e[u])));
+        (this.Me[s] === e[u] || (this.Ye && compare(this.Ke, this.Me[s], e[u])));
         s--, u--
       ) {
         E[u] = this.He[s];
@@ -2454,7 +2449,7 @@ function updateKeyedMap() {
         a.set(l, i);
       }
       for (n = o; n <= s; n++) {
-        c = this.Fe[n];
+        c = this.Me[n];
         l = this.Ke ? this.Ke(c) : c;
         i = a.get(l);
         if (i !== undefined && i !== -1) {
@@ -2482,8 +2477,8 @@ function updateKeyedMap() {
           this.He[i] = runWithOwner((this.je[i] = createOwner()), r);
         }
       }
-      this.He = this.He.slice(0, (this.Ge = t));
-      this.Fe = e.slice(0);
+      this.He = this.He.slice(0, (this.Fe = t));
+      this.Me = e.slice(0);
     }
   });
   return this.He;
@@ -2491,7 +2486,7 @@ function updateKeyedMap() {
 function repeat(e, t, n) {
   return updateRepeat.bind({
     xe: createOwner(),
-    Ge: 0,
+    Fe: 0,
     qe: 0,
     ze: e,
     $e: t,
@@ -2506,11 +2501,11 @@ function updateRepeat() {
   const t = this.Ze?.() || 0;
   runWithOwner(this.xe, () => {
     if (e === 0) {
-      if (this.Ge !== 0) {
+      if (this.Fe !== 0) {
         this.xe.dispose(false);
         this.je = [];
         this.He = [];
-        this.Ge = 0;
+        this.Fe = 0;
       }
       if (this.Xe && !this.He[0]) {
         this.He[0] = runWithOwner((this.je[0] = createOwner()), this.Xe);
@@ -2518,12 +2513,12 @@ function updateRepeat() {
       return;
     }
     const n = t + e;
-    const i = this.qe + this.Ge;
-    if (this.Ge === 0 && this.je[0]) this.je[0].dispose();
+    const i = this.qe + this.Fe;
+    if (this.Fe === 0 && this.je[0]) this.je[0].dispose();
     for (let e = n; e < i; e++) this.je[e - this.qe].dispose();
     if (this.qe < t) {
       let e = this.qe;
-      while (e < t && e < this.Ge) this.je[e++].dispose();
+      while (e < t && e < this.Fe) this.je[e++].dispose();
       this.je.splice(0, t - this.qe);
       this.He.splice(0, t - this.qe);
     } else if (this.qe > t) {
@@ -2544,7 +2539,7 @@ function updateRepeat() {
     }
     this.He = this.He.slice(0, e);
     this.qe = t;
-    this.Ge = e;
+    this.Fe = e;
   });
   return this.He;
 }
@@ -2553,119 +2548,68 @@ function compare(e, t, n) {
 }
 function boundaryComputed(e, t) {
   const n = computed(e, undefined, { lazy: true });
-  n.Pe = (e, t) => {
-    const i = e !== undefined ? e : n.Oe;
-    const r = t !== undefined ? t : n.se;
-    n.Oe &= ~n.Je;
-    n.Te.notify(n, n.Je, i, r);
+  n.pe = (e, t) => {
+    const i = e !== undefined ? e : n.fe;
+    const r = t !== undefined ? t : n.Z;
+    n.fe &= ~n.Je;
+    n.ue.notify(n, n.Je, i, r);
   };
   n.Je = t;
-  n.ve = true;
+  n.Ue = true;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.Te;
-  r.addChild((e.Te = n));
-  onCleanup(() => r.removeChild(e.Te));
+  const r = e.ue;
+  r.addChild((e.ue = n));
+  onCleanup(() => r.removeChild(e.ue));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
   });
 }
-class ConditionalQueue extends Queue {
+class CollectionQueue extends Queue {
   et;
   tt = new Set();
-  J = new Set();
+  nt = signal(false, { pureWrite: true });
+  it = false;
   constructor(e) {
     super();
     this.et = e;
   }
   run(e) {
-    if (!e || read(this.et)) return;
-    return super.run(e);
-  }
-  notify(e, t, n, i) {
-    if (read(this.et)) {
-      if (t & STATUS_PENDING) {
-        if (n & STATUS_PENDING) {
-          this.J.add(e);
-          t &= ~STATUS_PENDING;
-        } else if (this.J.delete(e)) t &= ~STATUS_PENDING;
-      }
-      if (t & STATUS_ERROR) {
-        if (n & STATUS_ERROR) {
-          this.tt.add(e);
-          t &= ~STATUS_ERROR;
-        } else if (this.tt.delete(e)) t &= ~STATUS_ERROR;
-      }
-    }
-    return t ? super.notify(e, t, n, i ?? e.se) : true;
-  }
-}
-class CollectionQueue extends Queue {
-  nt;
-  it = new Set();
-  et = signal(false, { pureWrite: true });
-  rt = false;
-  constructor(e) {
-    super();
-    this.nt = e;
-  }
-  run(e) {
-    if (!e || read(this.et)) return;
+    if (!e || read(this.nt)) return;
     return super.run(e);
   }
   notify(e, t, n, i) {
-    if (!(t & this.nt) || (this.nt & STATUS_PENDING && this.rt)) return super.notify(e, t, n, i);
-    if (n & this.nt) {
-      const t = i?.t || e.se?.t;
+    if (!(t & this.et) || (this.et & STATUS_PENDING && this.it)) return super.notify(e, t, n, i);
+    if (n & this.et) {
+      const t = i?.t || e.Z?.t;
       if (t) {
-        const e = this.it.size === 0;
-        this.it.add(t);
-        if (e) setSignal(this.et, true);
+        const e = this.tt.size === 0;
+        this.tt.add(t);
+        if (e) setSignal(this.nt, true);
       }
     }
-    t &= ~this.nt;
+    t &= ~this.et;
     return t ? super.notify(e, t, n, i) : true;
   }
   checkSources() {
-    for (const e of this.it) {
-      if (!(e.Oe & this.nt)) this.it.delete(e);
-    }
-    if (!this.it.size) setSignal(this.et, false);
-  }
-}
-var BoundaryMode;
-(function (e) {
-  e["VISIBLE"] = "visible";
-  e["HIDDEN"] = "hidden";
-})(BoundaryMode || (BoundaryMode = {}));
-function createBoundary(e, t) {
-  const n = createOwner();
-  const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
-  const r = createBoundChildren(n, e, i, 0);
-  computed(() => {
-    const e = read(i.et);
-    r.Je = e ? STATUS_ERROR | STATUS_PENDING : 0;
-    if (!e) {
-      i.J.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING, e.se));
-      i.tt.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR, e.se));
-      i.J.clear();
-      i.tt.clear();
+    for (const e of this.tt) {
+      if (!(e.fe & this.et)) this.tt.delete(e);
     }
-  });
-  return () => (read(i.et) ? undefined : read(r));
+    if (!this.tt.size) setSignal(this.nt, false);
+  }
 }
 function createCollectionBoundary(e, t, n) {
   const i = createOwner();
   const r = new CollectionQueue(e);
   const o = createBoundChildren(i, t, r, e);
   const s = computed(() => {
-    if (!read(r.et)) {
+    if (!read(r.nt)) {
       const e = read(o);
-      if (!untrack(() => read(r.et))) {
-        r.rt = true;
+      if (!untrack(() => read(r.nt))) {
+        r.it = true;
         return e;
       }
     }
@@ -2678,10 +2622,10 @@ function createLoadBoundary(e, t) {
 }
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.it.values().next().value;
-    const i = n.se?.cause ?? n.se;
+    let n = e.tt.values().next().value;
+    const i = n.Z?.cause ?? n.Z;
     return t(i, () => {
-      for (const t of e.it) recompute(t);
+      for (const t of e.tt) recompute(t);
       schedule();
     });
   });
@@ -2744,7 +2688,6 @@ export {
   NotReadyError,
   SUPPORTS_PROXY,
   action,
-  createBoundary,
   createContext,
   createEffect,
   createErrorBoundary,
@@ -2752,6 +2695,7 @@ export {
   createMemo,
   createOptimistic,
   createOptimisticStore,
+  createOwner,
   createProjection,
   createReaction,
   createRenderEffect,