@solidjs/signals 0.13.13 → 2.0.0-beta.11

package/dist/prod.js

@@ -33,6 +33,14 @@ const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const REACTIVE_LAZY = 1 << 9;
+const REACTIVE_MANUAL_WRITE = 1 << 10;
+const CONFIG_OWNED_WRITE = 1 << 0;
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+const CONFIG_TRANSPARENT = 1 << 2;
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+const CONFIG_AUTO_DISPOSE = 1 << 5;
+const CONFIG_SYNC = 1 << 6;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -45,6 +53,16 @@ const STORE_SNAPSHOT_PROPS = "sp";
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
 const $REFRESH = Symbol("refresh");
+const diagnosticListeners = new Set();
+const diagnosticCaptures = new Set();
+let diagnosticSequence = 0;
+const DEV$1 = undefined;
+function emitDiagnostic(e) {
+  const t = { sequence: ++diagnosticSequence, ...e };
+  for (const e of diagnosticListeners) e(t);
+  for (const e of diagnosticCaptures) e.push(t);
+  return t;
+}
 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;
@@ -52,131 +70,226 @@ function actualInsertIntoHeap(e, t) {
   const r = t.l[i];
   if (r === undefined) t.l[i] = e;
   else {
-    const t = r.T;
-    t.S = e;
-    e.T = t;
-    r.T = e;
+    const t = r.S;
+    t.T = e;
+    e.S = t;
+    r.S = e;
   }
-  if (i > t.R) t.R = i;
+  if (i > t.O) t.O = i;
 }
 function insertIntoHeap(e, t) {
-  let n = e.O;
-  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  let n = e._;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (n & REACTIVE_CHECK) {
-    e.O = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else e.O = n | REACTIVE_IN_HEAP;
+    e._ = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e._ = n | REACTIVE_IN_HEAP;
   if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 function insertIntoHeapHeight(e, t) {
-  let n = e.O;
-  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
-  e.O = n | REACTIVE_IN_HEAP_HEIGHT;
+  let n = e._;
+  if (
+    n &
+    (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)
+  )
+    return;
+  e._ = n | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(e, t);
 }
 function deleteFromHeap(e, t) {
-  const n = e.O;
+  const n = e._;
   if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  e.O = n & -25;
+  e._ = n & -25;
   const i = e.o;
-  if (e.T === e) t.l[i] = undefined;
+  if (e.S === e) t.l[i] = undefined;
   else {
-    const n = e.S;
+    const n = e.T;
     const r = t.l[i];
     const s = n ?? r;
     if (e === r) t.l[i] = n;
-    else e.T.S = n;
-    s.T = e.T;
+    else e.S.T = n;
+    s.S = e.S;
   }
-  e.T = e;
-  e.S = undefined;
+  e.S = e;
+  e.T = undefined;
 }
 function markHeap(e) {
-  if (e._) return;
-  e._ = true;
-  for (let t = 0; t <= e.R; t++) {
-    for (let n = e.l[t]; n !== undefined; n = n.S) {
-      if (n.O & REACTIVE_IN_HEAP) markNode(n);
+  if (e.R) return;
+  e.R = true;
+  for (let t = 0; t <= e.O; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.T) {
+      if (n._ & REACTIVE_IN_HEAP) markNode(n);
     }
   }
 }
 function markNode(e, t = REACTIVE_DIRTY) {
-  const n = e.O;
+  const n = e._;
   if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-  e.O = (n & -4) | t;
-  for (let t = e.I; t !== null; t = t.h) {
-    markNode(t.p, REACTIVE_CHECK);
+  e._ = (n & -4) | t;
+  for (let t = e.I; t !== null; t = t.p) {
+    markNode(t.h, REACTIVE_CHECK);
   }
-  if (e.A !== null) {
-    for (let t = e.A; t !== null; t = t.N) {
-      for (let e = t.I; e !== null; e = e.h) {
-        markNode(e.p, REACTIVE_CHECK);
+  if (e.N !== null) {
+    for (let t = e.N; t !== null; t = t.A) {
+      for (let e = t.I; e !== null; e = e.p) {
+        markNode(e.h, REACTIVE_CHECK);
       }
     }
   }
 }
 function runHeap(e, t) {
-  e._ = false;
-  for (e.P = 0; e.P <= e.R; e.P++) {
-    let n = e.l[e.P];
+  e.R = false;
+  for (e.C = 0; e.C <= e.O; e.C++) {
+    let n = e.l[e.C];
     while (n !== undefined) {
-      if (n.O & REACTIVE_IN_HEAP) t(n);
+      if (n._ & REACTIVE_IN_HEAP) t(n);
       else adjustHeight(n, e);
-      n = e.l[e.P];
+      n = e.l[e.C];
     }
   }
-  e.R = 0;
+  e.O = 0;
 }
 function adjustHeight(e, t) {
   deleteFromHeap(e, t);
   let n = e.o;
-  for (let t = e.C; t; t = t.D) {
+  for (let t = e.P; t; t = t.D) {
     const e = t.m;
     const i = e.V || e;
     if (i.L && i.o >= n) n = i.o + 1;
   }
   if (e.o !== n) {
     e.o = n;
-    for (let n = e.I; n !== null; n = n.h) {
-      insertIntoHeapHeight(n.p, t);
+    for (let n = e.I; n !== null; n = n.p) {
+      insertIntoHeapHeight(n.h, t);
     }
   }
 }
-const DEV$1 = undefined;
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(e) {
+  let t = signalLanes.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.U;
+  const i = n?.G ? findLane(n.G) : null;
+  t = { F: e, k: new Set(), W: [[], []], H: null, M: activeTransition, j: i };
+  signalLanes.set(e, t);
+  activeLanes.add(t);
+  e.$ = false;
+  return t;
+}
+function findLane(e) {
+  while (e.H) e = e.H;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.H = e;
+  for (const n of t.k) e.k.add(n);
+  e.W[0].push(...t.W[0]);
+  e.W[1].push(...t.W[1]);
+  return e;
+}
+function resolveLane(e) {
+  const t = e.G;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (activeLanes.has(n)) return n;
+  e.G = undefined;
+  return undefined;
+}
+function resolveTransition(e) {
+  return resolveLane(e)?.M ?? e.M;
+}
+function hasActiveOverride(e) {
+  return !!(e.K !== undefined && e.K !== NOT_PENDING);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const i = e.G;
+  if (i) {
+    if (i.H) {
+      e.G = t;
+      return;
+    }
+    const r = findLane(i);
+    if (activeLanes.has(r)) {
+      if (r !== n && !hasActiveOverride(e)) {
+        if (n.j && findLane(n.j) === r) {
+          e.G = t;
+        } else if (r.j && findLane(r.j) === n);
+        else mergeLanes(n, r);
+      }
+      return;
+    }
+  }
+  e.G = t;
+}
 const transitions = new Set();
-const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
-const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
+const dirtyQueue = { l: new Array(2e3).fill(undefined), R: false, C: 0, O: 0 };
+const zombieQueue = { l: new Array(2e3).fill(undefined), R: false, C: 0, O: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let syncDepth = 0;
 let projectionWriteActive = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(e) {
+  transientStoreNodes.add(e);
+}
+function canUseSimpleSyncFlush(e) {
+  return (
+    transitions.size === 0 &&
+    activeLanes.size === 0 &&
+    e.Y.length === 0 &&
+    e.Z.length === 0 &&
+    e.q.size === 0 &&
+    transientStoreNodes.size === 0
+  );
+}
+function sweepTransientStoreNodes() {
+  if (transientStoreNodes.size === 0) return;
+  for (const e of transientStoreNodes) {
+    if (e.I !== null) {
+      transientStoreNodes.delete(e);
+      continue;
+    }
+    if (e.B !== NOT_PENDING) continue;
+    if (e.K !== undefined && e.K !== NOT_PENDING) continue;
+    transientStoreNodes.delete(e);
+    e.X?.();
+  }
+}
 function enforceLoadingBoundary(e) {}
 function shouldReadStashedOptimisticValue(e) {
   return !!stashedOptimisticReads?.has(e);
 }
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.U || t.k.size > 0) continue;
-    const n = t.G[e - 1];
+    if (t.H || t.k.size > 0) continue;
+    const n = t.W[e - 1];
     if (n.length) {
-      t.G[e - 1] = [];
+      t.W[e - 1] = [];
       runQueue(n, e);
     }
   }
 }
 function queueStashedOptimisticEffects(e) {
-  for (let t = e.I; t !== null; t = t.h) {
-    const e = t.p;
-    if (!e.W) continue;
-    if (e.W === EFFECT_TRACKED) {
-      if (!e.H) {
-        e.H = true;
-        e.F.enqueue(EFFECT_USER, e.M);
+  for (let t = e.I; t !== null; t = t.p) {
+    const e = t.h;
+    if (!e.J) continue;
+    if (e.J === EFFECT_TRACKED) {
+      if (!e.ee) {
+        e.ee = true;
+        e.te.enqueue(EFFECT_USER, e.ne);
       }
       continue;
     }
-    const n = e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (n.P > e.o) n.P = e.o;
+    const n = e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (n.C > e.o) n.C = e.o;
     insertIntoHeap(e, n);
   }
 }
@@ -184,66 +297,67 @@ function setProjectionWriteActive(e) {
   projectionWriteActive = e;
 }
 function mergeTransitionState(e, t) {
-  t.j = e;
-  e.$.push(...t.$);
-  for (const n of activeLanes) if (n.K === t) n.K = e;
-  e.Y.push(...t.Y);
-  for (const n of t.Z) e.Z.add(n);
-  for (const [n, i] of t.B) {
-    let t = e.B.get(n);
-    if (!t) e.B.set(n, (t = new Set()));
+  t.ie = e;
+  e.re.push(...t.re);
+  for (const n of activeLanes) if (n.M === t) n.M = e;
+  e.Z.push(...t.Z);
+  for (const n of t.q) e.q.add(n);
+  for (const [n, i] of t.se) {
+    let t = e.se.get(n);
+    if (!t) e.se.set(n, (t = new Set()));
     for (const e of i) t.add(e);
   }
+  for (const n of t.oe) e.oe.add(n);
 }
 function resolveOptimisticNodes(e) {
   for (let t = 0; t < e.length; t++) {
     const n = e[t];
-    n.q = undefined;
-    if (n.X !== NOT_PENDING) {
-      n.J = n.X;
-      n.X = NOT_PENDING;
+    n.G = undefined;
+    if (n.B !== NOT_PENDING) {
+      n.ue = n.B;
+      n.B = NOT_PENDING;
     }
-    const i = n.ee;
-    n.ee = NOT_PENDING;
-    if (i !== NOT_PENDING && n.J !== i) insertSubs(n, true);
-    n.K = null;
+    const i = n.K;
+    n.K = NOT_PENDING;
+    if (i !== NOT_PENDING && n.ue !== i) insertSubs(n, true);
+    n.M = null;
   }
   e.length = 0;
 }
 function cleanupCompletedLanes(e) {
   for (const t of activeLanes) {
-    const n = e ? t.K === e : !t.K;
+    const n = e ? t.M === e : !t.M;
     if (!n) continue;
-    if (!t.U) {
-      if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
-      if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
+    if (!t.H) {
+      if (t.W[0].length) runQueue(t.W[0], EFFECT_RENDER);
+      if (t.W[1].length) runQueue(t.W[1], EFFECT_USER);
     }
-    if (t.te.q === t) t.te.q = undefined;
+    if (t.F.G === t) t.F.G = undefined;
     t.k.clear();
-    t.G[0].length = 0;
-    t.G[1].length = 0;
+    t.W[0].length = 0;
+    t.W[1].length = 0;
     activeLanes.delete(t);
-    signalLanes.delete(t.te);
+    signalLanes.delete(t.F);
   }
 }
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.ne && !projectionWriteActive) queueMicrotask(flush);
+  if (!syncDepth && !globalQueue.le && !projectionWriteActive) queueMicrotask(flush);
 }
 class Queue {
   i = null;
-  ie = [[], []];
-  re = [];
+  ce = [[], []];
+  Y = [];
   created = clock;
   addChild(e) {
-    this.re.push(e);
+    this.Y.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.re.indexOf(e);
+    const t = this.Y.indexOf(e);
     if (t >= 0) {
-      this.re.splice(t, 1);
+      this.Y.splice(t, 1);
       e.i = null;
     }
   }
@@ -252,81 +366,84 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.ie[e - 1].length) {
-      const t = this.ie[e - 1];
-      this.ie[e - 1] = [];
+    if (this.ce[e - 1].length) {
+      const t = this.ce[e - 1];
+      this.ce[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.re.length; t++) this.re[t].run?.(e);
+    for (let t = 0; t < this.Y.length; t++) this.Y[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.G[e - 1].push(t);
+        n.W[e - 1].push(t);
       } else {
-        this.ie[e - 1].push(t);
+        this.ce[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.ie[0].push(...this.ie[0]);
-    e.ie[1].push(...this.ie[1]);
-    this.ie = [[], []];
-    for (let t = 0; t < this.re.length; t++) {
-      let n = this.re[t];
-      let i = e.re[t];
+    e.ce[0].push(...this.ce[0]);
+    e.ce[1].push(...this.ce[1]);
+    this.ce = [[], []];
+    for (let t = 0; t < this.Y.length; t++) {
+      let n = this.Y[t];
+      let i = e.Y[t];
       if (!i) {
-        i = { ie: [[], []], re: [] };
-        e.re[t] = i;
+        i = { ce: [[], []], Y: [] };
+        e.Y[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.ie[0].push(...e.ie[0]);
-    this.ie[1].push(...e.ie[1]);
-    for (let t = 0; t < e.re.length; t++) {
-      const n = e.re[t];
-      let i = this.re[t];
+    this.ce[0].push(...e.ce[0]);
+    this.ce[1].push(...e.ce[1]);
+    for (let t = 0; t < e.Y.length; t++) {
+      const n = e.Y[t];
+      let i = this.Y[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  ne = false;
-  se = [];
-  Y = [];
-  Z = new Set();
-  static oe;
-  static ue;
-  static ce = null;
+  le = false;
+  ae = null;
+  fe = [];
+  Z = [];
+  q = new Set();
+  static Ee;
+  static Se;
+  static Te;
+  static de = null;
   flush() {
-    if (this.ne) return;
-    this.ne = true;
+    if (this.le) return;
+    this.le = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.oe);
+      runHeap(dirtyQueue, GlobalQueue.Ee);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
           const e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.oe);
-          this.se = [];
-          this.Y = [];
-          this.Z = new Set();
+          runHeap(zombieQueue, GlobalQueue.Ee);
+          this.ae = null;
+          this.fe = [];
+          this.Z = [];
+          this.q = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(e.ae);
+          this.stashQueues(e.Oe);
           clock++;
-          scheduled = dirtyQueue.R >= dirtyQueue.P;
-          reassignPendingTransition(e.se);
+          scheduled = dirtyQueue.O >= dirtyQueue.C;
+          reassignPendingTransition(e.fe);
           activeTransition = null;
-          if (!e.$.length && e.Y.length) {
+          if (!e.re.length && !e.se.size && e.Z.length) {
             stashedOptimisticReads = new Set();
-            for (let t = 0; t < e.Y.length; t++) {
-              const n = e.Y[t];
-              if (n.L || n.le) continue;
+            for (let t = 0; t < e.Z.length; t++) {
+              const n = e.Z[t];
+              if (n.L || n._e & CONFIG_OWNED_WRITE) continue;
               stashedOptimisticReads.add(n);
               queueStashedOptimisticEffects(n);
             }
@@ -338,36 +455,44 @@ class GlobalQueue extends Queue {
           }
           return;
         }
-        this.se !== activeTransition.se && this.se.push(...activeTransition.se);
-        this.restoreQueues(activeTransition.ae);
+        this.fe !== activeTransition.fe && this.fe.push(...activeTransition.fe);
+        this.restoreQueues(activeTransition.Oe);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.se);
+        reassignPendingTransition(this.fe);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.oe);
-        finalizePureQueue();
+        if (canUseSimpleSyncFlush(this)) {
+          commitPendingNodes();
+          if (dirtyQueue.O >= dirtyQueue.C) {
+            runHeap(dirtyQueue, GlobalQueue.Ee);
+            commitPendingNodes();
+          }
+        } else {
+          if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ee);
+          finalizePureQueue();
+        }
       }
       clock++;
-      scheduled = dirtyQueue.R >= dirtyQueue.P;
-      runLaneEffects(EFFECT_RENDER);
+      scheduled = dirtyQueue.O >= dirtyQueue.C;
+      activeLanes.size && runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
-      runLaneEffects(EFFECT_USER);
+      activeLanes.size && runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
       if (false);
     } finally {
-      this.ne = false;
+      this.le = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.fe;
+        const t = i !== undefined ? i : e.Re;
         if (activeTransition && t) {
           const n = t.source;
-          let i = activeTransition.B.get(n);
-          if (!i) activeTransition.B.set(n, (i = new Set()));
+          let i = activeTransition.se.get(n);
+          if (!i) activeTransition.se.set(n, (i = new Set()));
           const r = i.size;
           i.add(e);
           if (i.size !== r) schedule();
@@ -380,17 +505,18 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.Ee === clock) return;
+    if (!e && activeTransition && activeTransition.Ie === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        Ee: clock,
-        se: [],
-        B: new Map(),
-        Y: [],
-        Z: new Set(),
-        $: [],
-        ae: { ie: [[], []], re: [] },
-        j: false
+        Ie: clock,
+        fe: [],
+        se: new Map(),
+        Z: [],
+        q: new Set(),
+        re: [],
+        Oe: { ce: [[], []], Y: [] },
+        ie: false,
+        oe: new Set()
       };
     } else if (e) {
       const t = activeTransition;
@@ -399,111 +525,173 @@ class GlobalQueue extends Queue {
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.Ee = clock;
-    if (this.se !== activeTransition.se) {
-      for (let e = 0; e < this.se.length; e++) {
-        const t = this.se[e];
-        t.K = activeTransition;
-        activeTransition.se.push(t);
+    activeTransition.Ie = clock;
+    if (this.ae !== null) {
+      this.ae.M = activeTransition;
+      activeTransition.fe.push(this.ae);
+      this.ae = null;
+    }
+    if (this.fe !== activeTransition.fe) {
+      for (let e = 0; e < this.fe.length; e++) {
+        const t = this.fe[e];
+        t.M = activeTransition;
+        activeTransition.fe.push(t);
       }
-      this.se = activeTransition.se;
+      this.fe = activeTransition.fe;
     }
-    if (this.Y !== activeTransition.Y) {
-      for (let e = 0; e < this.Y.length; e++) {
-        const t = this.Y[e];
-        t.K = activeTransition;
-        activeTransition.Y.push(t);
+    if (this.Z !== activeTransition.Z) {
+      for (let e = 0; e < this.Z.length; e++) {
+        const t = this.Z[e];
+        t.M = activeTransition;
+        activeTransition.Z.push(t);
       }
-      this.Y = activeTransition.Y;
+      this.Z = activeTransition.Z;
     }
     for (const e of activeLanes) {
-      if (!e.K) e.K = activeTransition;
+      if (!e.M) e.M = activeTransition;
     }
-    if (this.Z !== activeTransition.Z) {
-      for (const e of this.Z) activeTransition.Z.add(e);
-      this.Z = activeTransition.Z;
+    if (this.q !== activeTransition.q) {
+      for (const e of this.q) activeTransition.q.add(e);
+      this.q = activeTransition.q;
     }
   }
 }
+function queuePendingNode(e) {
+  if (activeTransition) {
+    globalQueue.fe.push(e);
+    return;
+  }
+  if (globalQueue.ae === null && globalQueue.fe.length === 0) {
+    globalQueue.ae = e;
+    return;
+  }
+  if (globalQueue.ae !== null) {
+    globalQueue.fe.push(globalQueue.ae);
+    globalQueue.ae = null;
+  }
+  globalQueue.fe.push(e);
+}
 function insertSubs(e, t = false) {
-  const n = e.q || currentOptimisticLane;
-  const i = e.de !== undefined;
-  for (let r = e.I; r !== null; r = r.h) {
-    if (i && r.p.Te) {
-      r.p.O |= REACTIVE_SNAPSHOT_STALE;
+  const n = e.G || currentOptimisticLane;
+  const i = e.pe !== undefined;
+  for (let r = e.I; r !== null; r = r.p) {
+    if (i && r.h._e & CONFIG_IN_SNAPSHOT_SCOPE) {
+      r.h._ |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
     if (t && n) {
-      r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      assignOrMergeLane(r.p, n);
+      r.h._ |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(r.h, n);
     } else if (t) {
-      r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      r.p.q = undefined;
+      r.h._ |= REACTIVE_OPTIMISTIC_DIRTY;
+      r.h.G = undefined;
     }
-    const e = r.p;
-    if (e.W === EFFECT_TRACKED) {
-      if (!e.H) {
-        e.H = true;
-        e.F.enqueue(EFFECT_USER, e.M);
+    const e = r.h;
+    if (e.J === EFFECT_TRACKED) {
+      if (!e.ee) {
+        e.ee = true;
+        e.te.enqueue(EFFECT_USER, e.ne);
       }
       continue;
     }
-    const s = r.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (s.P > r.p.o) s.P = r.p.o;
-    insertIntoHeap(r.p, s);
+    const s = r.h._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (s.C > r.h.o) s.C = r.h.o;
+    insertIntoHeap(r.h, s);
+  }
+}
+function commitPendingNode(e) {
+  const t = e;
+  if (!t.L) {
+    if (e.B !== NOT_PENDING) {
+      e.ue = e.B;
+      e.B = NOT_PENDING;
+    }
+    return;
+  }
+  if (e.B !== NOT_PENDING) {
+    e.ue = e.B;
+    e.B = NOT_PENDING;
+    if (e.J && e.J !== EFFECT_TRACKED) e.ee = true;
   }
+  t._ &= ~REACTIVE_MANUAL_WRITE;
+  if (!(t.he & STATUS_PENDING)) t.he &= ~STATUS_UNINITIALIZED;
+  if (t.Ne !== null || t.Ae !== null) GlobalQueue.Se(t, false, true);
 }
 function commitPendingNodes() {
-  const e = globalQueue.se;
+  if (globalQueue.ae !== null) {
+    commitPendingNode(globalQueue.ae);
+    globalQueue.ae = null;
+  }
+  const e = globalQueue.fe;
   for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    if (n.X !== NOT_PENDING) {
-      n.J = n.X;
-      n.X = NOT_PENDING;
-      if (n.W && n.W !== EFFECT_TRACKED) n.H = true;
-    }
-    if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
-    if (n.L) GlobalQueue.ue(n, false, true);
+    commitPendingNode(e[t]);
   }
   e.length = 0;
 }
 function finalizePureQueue(e = null, t = false) {
   const n = !t;
   if (n) commitPendingNodes();
-  if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.oe);
+  if (!t && globalQueue.Y.length) checkBoundaryChildren(globalQueue);
+  const i = dirtyQueue.O >= dirtyQueue.C;
+  if (i) runHeap(dirtyQueue, GlobalQueue.Ee);
   if (n) {
-    commitPendingNodes();
-    resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
-    const t = e ? e.Z : globalQueue.Z;
-    if (GlobalQueue.ce && t.size) {
+    if (i) commitPendingNodes();
+    resolveOptimisticNodes(e ? e.Z : globalQueue.Z);
+    if (e && e.oe.size) {
+      for (const t of e.oe) {
+        if (t._ & REACTIVE_DISPOSED) continue;
+        if (t.J === EFFECT_TRACKED) {
+          if (!t.ee) {
+            t.ee = true;
+            t.te.enqueue(EFFECT_USER, t.ne);
+          }
+          continue;
+        }
+        const e = t._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+        if (e.C > t.o) e.C = t.o;
+        insertIntoHeap(t, e);
+      }
+      e.oe.clear();
+    }
+    const t = e ? e.q : globalQueue.q;
+    if (GlobalQueue.de && t.size) {
       for (const e of t) {
-        GlobalQueue.ce(e);
+        GlobalQueue.de(e);
       }
       t.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(e);
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.re) {
+  for (const t of e.Y) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.Z.add(e);
+  globalQueue.q.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].K = activeTransition;
+    e[t].M = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
-function flush() {
-  if (globalQueue.ne) {
+function flush(e) {
+  if (e) {
+    syncDepth++;
+    try {
+      return e();
+    } finally {
+      flush();
+      syncDepth--;
+    }
+  }
+  if (globalQueue.le) {
     return;
   }
   while (scheduled || activeTransition) {
@@ -514,22 +702,22 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function reporterBlocksSource(e, t) {
-  if (e.O & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-  if (e.Re === t || e.Oe?.has(t)) return true;
-  for (let n = e.C; n; n = n.D) {
+  if (e._ & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+  if (e.Ce === t || e.Pe?.has(t)) return true;
+  for (let n = e.P; n; n = n.D) {
     let e = n.m;
     while (e) {
       if (e === t || e.V === t) return true;
-      e = e._e;
+      e = e.U;
     }
   }
-  return !!(e.Se & STATUS_PENDING && e.fe instanceof NotReadyError && e.fe.source === t);
+  return !!(e.he & STATUS_PENDING && e.Re instanceof NotReadyError && e.Re.source === t);
 }
 function transitionComplete(e) {
-  if (e.j) return true;
-  if (e.$.length) return false;
+  if (e.ie) return true;
+  if (e.re.length) return false;
   let t = true;
-  for (const [n, i] of e.B) {
+  for (const [n, i] of e.se) {
     let r = false;
     for (const e of i) {
       if (reporterBlocksSource(e, n)) {
@@ -538,32 +726,32 @@ function transitionComplete(e) {
       }
       i.delete(e);
     }
-    if (!r) e.B.delete(n);
-    else if (n.Se & STATUS_PENDING && n.fe?.source === n) {
+    if (!r) e.se.delete(n);
+    else if (n.he & STATUS_PENDING && n.Re?.source === n) {
       t = false;
       break;
     }
   }
   if (t) {
-    for (let n = 0; n < e.Y.length; n++) {
-      const i = e.Y[n];
+    for (let n = 0; n < e.Z.length; n++) {
+      const i = e.Z[n];
       if (
         hasActiveOverride(i) &&
-        "Se" in i &&
-        i.Se & STATUS_PENDING &&
-        i.fe instanceof NotReadyError &&
-        i.fe.source !== i
+        "he" in i &&
+        i.he & STATUS_PENDING &&
+        i.Re instanceof NotReadyError &&
+        i.Re.source !== i
       ) {
         t = false;
         break;
       }
     }
   }
-  t && (e.j = true);
+  t && (e.ie = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.j && typeof e.j === "object") e = e.j;
+  while (e.ie && typeof e.ie === "object") e = e.ie;
   return e;
 }
 function setActiveTransition(e) {
@@ -578,134 +766,12 @@ function runInTransition(e, t) {
     activeTransition = 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._e;
-  const i = n?.q ? findLane(n.q) : null;
-  t = { te: e, k: new Set(), G: [[], []], U: null, K: activeTransition, Ie: i };
-  signalLanes.set(e, t);
-  activeLanes.add(t);
-  e.he = false;
-  return t;
-}
-function findLane(e) {
-  while (e.U) e = e.U;
-  return e;
-}
-function mergeLanes(e, t) {
-  e = findLane(e);
-  t = findLane(t);
-  if (e === t) return e;
-  t.U = e;
-  for (const n of t.k) e.k.add(n);
-  e.G[0].push(...t.G[0]);
-  e.G[1].push(...t.G[1]);
-  return e;
-}
-function resolveLane(e) {
-  const t = e.q;
-  if (!t) return undefined;
-  const n = findLane(t);
-  if (activeLanes.has(n)) return n;
-  e.q = undefined;
-  return undefined;
-}
-function resolveTransition(e) {
-  return resolveLane(e)?.K ?? e.K;
-}
-function hasActiveOverride(e) {
-  return !!(e.ee !== undefined && e.ee !== NOT_PENDING);
-}
-function assignOrMergeLane(e, t) {
-  const n = findLane(t);
-  const i = e.q;
-  if (i) {
-    if (i.U) {
-      e.q = t;
-      return;
-    }
-    const r = findLane(i);
-    if (activeLanes.has(r)) {
-      if (r !== n && !hasActiveOverride(e)) {
-        if (n.Ie && findLane(n.Ie) === r) {
-          e.q = t;
-        } else if (r.Ie && findLane(r.Ie) === n);
-        else mergeLanes(n, r);
-      }
-      return;
-    }
-  }
-  e.q = t;
-}
-function unlinkSubs(e) {
-  const t = e.m;
-  const n = e.D;
-  const i = e.h;
-  const r = e.pe;
-  if (i !== null) i.pe = r;
-  else t.Ae = r;
-  if (r !== null) r.h = i;
-  else {
-    t.I = i;
-    if (i === null) {
-      t.Ne?.();
-      t.L && !t.Pe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
-    }
-  }
-  return n;
-}
-function unobserved(e) {
-  deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let t = e.C;
-  while (t !== null) {
-    t = unlinkSubs(t);
-  }
-  e.C = null;
-  disposeChildren(e, true);
-}
-function link(e, t) {
-  const n = t.ge;
-  if (n !== null && n.m === e) return;
-  let i = null;
-  const r = t.O & REACTIVE_RECOMPUTING_DEPS;
-  if (r) {
-    i = n !== null ? n.D : t.C;
-    if (i !== null && i.m === e) {
-      t.ge = i;
-      return;
-    }
-  }
-  const s = e.Ae;
-  if (s !== null && s.p === t && (!r || isValidLink(s, t))) return;
-  const o = (t.ge = e.Ae = { m: e, p: t, D: i, pe: s, h: null });
-  if (n !== null) n.D = o;
-  else t.C = o;
-  if (s !== null) s.h = o;
-  else e.I = o;
-}
-function isValidLink(e, t) {
-  const n = t.ge;
-  if (n !== null) {
-    let i = t.C;
-    do {
-      if (i === e) return true;
-      if (i === n) break;
-      i = i.D;
-    } while (i !== null);
-  }
-  return false;
-}
 const PENDING_OWNER = {};
 function markDisposal(e) {
-  let t = e.Ce;
+  let t = e.ge;
   while (t) {
-    t.O |= REACTIVE_ZOMBIE;
-    if (t.O & REACTIVE_IN_HEAP) {
+    t._ |= REACTIVE_ZOMBIE;
+    if (t._ & REACTIVE_IN_HEAP) {
       deleteFromHeap(t, dirtyQueue);
       insertIntoHeap(t, zombieQueue);
     }
@@ -714,44 +780,53 @@ function markDisposal(e) {
   }
 }
 function dispose(e) {
-  let t = e.C || null;
+  let t = e.P || null;
   do {
     t = unlinkSubs(t);
   } while (t !== null);
-  e.C = null;
-  e.ge = null;
+  e.P = null;
+  e.ye = null;
   disposeChildren(e, true);
 }
 function disposeChildren(e, t = false, n) {
-  if (e.O & REACTIVE_DISPOSED) return;
-  if (t) e.O = REACTIVE_DISPOSED;
-  if (t && e.L) e.ye = null;
-  let i = n ? e.ve : e.Ce;
-  while (i) {
-    const e = i.De;
-    if (i.C) {
-      const e = i;
-      deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.C;
+  const i = e._;
+  if (i & REACTIVE_DISPOSED) return;
+  if (t) e._ = i | REACTIVE_DISPOSED;
+  if (t && e.L) e.ve = null;
+  let r = n ? e.Ne : e.ge;
+  while (r) {
+    const e = r.De;
+    if (r.P) {
+      const e = r;
+      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.P;
       do {
         t = unlinkSubs(t);
       } while (t !== null);
-      e.C = null;
-      e.ge = null;
+      e.P = null;
+      e.ye = null;
     }
-    disposeChildren(i, true);
-    i = e;
+    disposeChildren(r, true);
+    r = e;
   }
   if (n) {
-    e.ve = null;
+    e.Ne = null;
   } else {
-    e.Ce = null;
+    e.ge = null;
     e.me = 0;
   }
+  if (t && !n && !(i & REACTIVE_ZOMBIE) && e.i !== null && !(e.i._ & REACTIVE_DISPOSED)) {
+    const t = e.be;
+    const n = e.De;
+    if (t !== null) t.De = n;
+    else e.i.ge = n;
+    if (n !== null) n.be = t;
+    e.be = null;
+  }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.we : e.Ve;
+  let n = t ? e.Ae : e.we;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -761,11 +836,11 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.we = null) : (e.Ve = null);
+  t ? (e.Ae = null) : (e.we = null);
 }
 function childId(e, t) {
   let n = e;
-  while (n.be && n.i) n = n.i;
+  while (n._e & CONFIG_TRANSPARENT && n.i) n = n.i;
   if (n.id != null) return formatId(n.id, t ? n.me++ : n.me);
   throw new Error("Cannot get child id from owner without an id");
 }
@@ -789,102 +864,176 @@ function getOwner() {
 }
 function cleanup(e) {
   if (!context) return e;
-  if (!context.Ve) context.Ve = e;
-  else if (Array.isArray(context.Ve)) context.Ve.push(e);
-  else context.Ve = [context.Ve, 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 isDisposed(e) {
-  return !!(e.O & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+  return !!(e._ & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+}
+function disposeRootSelf(e = true) {
+  disposeChildren(this, e);
 }
 function createOwner(e) {
   const t = context;
   const n = e?.transparent ?? false;
   const i = {
     id: e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined),
-    be: n || undefined,
+    _e: n ? CONFIG_TRANSPARENT : 0,
     t: true,
     u: t?.t ? t.u : t,
-    Ce: null,
+    ge: null,
     De: null,
-    Ve: null,
-    F: t?.F ?? globalQueue,
-    Le: t?.Le || defaultContext,
-    me: 0,
+    be: null,
     we: null,
-    ve: null,
+    te: t?.te ?? globalQueue,
+    Ve: t?.Ve || defaultContext,
+    me: 0,
+    Ae: null,
+    Ne: null,
     i: t,
-    dispose(e = true) {
-      disposeChildren(i, e);
-    }
+    dispose: disposeRootSelf
   };
   if (t) {
-    const e = t.Ce;
+    const e = t.ge;
     if (e === null) {
-      t.Ce = i;
+      t.ge = i;
     } else {
       i.De = e;
-      t.Ce = i;
+      e.be = i;
+      t.ge = i;
     }
   }
   return i;
 }
 function createRoot(e, t) {
   const n = createOwner(t);
-  return runWithOwner(n, () => e(n.dispose));
+  return runWithOwner(n, () => e(() => n.dispose()));
+}
+function unlinkSubs(e) {
+  const t = e.m;
+  const n = e.D;
+  const i = e.p;
+  const r = e.Le;
+  if (i !== null) i.Le = r;
+  else t.Ue = r;
+  if (r !== null) r.p = i;
+  else {
+    t.I = i;
+    if (i === null) {
+      t.X?.();
+      const e = t;
+      e.L && e._e & CONFIG_AUTO_DISPOSE && !(e._ & REACTIVE_ZOMBIE) && unobserved(e);
+    }
+  }
+  return n;
+}
+function trimStaleDeps(e) {
+  const t = e.ye;
+  let n = t !== null ? t.D : e.P;
+  if (n !== null) {
+    do {
+      n = unlinkSubs(n);
+    } while (n !== null);
+    if (t !== null) t.D = null;
+    else e.P = null;
+  }
+}
+function unobserved(e) {
+  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.P;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.P = null;
+  e.ye = null;
+  disposeChildren(e, true);
+}
+function link(e, t) {
+  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.D : t.P;
+    if (i !== null && i.m === e) {
+      t.ye = i;
+      return;
+    }
+  }
+  const s = e.Ue;
+  if (s !== null && s.h === t && (!r || isValidLink(s, t))) return;
+  const o = (t.ye = e.Ue = { m: e, h: t, D: i, Le: s, p: null });
+  if (n !== null) n.D = o;
+  else t.P = o;
+  if (s !== null) s.p = o;
+  else e.I = o;
+}
+function isValidLink(e, t) {
+  const n = t.ye;
+  if (n !== null) {
+    let i = t.P;
+    do {
+      if (i === e) return true;
+      if (i === n) break;
+      i = i.D;
+    } while (i !== null);
+  }
+  return false;
 }
 function addPendingSource(e, t) {
-  if (e.Re === t || e.Oe?.has(t)) return false;
-  if (!e.Re) {
-    e.Re = t;
+  if (e.Ce === t || e.Pe?.has(t)) return false;
+  if (!e.Ce) {
+    e.Ce = t;
     return true;
   }
-  if (!e.Oe) {
-    e.Oe = new Set([e.Re, t]);
+  if (!e.Pe) {
+    e.Pe = new Set([e.Ce, t]);
   } else {
-    e.Oe.add(t);
+    e.Pe.add(t);
   }
-  e.Re = undefined;
+  e.Ce = undefined;
   return true;
 }
 function removePendingSource(e, t) {
-  if (e.Re) {
-    if (e.Re !== t) return false;
-    e.Re = undefined;
+  if (e.Ce) {
+    if (e.Ce !== t) return false;
+    e.Ce = undefined;
     return true;
   }
-  if (!e.Oe?.delete(t)) return false;
-  if (e.Oe.size === 1) {
-    e.Re = e.Oe.values().next().value;
-    e.Oe = undefined;
-  } else if (e.Oe.size === 0) {
-    e.Oe = undefined;
+  if (!e.Pe?.delete(t)) return false;
+  if (e.Pe.size === 1) {
+    e.Ce = e.Pe.values().next().value;
+    e.Pe = undefined;
+  } else if (e.Pe.size === 0) {
+    e.Pe = undefined;
   }
   return true;
 }
 function clearPendingSources(e) {
-  e.Re = undefined;
-  e.Oe?.clear();
-  e.Oe = undefined;
+  e.Ce = undefined;
+  e.Pe?.clear();
+  e.Pe = undefined;
 }
 function setPendingError(e, t, n) {
   if (!t) {
-    e.fe = null;
+    e.Re = null;
     return;
   }
   if (n instanceof NotReadyError && n.source === t) {
-    e.fe = n;
+    e.Re = n;
     return;
   }
-  const i = e.fe;
+  const i = e.Re;
   if (!(i instanceof NotReadyError) || i.source !== t) {
-    e.fe = new NotReadyError(t);
+    e.Re = new NotReadyError(t);
   }
 }
 function forEachDependent(e, t) {
-  for (let n = e.I; n !== null; n = n.h) t(n.p);
-  for (let n = e.A; n !== null; n = n.N) {
-    for (let e = n.I; e !== null; e = e.h) t(e.p);
+  for (let n = e.I; n !== null; n = n.p) t(n.h);
+  for (let n = e.N; n !== null; n = n.A) {
+    for (let e = n.I; e !== null; e = e.p) t(e.h);
   }
 }
 function settlePendingSource(e) {
@@ -893,30 +1042,30 @@ function settlePendingSource(e) {
   const settle = i => {
     if (n.has(i) || !removePendingSource(i, e)) return;
     n.add(i);
-    i.Ee = clock;
-    const r = i.Re ?? i.Oe?.values().next().value;
+    i.Ie = clock;
+    const r = i.Ce ?? i.Pe?.values().next().value;
     if (r) {
       setPendingError(i, r);
       updatePendingSignal(i);
     } else {
-      i.Se &= ~STATUS_PENDING;
+      i.he &= ~STATUS_PENDING;
       setPendingError(i);
       updatePendingSignal(i);
-      if (i.Ue) {
-        if (i.W === EFFECT_TRACKED) {
+      if (i.Ge) {
+        if (i.J === EFFECT_TRACKED) {
           const e = i;
-          if (!e.H) {
-            e.H = true;
-            e.F.enqueue(EFFECT_USER, e.M);
+          if (!e.ee) {
+            e.ee = true;
+            e.te.enqueue(EFFECT_USER, e.ne);
           }
         } else {
-          const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-          if (e.P > i.o) e.P = i.o;
+          const e = i._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (e.C > i.o) e.C = i.o;
           insertIntoHeap(i, e);
         }
         t = true;
       }
-      i.Ue = false;
+      i.Ge = false;
     }
     forEachDependent(i, settle);
   };
@@ -924,46 +1073,52 @@ function settlePendingSource(e) {
   if (t) schedule();
 }
 function handleAsync(e, t, n) {
-  const i = typeof t === "object" && t !== null;
-  const r = i && untrack(() => t[Symbol.asyncIterator]);
-  const s = !r && i && untrack(() => typeof t.then === "function");
-  if (!s && !r) {
-    e.ye = null;
+  let i = false;
+  let r = false;
+  if (typeof t === "object" && t !== null) {
+    untrack(() => {
+      i = t[Symbol.asyncIterator];
+      r = !i && typeof t.then === "function";
+    });
+  }
+  if (!r && !i) {
+    e.ve = null;
     return t;
   }
-  e.ye = t;
-  let o;
+  e.ve = t;
+  let s;
   const handleError = n => {
-    if (e.ye !== t) return;
+    if (e.ve !== t) return;
     globalQueue.initTransition(resolveTransition(e));
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.Ee = clock;
+    e.Ie = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e.ye !== t) return;
-    if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    if (e.ve !== t) return;
+    if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(e));
-    const s = !!(e.Se & STATUS_UNINITIALIZED);
+    const s = !!(e.he & STATUS_UNINITIALIZED);
+    trimStaleDeps(e);
     clearStatus(e);
     const o = resolveLane(e);
     if (o) o.k.delete(e);
     if (n) n(i);
-    else if (e.ee !== undefined) {
-      if (e.ee !== undefined && e.ee !== NOT_PENDING) e.X = i;
+    else if (e.K !== undefined) {
+      if (e.K !== undefined && e.K !== NOT_PENDING) e.B = i;
       else {
-        e.J = i;
+        e.ue = i;
         insertSubs(e);
       }
-      e.Ee = clock;
+      e.Ie = clock;
     } else if (o) {
-      const t = e.W;
-      const n = e.J;
-      const r = e.ke;
+      const t = e.J;
+      const n = e.ue;
+      const r = e.Fe;
       if ((!t && s) || !r || !r(i, n)) {
-        e.J = i;
-        e.Ee = clock;
-        if (e.xe) {
-          setSignal(e.xe, i);
+        e.ue = i;
+        e.Ie = clock;
+        if (e.ke) {
+          setSignal(e.ke, i);
         }
         insertSubs(e, true);
       }
@@ -975,13 +1130,13 @@ function handleAsync(e, t, n) {
     flush();
     r?.();
   };
-  if (s) {
+  if (r) {
     let n = false,
       i = true;
     t.then(
       e => {
         if (i) {
-          o = e;
+          s = e;
           n = true;
         } else asyncWrite(e);
       },
@@ -995,7 +1150,7 @@ function handleAsync(e, t, n) {
       throw new NotReadyError(context);
     }
   }
-  if (r) {
+  if (i) {
     const n = t[Symbol.asyncIterator]();
     let i = false;
     let r = false;
@@ -1010,16 +1165,16 @@ function handleAsync(e, t, n) {
       } catch {}
     });
     const iterate = () => {
-      let s,
+      let o,
         u = false,
-        c = true;
+        l = true;
       n.next().then(
         n => {
-          if (c) {
-            s = n;
+          if (l) {
+            o = n;
             u = true;
             if (n.done) r = true;
-          } else if (e.ye !== t) {
+          } else if (e.ve !== t) {
             return;
           } else if (!n.done) asyncWrite(n.value, iterate);
           else {
@@ -1029,79 +1184,79 @@ function handleAsync(e, t, n) {
           }
         },
         n => {
-          if (!c && e.ye === t) {
+          if (!l && e.ve === t) {
             r = true;
             handleError(n);
           }
         }
       );
-      c = false;
-      if (u && !s.done) {
-        o = s.value;
+      l = false;
+      if (u && !o.done) {
+        s = o.value;
         i = true;
         return iterate();
       }
-      return u && s.done;
+      return u && o.done;
     };
-    const s = iterate();
-    if (!i && !s) {
+    const o = iterate();
+    if (!i && !o) {
       globalQueue.initTransition(resolveTransition(e));
       throw new NotReadyError(context);
     }
   }
-  return o;
+  return s;
 }
 function clearStatus(e, t = false) {
-  clearPendingSources(e);
-  e.Ue = false;
-  e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
-  setPendingError(e);
-  updatePendingSignal(e);
-  e.Ge?.();
+  if (e.Ce || e.Pe) clearPendingSources(e);
+  if (e.Ge) e.Ge = false;
+  e.he = t ? 0 : e.he & STATUS_UNINITIALIZED;
+  if (e.Re) setPendingError(e);
+  if (e.We) updatePendingSignal(e);
+  if (e.xe) e.xe();
 }
 function notifyStatus(e, t, n, i, r) {
   if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
     n = new StatusError(e, n);
   const s = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
   const o = s === e;
-  const u = t === STATUS_PENDING && e.ee !== undefined && !o;
-  const c = u && hasActiveOverride(e);
+  const u = t === STATUS_PENDING && e.K !== undefined && !o;
+  const l = u && hasActiveOverride(e);
   if (!i) {
     if (t === STATUS_PENDING && s) {
       addPendingSource(e, s);
-      e.Se = STATUS_PENDING | (e.Se & STATUS_UNINITIALIZED);
+      e.he = STATUS_PENDING | (e.he & STATUS_UNINITIALIZED);
       setPendingError(e, s, n);
     } else {
       clearPendingSources(e);
-      e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
-      e.fe = n;
+      e.he = t | (t !== STATUS_ERROR ? e.he & STATUS_UNINITIALIZED : 0);
+      e.Re = n;
     }
     updatePendingSignal(e);
   }
   if (r && !i) {
     assignOrMergeLane(e, r);
   }
-  const a = i || c;
-  const l = i || u ? undefined : r;
-  if (e.Ge) {
+  const c = i || l;
+  const a = i || u ? undefined : r;
+  if (e.xe) {
     if (i && t === STATUS_PENDING) {
       return;
     }
-    if (a) {
-      e.Ge(t, n);
+    if (c) {
+      e.xe(t, n);
     } else {
-      e.Ge();
+      e.xe();
     }
     return;
   }
   forEachDependent(e, e => {
-    e.Ee = clock;
+    e.Ie = clock;
     if (
-      (t === STATUS_PENDING && s && e.Re !== s && !e.Oe?.has(s)) ||
-      (t !== STATUS_PENDING && (e.fe !== n || e.Re || e.Oe))
+      (t === STATUS_PENDING && s && e.Ce !== s && !e.Pe?.has(s)) ||
+      (t !== STATUS_PENDING && (e.Re !== n || e.Ce || e.Pe))
     ) {
-      if (!a && !e.K) globalQueue.se.push(e);
-      notifyStatus(e, t, n, a, l);
+      if (!c && !e.M) queuePendingNode(e);
+      notifyStatus(e, t, n, c, a);
     }
   });
 }
@@ -1128,8 +1283,8 @@ function enableExternalSource(e) {
     externalSourceConfig = { factory: t, untrack: n };
   }
 }
-GlobalQueue.oe = recompute;
-GlobalQueue.ue = disposeChildren;
+GlobalQueue.Ee = recompute;
+GlobalQueue.Se = disposeChildren;
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -1142,7 +1297,7 @@ let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(e) {
   while (e) {
-    if (e.We) return true;
+    if (e.He) return true;
     e = e.i;
   }
   return false;
@@ -1152,27 +1307,27 @@ function setSnapshotCapture(e) {
   if (e && !snapshotSources) snapshotSources = new Set();
 }
 function markSnapshotScope(e) {
-  e.We = true;
+  e.He = true;
 }
 function releaseSnapshotScope(e) {
-  e.We = false;
+  e.He = false;
   releaseSubtree(e);
   schedule();
 }
 function releaseSubtree(e) {
-  let t = e.Ce;
+  let t = e.ge;
   while (t) {
-    if (t.We) {
+    if (t.He) {
       t = t.De;
       continue;
     }
     if (t.L) {
       const e = t;
-      e.Te = false;
-      if (e.O & REACTIVE_SNAPSHOT_STALE) {
-        e.O &= ~REACTIVE_SNAPSHOT_STALE;
-        e.O |= REACTIVE_DIRTY;
-        if (dirtyQueue.P > e.o) dirtyQueue.P = e.o;
+      e._e &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+      if (e._ & REACTIVE_SNAPSHOT_STALE) {
+        e._ &= ~REACTIVE_SNAPSHOT_STALE;
+        e._ |= REACTIVE_DIRTY;
+        if (dirtyQueue.C > e.o) dirtyQueue.C = e.o;
         insertIntoHeap(e, dirtyQueue);
       }
     }
@@ -1183,7 +1338,7 @@ function releaseSubtree(e) {
 function clearSnapshots() {
   if (snapshotSources) {
     for (const e of snapshotSources) {
-      delete e.de;
+      delete e.pe;
       delete e[STORE_SNAPSHOT_PROPS];
     }
     snapshotSources = null;
@@ -1191,220 +1346,308 @@ function clearSnapshots() {
   snapshotCaptureActive = false;
 }
 function recompute(e, t = false) {
-  const n = e.W;
+  const n = e.J;
   if (!t) {
-    if (e.K && (!n || activeTransition) && activeTransition !== e.K)
-      globalQueue.initTransition(e.K);
-    deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    e.ye = null;
-    if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
-    else {
+    if (e.M && (!n || activeTransition) && activeTransition !== e.M)
+      globalQueue.initTransition(e.M);
+    deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    e.ve = null;
+    if (e.M || n === EFFECT_TRACKED) disposeChildren(e);
+    else if (e.ge !== null || e.we !== null) {
       markDisposal(e);
-      e.we = e.Ve;
-      e.ve = e.Ce;
-      e.Ve = null;
-      e.Ce = null;
+      e.Ae = e.we;
+      e.Ne = e.ge;
+      e.we = null;
+      e.ge = null;
       e.me = 0;
-    }
+    } else;
   }
-  const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = e.ee !== undefined && e.ee !== NOT_PENDING;
-  const s = !!(e.Se & STATUS_PENDING);
-  const o = !!(e.Se & STATUS_UNINITIALIZED);
+  let i = !!(e._ & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = e.K !== undefined && e.K !== NOT_PENDING;
+  const s = !!(e.he & STATUS_PENDING);
+  const o = !!(e.he & STATUS_UNINITIALIZED);
   const u = context;
   context = e;
-  e.ge = null;
-  e.O = REACTIVE_RECOMPUTING_DEPS;
-  e.Ee = clock;
-  let c = e.X === NOT_PENDING ? e.J : e.X;
-  let a = e.o;
-  let l = tracking;
+  e.ye = null;
+  e._ = REACTIVE_RECOMPUTING_DEPS;
+  e.Ie = clock;
+  let l = e.B === NOT_PENDING ? e.ue : e.B;
+  let c = e.o;
+  let a = tracking;
   let f = currentOptimisticLane;
   tracking = true;
   if (i) {
     const t = resolveLane(e);
     if (t) currentOptimisticLane = t;
+  } else if (activeTransition && !t && activeTransition.Z.length) {
+    for (let t = e.P; t; t = t.D) {
+      const n = t.m;
+      if (n._ & REACTIVE_OPTIMISTIC_DIRTY) {
+        const t = resolveLane(n);
+        if (t) {
+          i = true;
+          currentOptimisticLane = t;
+          e._ |= REACTIVE_OPTIMISTIC_DIRTY;
+          assignOrMergeLane(e, t);
+          break;
+        }
+      }
+    }
   }
+  const E = n && n !== EFFECT_USER;
+  const S = stale;
+  if (E) stale = true;
   try {
-    c = handleAsync(e, e.L(c));
+    if (!false && e._e & CONFIG_SYNC) {
+      l = e.L(l);
+      e.ve = null;
+    } else {
+      const t = e.ve;
+      const n = e.L(l);
+      const i = typeof n === "object" && n !== null;
+      const r = e.ve !== t;
+      l = r || !i ? n : handleAsync(e, n);
+      if (!r && !i) e.ve = null;
+    }
     clearStatus(e, t);
-    const n = resolveLane(e);
-    if (n) {
-      n.k.delete(e);
-      updatePendingSignal(n.te);
+    if (e.G) {
+      const t = resolveLane(e);
+      if (t) {
+        t.k.delete(e);
+        updatePendingSignal(t.F);
+      }
     }
   } catch (t) {
     if (t instanceof NotReadyError && currentOptimisticLane) {
       const t = findLane(currentOptimisticLane);
-      if (t.te !== e) {
+      if (t.F !== e) {
         t.k.add(e);
-        e.q = t;
-        updatePendingSignal(t.te);
+        e.G = t;
+        updatePendingSignal(t.F);
       }
     }
-    if (t instanceof NotReadyError) e.Ue = true;
+    if (t instanceof NotReadyError) e.Ge = true;
     notifyStatus(
       e,
       t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
       t,
       undefined,
-      t instanceof NotReadyError ? e.q : undefined
+      t instanceof NotReadyError ? e.G : undefined
     );
   } finally {
-    tracking = l;
-    e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
+    tracking = a;
+    if (E) stale = S;
+    e._ = REACTIVE_NONE | (t ? e._ & REACTIVE_SNAPSHOT_STALE : 0);
     context = u;
   }
-  if (!e.fe) {
-    const u = e.ge;
-    let l = u !== null ? u.D : e.C;
-    if (l !== null) {
-      do {
-        l = unlinkSubs(l);
-      } while (l !== null);
-      if (u !== null) u.D = null;
-      else e.C = null;
-    }
-    const f = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
-    const E = (!n && o) || !e.ke || !e.ke(f, c);
-    if (E) {
-      const o = r ? e.ee : undefined;
-      if (t || (n && activeTransition !== e.K) || i) {
-        e.J = c;
+  if (!e.Re) {
+    trimStaleDeps(e);
+    const u = r ? e.K : e.B === NOT_PENDING ? e.ue : e.B;
+    const a = (!n && o) || !e.Fe || !e.Fe(u, l);
+    if (n && a) {
+      e.ee = !e.Re;
+      if (!t) e.te.enqueue(n, GlobalQueue.Te.bind(null, e));
+    }
+    if (a) {
+      const o = r ? e.K : undefined;
+      if (t || (n && activeTransition !== e.M) || i) {
+        e.ue = l;
         if (r && i) {
-          e.ee = c;
-          e.X = c;
+          e.K = l;
+          e.B = l;
         }
-      } else e.X = c;
-      if (r && !i && s && !e.he) e.ee = c;
-      if (!r || i || e.ee !== o) insertSubs(e, i || r);
+      } else e.B = l;
+      if (r && !i && s && !e.$) e.K = l;
+      if (!r || i || e.K !== o) insertSubs(e, i || r);
     } else if (r) {
-      e.X = c;
-    } else if (e.o != a) {
-      for (let t = e.I; t !== null; t = t.h) {
-        insertIntoHeapHeight(t.p, t.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      e.B = l;
+    } else if (e.o != c) {
+      for (let t = e.I; t !== null; t = t.p) {
+        insertIntoHeapHeight(t.h, t.h._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       }
     }
   }
   currentOptimisticLane = f;
-  (!t || e.Se & STATUS_PENDING) && !e.K && !(activeTransition && r) && globalQueue.se.push(e);
-  e.K && n && activeTransition !== e.K && runInTransition(e.K, () => recompute(e));
+  const T =
+    e.B !== NOT_PENDING ||
+    e.Ne !== null ||
+    e.Ae !== null ||
+    !!(e.he & (STATUS_PENDING | STATUS_UNINITIALIZED));
+  T && (!t || e.he & STATUS_PENDING) && !e.M && !(activeTransition && r) && queuePendingNode(e);
+  e.M && n && activeTransition !== e.M && runInTransition(e.M, () => recompute(e));
 }
 function updateIfNecessary(e) {
-  if (e.O & REACTIVE_CHECK) {
-    for (let t = e.C; t; t = t.D) {
+  if (e._ & REACTIVE_CHECK) {
+    for (let t = e.P; t; t = t.D) {
       const n = t.m;
       const i = n.V || n;
       if (i.L) {
         updateIfNecessary(i);
       }
-      if (e.O & REACTIVE_DIRTY) {
+      if (e._ & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.fe && e.Ee < clock && !e.ye)) {
+  if (e._ & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.Re && e.Ie < clock && !e.ve)) {
     recompute(e);
   }
-  e.O = e.O & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
-}
-function computed(e, t, n) {
-  const i = n?.transparent ?? false;
-  const r = {
-    id: n?.id ?? (i ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
-    be: i || undefined,
-    ke: n?.equals != null ? n.equals : isEqual,
-    le: !!n?.pureWrite,
-    Ne: n?.unobserved,
-    Ve: null,
-    F: context?.F ?? globalQueue,
-    Le: context?.Le ?? defaultContext,
+  e._ = e._ & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+}
+function computed(e, t) {
+  const n = t?.transparent ?? false;
+  const i = {
+    id: t?.id ?? (n ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
+    _e:
+      (n ? CONFIG_TRANSPARENT : 0) |
+      (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) |
+      (t?.sync ? CONFIG_SYNC : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+    Fe: t?.equals != null ? t.equals : isEqual,
+    X: t?.unobserved,
+    we: null,
+    te: context?.te ?? globalQueue,
+    Ve: context?.Ve ?? defaultContext,
     me: 0,
     L: e,
-    J: t,
+    ue: undefined,
     o: 0,
-    A: null,
-    S: undefined,
-    T: null,
-    C: null,
-    ge: null,
+    N: null,
+    T: undefined,
+    S: null,
+    P: null,
+    ye: null,
     I: null,
-    Ae: null,
+    Ue: null,
     i: context,
     De: null,
-    Ce: null,
-    O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    Se: STATUS_UNINITIALIZED,
-    Ee: clock,
-    X: NOT_PENDING,
-    we: null,
+    be: null,
+    ge: null,
+    _: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+    he: STATUS_UNINITIALIZED,
+    Ie: clock,
+    B: NOT_PENDING,
+    Ae: null,
+    Ne: null,
     ve: null,
+    M: null
+  };
+  setupComputedNode(i, t);
+  return i;
+}
+function createEffectNode(e, t, n, i, r, s) {
+  const o = s?.transparent ?? false;
+  const u = {
+    id: s?.id ?? (o ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
+    _e:
+      (o ? CONFIG_TRANSPARENT : 0) |
+      (s?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (s?.sync ? CONFIG_SYNC : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+    Fe: false,
+    X: s?.unobserved,
+    we: null,
+    te: context?.te ?? globalQueue,
+    Ve: context?.Ve ?? defaultContext,
+    me: 0,
+    L: e,
+    ue: undefined,
+    o: 0,
+    N: null,
+    T: undefined,
+    S: null,
+    P: null,
     ye: null,
-    K: null
+    I: null,
+    Ue: null,
+    i: context,
+    De: null,
+    be: null,
+    ge: null,
+    _: REACTIVE_LAZY,
+    he: STATUS_UNINITIALIZED,
+    Ie: clock,
+    B: NOT_PENDING,
+    Ae: null,
+    Ne: null,
+    ve: null,
+    M: null,
+    ee: false,
+    Me: undefined,
+    Qe: t,
+    je: n,
+    $e: undefined,
+    Ke: false,
+    J: i,
+    xe: r
   };
-  r.T = r;
-  const s = context?.t ? context.u : context;
+  setupComputedNode(u, lazyOptions);
+  return u;
+}
+const lazyOptions = { lazy: true };
+function setupComputedNode(e, t) {
+  e.S = e;
+  const n = context?.t ? context.u : context;
   if (context) {
-    const e = context.Ce;
-    if (e === null) {
-      context.Ce = r;
+    const t = context.ge;
+    if (t === null) {
+      context.ge = e;
     } else {
-      r.De = e;
-      context.Ce = r;
+      e.De = t;
+      t.be = e;
+      context.ge = e;
     }
   }
-  if (s) r.o = s.o + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.Te = true;
+  if (n) e.o = n.o + 1;
   if (externalSourceConfig) {
-    const e = signal(undefined, { equals: false, pureWrite: true });
-    const t = externalSourceConfig.factory(r.L, () => {
-      setSignal(e, undefined);
+    const t = signal(undefined, { equals: false, ownedWrite: true });
+    const n = externalSourceConfig.factory(e.L, () => {
+      setSignal(t, undefined);
     });
-    cleanup(() => t.dispose());
-    r.L = n => {
-      read(e);
-      return t.track(n);
+    cleanup(() => n.dispose());
+    e.L = e => {
+      read(t);
+      return n.track(e);
     };
   }
-  !n?.lazy && recompute(r, true);
-  if (snapshotCaptureActive && !n?.lazy) {
-    if (!(r.Se & STATUS_PENDING)) {
-      r.de = r.J === undefined ? NO_SNAPSHOT : r.J;
-      snapshotSources.add(r);
+  !t?.lazy && recompute(e, true);
+  if (snapshotCaptureActive && !t?.lazy) {
+    if (!(e.he & STATUS_PENDING)) {
+      e.pe = e.ue === undefined ? NO_SNAPSHOT : e.ue;
+      snapshotSources.add(e);
     }
   }
-  return r;
 }
 function signal(e, t, n = null) {
   const i = {
-    ke: t?.equals != null ? t.equals : isEqual,
-    le: !!t?.pureWrite,
-    He: !!t?.He,
-    Ne: t?.unobserved,
-    J: e,
+    Fe: t?.equals != null ? t.equals : isEqual,
+    _e: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Ye ? CONFIG_NO_SNAPSHOT : 0),
+    X: t?.unobserved,
+    ue: e,
     I: null,
-    Ae: null,
-    Ee: clock,
+    Ue: null,
+    Ie: clock,
     V: n,
-    N: n?.A || null,
-    X: NOT_PENDING
+    A: n?.N || null,
+    B: NOT_PENDING
   };
-  n && (n.A = i);
-  if (snapshotCaptureActive && !i.He && !((n?.Se ?? 0) & STATUS_PENDING)) {
-    i.de = e === undefined ? NO_SNAPSHOT : e;
+  n && (n.N = i);
+  if (snapshotCaptureActive && !(i._e & CONFIG_NO_SNAPSHOT) && !((n?.he ?? 0) & STATUS_PENDING)) {
+    i.pe = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources.add(i);
   }
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.ee = NOT_PENDING;
+  n.K = NOT_PENDING;
   return n;
 }
-function optimisticComputed(e, t, n) {
-  const i = computed(e, t, n);
-  i.ee = NOT_PENDING;
-  return i;
+function optimisticComputed(e, t) {
+  const n = computed(e, t);
+  n.K = NOT_PENDING;
+  return n;
 }
 function isEqual(e, t) {
   return e === t;
@@ -1425,7 +1668,7 @@ function read(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     latestReadActive = false;
-    const i = e.ee !== undefined && e.ee !== NOT_PENDING ? e.ee : e.J;
+    const i = e.K !== undefined && e.K !== NOT_PENDING ? e.K : e.ue;
     let r;
     try {
       r = read(t);
@@ -1435,9 +1678,9 @@ function read(e) {
     } finally {
       latestReadActive = n;
     }
-    if (t.Se & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.q) {
-      const e = findLane(t.q);
+    if (t.he & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.G) {
+      const e = findLane(t.G);
       const n = findLane(currentOptimisticLane);
       if (e !== n && e.k.size > 0) {
         return i;
@@ -1449,8 +1692,8 @@ function read(e) {
     const t = e.V;
     const n = pendingCheckActive;
     pendingCheckActive = false;
-    if (t && e.ee !== undefined) {
-      if (e.ee !== NOT_PENDING && (t.ye || !!(t.Se & STATUS_PENDING))) {
+    if (t && e.K !== undefined) {
+      if (e.K !== NOT_PENDING && (t.ve || !!(t.he & STATUS_PENDING))) {
         foundPending = true;
       }
       let n = context;
@@ -1463,86 +1706,127 @@ function read(e) {
       if (t && read(getPendingSignal(t))) foundPending = true;
     }
     pendingCheckActive = n;
-    return e.J;
+    return e.ue;
   }
   let t = context;
   if (t?.t) t = t.u;
-  if (refreshing && e.L) recompute(e);
-  if (e.O & REACTIVE_LAZY) {
-    e.O &= ~REACTIVE_LAZY;
-    recompute(e, true);
+  const n = e;
+  if (typeof n.L === "function") {
+    const t = e;
+    if (t._ & REACTIVE_LAZY) {
+      t._ &= ~REACTIVE_LAZY;
+      recompute(t, true);
+    } else if (t._ & REACTIVE_DISPOSED) {
+      recompute(t, true);
+    }
+  }
+  const i = e.V || e;
+  if (
+    !n.L &&
+    i === e &&
+    e.K === undefined &&
+    e.pe === undefined &&
+    activeTransition === null &&
+    currentOptimisticLane === null &&
+    !snapshotCaptureActive &&
+    true
+  ) {
+    if (t && tracking) link(e, t);
+    return !t || e.B === NOT_PENDING ? e.ue : e.B;
   }
-  const n = e.V || e;
   if (t && tracking) {
-    if (e.L && e.O & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    if (n.L) {
-      const i = e.O & REACTIVE_ZOMBIE;
-      if (n.o >= (i ? zombieQueue.P : dirtyQueue.P)) {
+    if (i.L) {
+      const n = e._ & REACTIVE_ZOMBIE;
+      if (i.o >= (n ? zombieQueue.C : dirtyQueue.C)) {
         markNode(t);
-        markHeap(i ? zombieQueue : dirtyQueue);
-        updateIfNecessary(n);
+        markHeap(n ? zombieQueue : dirtyQueue);
+        updateIfNecessary(i);
       }
-      const r = n.o;
+      const r = i.o;
       if (r >= t.o && e.i !== t) {
         t.o = r + 1;
       }
     }
   }
-  if (n.Se & STATUS_PENDING) {
-    if (t && !(stale && n.K && activeTransition !== n.K)) {
+  if (i.he & STATUS_PENDING) {
+    if (t && !(stale && i.M && activeTransition !== i.M)) {
       if (currentOptimisticLane) {
-        const i = n.q;
+        const n = i.G;
         const r = findLane(currentOptimisticLane);
-        if (i && findLane(i) === r && !hasActiveOverride(n)) {
+        if (n && findLane(n) === r && !hasActiveOverride(i)) {
           if (!tracking && e !== t) link(e, t);
-          throw n.fe;
+          throw i.Re;
         }
       } else {
         if (!tracking && e !== t) link(e, t);
-        throw n.fe;
+        throw i.Re;
       }
-    } else if (t && n !== e && n.Se & STATUS_UNINITIALIZED) {
+    } else if (t && i !== e && i.he & STATUS_UNINITIALIZED) {
       if (!tracking && e !== t) link(e, t);
-      throw n.fe;
-    } else if (!t && n.Se & STATUS_UNINITIALIZED) {
-      throw n.fe;
+      throw i.Re;
+    } else if (!t && i.he & STATUS_UNINITIALIZED) {
+      throw i.Re;
     }
   }
-  if (e.L && e.Se & STATUS_ERROR) {
-    if (e.Ee < clock) {
+  if (e.L && e.he & STATUS_ERROR) {
+    if (e.Ie < clock) {
       recompute(e);
       return read(e);
-    } else throw e.fe;
+    } else throw e.Re;
   }
-  if (snapshotCaptureActive && t && t.Te) {
-    const n = e.de;
+  if (snapshotCaptureActive && t && t._e & CONFIG_IN_SNAPSHOT_SCOPE) {
+    const n = e.pe;
     if (n !== undefined) {
       const i = n === NO_SNAPSHOT ? undefined : n;
-      const r = e.X !== NOT_PENDING ? e.X : e.J;
-      if (r !== i) t.O |= REACTIVE_SNAPSHOT_STALE;
+      const r = e.B !== NOT_PENDING ? e.B : e.ue;
+      if (r !== i) t._ |= REACTIVE_SNAPSHOT_STALE;
       return i;
     }
   }
-  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
-    if (t && stale && shouldReadStashedOptimisticValue(e)) return e.J;
-    return e.ee;
+  if (e.K !== undefined && e.K !== NOT_PENDING) {
+    if (t && stale && shouldReadStashedOptimisticValue(e)) return e.ue;
+    return e.K;
   }
-  return !t ||
+  if (
+    activeTransition !== null &&
+    currentOptimisticLane !== null &&
+    !latestReadActive &&
+    e.B !== NOT_PENDING &&
+    i === e &&
+    !e.L &&
+    t
+  ) {
+    activeTransition.oe.add(t);
+    return e.ue;
+  }
+  const r =
+    !t ||
     (currentOptimisticLane !== null &&
-      (e.ee !== undefined || e.q || (n === e && stale) || !!(n.Se & STATUS_PENDING))) ||
-    e.X === NOT_PENDING ||
-    (stale && e.K && activeTransition !== e.K)
-    ? e.J
-    : e.X;
+      (e.K !== undefined || e.G || (i === e && stale) || !!(i.he & STATUS_PENDING))) ||
+    e.B === NOT_PENDING ||
+    (stale && e.M && activeTransition !== e.M)
+      ? e.ue
+      : e.B;
+  if (
+    !t &&
+    i === e &&
+    typeof n.L === "function" &&
+    e._e & CONFIG_AUTO_DISPOSE &&
+    !(i.he & STATUS_PENDING) &&
+    !e.I
+  ) {
+    unobserved(e);
+  }
+  return r;
 }
 function setSignal(e, t) {
-  if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
-  const n = e.ee !== undefined && !projectionWriteActive;
-  const i = e.ee !== undefined && e.ee !== NOT_PENDING;
-  const r = n ? (i ? e.ee : e.J) : e.X === NOT_PENDING ? e.J : e.X;
+  if (e.M && activeTransition !== e.M) globalQueue.initTransition(e.M);
+  const n = e.K !== undefined && !projectionWriteActive;
+  const i = e.K !== undefined && e.K !== NOT_PENDING;
+  const r = n ? (i ? e.K : e.ue) : e.B === NOT_PENDING ? e.ue : e.B;
   if (typeof t === "function") t = t(r);
-  const s = !e.ke || !e.ke(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
+  const s = !e.Fe || !e.Fe(r, t) || !!(e.he & STATUS_UNINITIALIZED);
   if (!s) {
     if (n && i && e.L) {
       insertSubs(e, true);
@@ -1551,29 +1835,39 @@ function setSignal(e, t) {
     return t;
   }
   if (n) {
-    const n = e.ee === NOT_PENDING;
+    const n = e.K === NOT_PENDING;
     if (!n) globalQueue.initTransition(resolveTransition(e));
     if (n) {
-      e.X = e.J;
-      globalQueue.Y.push(e);
+      e.B = e.ue;
+      globalQueue.Z.push(e);
     }
-    e.he = true;
+    e.$ = true;
     const i = getOrCreateLane(e);
-    e.q = i;
-    e.ee = t;
+    e.G = i;
+    e.K = t;
   } else {
-    if (e.X === NOT_PENDING) globalQueue.se.push(e);
-    e.X = t;
+    if (e.B === NOT_PENDING) queuePendingNode(e);
+    e.B = t;
   }
-  updatePendingSignal(e);
-  if (e.xe) {
-    setSignal(e.xe, t);
+  if (e.We) updatePendingSignal(e);
+  if (e.ke) {
+    setSignal(e.ke, t);
   }
-  e.Ee = clock;
+  e.Ie = clock;
   insertSubs(e, n);
   schedule();
   return t;
 }
+function suppressComputedRecompute(e) {
+  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  if (!(e._ & REACTIVE_MANUAL_WRITE) && e.B === NOT_PENDING) queuePendingNode(e);
+  e._ = (e._ & -4) | REACTIVE_MANUAL_WRITE;
+}
+function setMemo(e, t) {
+  const n = setSignal(e, t);
+  suppressComputedRecompute(e);
+  return n;
+}
 function runWithOwner(e, t) {
   const n = context;
   const i = tracking;
@@ -1587,68 +1881,68 @@ function runWithOwner(e, t) {
   }
 }
 function getPendingSignal(e) {
-  if (!e.Fe) {
-    e.Fe = optimisticSignal(false, { pureWrite: true });
-    if (e._e) {
-      e.Fe._e = e;
+  if (!e.We) {
+    e.We = optimisticSignal(false, { ownedWrite: true });
+    if (e.U) {
+      e.We.U = e;
     }
-    if (computePendingState(e)) setSignal(e.Fe, true);
+    if (computePendingState(e)) setSignal(e.We, true);
   }
-  return e.Fe;
+  return e.We;
 }
 function computePendingState(e) {
   const t = e;
   const n = e.V;
-  if (n && e.X !== NOT_PENDING) {
-    return !n.ye && !(n.Se & STATUS_PENDING);
+  if (n && e.B !== NOT_PENDING) {
+    return !n.ve && !(n.he & STATUS_PENDING);
   }
-  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
-    if (t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
-    if (e._e) {
-      const t = e.q ? findLane(e.q) : null;
+  if (e.K !== undefined && e.K !== NOT_PENDING) {
+    if (t.he & STATUS_PENDING && !(t.he & STATUS_UNINITIALIZED)) return true;
+    if (e.U) {
+      const t = e.G ? findLane(e.G) : null;
       return !!(t && t.k.size > 0);
     }
     return true;
   }
-  if (e.ee !== undefined && e.ee === NOT_PENDING && !e._e) {
+  if (e.K !== undefined && e.K === NOT_PENDING && !e.U) {
     return false;
   }
-  if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
+  if (e.B !== NOT_PENDING && !(t.he & STATUS_UNINITIALIZED)) return true;
+  return !!(t.he & STATUS_PENDING && !(t.he & STATUS_UNINITIALIZED));
 }
 function updatePendingSignal(e) {
-  if (e.Fe) {
+  if (e.We) {
     const t = computePendingState(e);
-    const n = e.Fe;
+    const n = e.We;
     setSignal(n, t);
-    if (!t && n.q) {
+    if (!t && n.G) {
       const t = resolveLane(e);
       if (t && t.k.size > 0) {
-        const e = findLane(n.q);
+        const e = findLane(n.G);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
       signalLanes.delete(n);
-      n.q = undefined;
+      n.G = undefined;
     }
   }
 }
 function getLatestValueComputed(e) {
-  if (!e.xe) {
+  if (!e.ke) {
     const t = latestReadActive;
     latestReadActive = false;
     const n = pendingCheckActive;
     pendingCheckActive = false;
     const i = context;
     context = null;
-    e.xe = optimisticComputed(() => read(e));
-    e.xe._e = e;
+    e.ke = optimisticComputed(() => read(e));
+    e.ke.U = e;
     context = i;
     pendingCheckActive = n;
     latestReadActive = t;
   }
-  return e.xe;
+  return e.ke;
 }
 function staleValues(e, t = true) {
   const n = stale;
@@ -1687,11 +1981,11 @@ function refresh(e) {
   let t = refreshing;
   refreshing = true;
   try {
-    if (typeof e !== "function") {
-      recompute(e[$REFRESH]);
-      return e;
+    const t = e?.[$REFRESH];
+    if (false && !t);
+    if (t && typeof t.L === "function" && !(t._ & REACTIVE_DISPOSED)) {
+      recompute(t);
     }
-    return untrack(e);
   } finally {
     refreshing = t;
     if (!t) {
@@ -1709,7 +2003,7 @@ function getContext(e, t = getOwner()) {
   if (!t) {
     throw new NoOwnerError();
   }
-  const n = hasContext(e, t) ? t.Le[e.id] : e.defaultValue;
+  const n = hasContext(e, t) ? t.Ve[e.id] : e.defaultValue;
   if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
@@ -1719,80 +2013,73 @@ function setContext(e, t, n = getOwner()) {
   if (!n) {
     throw new NoOwnerError();
   }
-  n.Le = { ...n.Le, [e.id]: isUndefined(t) ? e.defaultValue : t };
+  n.Ve = { ...n.Ve, [e.id]: isUndefined(t) ? e.defaultValue : t };
 }
 function hasContext(e, t) {
-  return !isUndefined(t?.Le[e.id]);
+  return !isUndefined(t?.Ve[e.id]);
 }
 function isUndefined(e) {
   return typeof e === "undefined";
 }
-function effect(e, t, n, i, r) {
-  let s = false;
-  const o = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
-    ...r,
-    equals: () => {
-      o.H = !o.fe;
-      if (s) o.F.enqueue(o.W, runEffect.bind(o));
-      return false;
-    },
-    lazy: true
-  });
-  o.Qe = i;
-  o.Me = t;
-  o.je = n;
-  o.$e = undefined;
-  o.W = r?.render ? EFFECT_RENDER : EFFECT_USER;
-  o.Ge = (e, t) => {
-    const n = e !== undefined ? e : o.Se;
-    const i = t !== undefined ? t : o.fe;
-    if (n & STATUS_ERROR) {
-      let e = i;
-      o.F.notify(o, STATUS_PENDING, 0);
-      if (o.W === EFFECT_USER) {
-        try {
-          return o.je
-            ? o.je(e, () => {
-                o.$e?.();
-                o.$e = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
-        }
+function effect(e, t, n, i) {
+  const r = !!i?.user;
+  const s = createEffectNode(e, t, n, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, i);
+  recompute(s, true);
+  !i?.defer &&
+    (s.J === EFFECT_USER || i?.schedule
+      ? s.te.enqueue(s.J, runEffect.bind(null, s))
+      : runEffect(s));
+}
+function notifyEffectStatus(e, t) {
+  const n = e !== undefined ? e : this.he;
+  const i = t !== undefined ? t : this.Re;
+  if (n & STATUS_ERROR) {
+    let e = i;
+    this.te.notify(this, STATUS_PENDING, 0);
+    if (this.J === EFFECT_USER) {
+      try {
+        return this.je
+          ? this.je(e, () => {
+              this.$e?.();
+              this.$e = undefined;
+            })
+          : console.error(e);
+      } catch (t) {
+        e = t;
       }
-      if (!o.F.notify(o, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (o.W === EFFECT_RENDER) {
-      o.F.notify(o, STATUS_PENDING | STATUS_ERROR, n, i);
     }
-  };
-  recompute(o, true);
-  !r?.defer && (o.W === EFFECT_USER ? o.F.enqueue(o.W, runEffect.bind(o)) : runEffect.call(o));
-  s = true;
-  cleanup(() => o.$e?.());
-}
-function runEffect() {
-  if (!this.H || this.O & REACTIVE_DISPOSED) return;
-  this.$e?.();
-  this.$e = undefined;
+    if (!this.te.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+  } else if (this.J === EFFECT_RENDER) {
+    this.te.notify(this, STATUS_PENDING | STATUS_ERROR, n, i);
+  }
+}
+function runEffect(e) {
+  if (!e.ee || e._ & REACTIVE_DISPOSED) return;
+  e.$e?.();
+  e.$e = undefined;
   try {
-    const e = this.Me(this.J, this.Qe);
-    if (false && e !== undefined && typeof e !== "function");
-    this.$e = e;
-  } catch (e) {
-    this.fe = new StatusError(this, e);
-    this.Se |= STATUS_ERROR;
-    if (!this.F.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+    const t = e.Qe(e.ue, e.Me);
+    if (false && t !== undefined && typeof t !== "function");
+    e.$e = t;
+    if (e.$e && !e.Ke) {
+      e.Ke = true;
+      runWithOwner(e.i, () => cleanup(() => e.$e?.()));
+    }
+  } catch (t) {
+    e.Re = new StatusError(e, t);
+    e.he |= STATUS_ERROR;
+    if (!e.te.notify(e, STATUS_ERROR, STATUS_ERROR)) throw t;
   } finally {
-    this.Qe = this.J;
-    this.H = false;
+    e.Me = e.ue;
+    e.ee = false;
   }
 }
+GlobalQueue.Te = runEffect;
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.H || n.O & REACTIVE_DISPOSED) return;
+    if (!n.ee || n._ & REACTIVE_DISPOSED) return;
     try {
-      n.H = false;
+      n.ee = false;
       recompute(n);
     } finally {
     }
@@ -1804,23 +2091,22 @@ function trackedEffect(e, t) {
       const t = staleValues(e);
       n.$e = t;
     },
-    undefined,
     { ...t, lazy: true }
   );
   n.$e = undefined;
-  n.Ke = true;
-  n.H = true;
-  n.W = EFFECT_TRACKED;
-  n.Ge = (e, t) => {
-    const i = e !== undefined ? e : n.Se;
+  n._e = (n._e & ~CONFIG_AUTO_DISPOSE) | CONFIG_CHILDREN_FORBIDDEN;
+  n.ee = true;
+  n.J = EFFECT_TRACKED;
+  n.xe = (e, t) => {
+    const i = e !== undefined ? e : n.he;
     if (i & STATUS_ERROR) {
-      n.F.notify(n, STATUS_PENDING, 0);
-      const e = t !== undefined ? t : n.fe;
-      if (!n.F.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
+      n.te.notify(n, STATUS_PENDING, 0);
+      const e = t !== undefined ? t : n.Re;
+      if (!n.te.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
     }
   };
-  n.M = run;
-  n.F.enqueue(EFFECT_USER, run);
+  n.ne = run;
+  n.te.enqueue(EFFECT_USER, run);
   cleanup(() => n.$e?.());
 }
 function restoreTransition(e, t) {
@@ -1835,11 +2121,11 @@ function action(e) {
       const r = e(...t);
       globalQueue.initTransition();
       let s = activeTransition;
-      s.$.push(r);
+      s.re.push(r);
       const done = (e, t) => {
         s = currentTransition(s);
-        const o = s.$.indexOf(r);
-        if (o >= 0) s.$.splice(o, 1);
+        const o = s.re.indexOf(r);
+        if (o >= 0) s.re.splice(o, 1);
         setActiveTransition(s);
         schedule();
         t ? i(t) : n(e);
@@ -1872,26 +2158,26 @@ function onCleanup(e) {
 }
 function accessor(e) {
   const t = read.bind(null, e);
-  t.$r = true;
+  t[$REFRESH] = e;
   return t;
 }
-function createSignal(e, t, n) {
+function createSignal(e, t) {
   if (typeof e === "function") {
-    const i = computed(e, t, n);
-    return [accessor(i), setSignal.bind(null, i)];
+    const n = computed(e, t);
+    n._e &= ~CONFIG_AUTO_DISPOSE;
+    return [accessor(n), setMemo.bind(null, n)];
   }
-  const i = signal(e, t);
-  return [accessor(i), setSignal.bind(null, i)];
+  const n = signal(e, t);
+  return [accessor(n), setSignal.bind(null, n)];
 }
-function createMemo(e, t, n) {
-  let i = computed(e, t, n);
-  return accessor(i);
+function createMemo(e, t) {
+  return accessor(computed(e, t));
 }
-function createEffect(e, t, n, i) {
-  effect(e, t.effect || t, t.error, n, i);
+function createEffect(e, t, n) {
+  effect(e, t.effect || t, t.error, { user: true, ...n });
 }
-function createRenderEffect(e, t, n, i) {
-  effect(e, t, undefined, n, { render: true, ...i });
+function createRenderEffect(e, t, n) {
+  effect(e, t, undefined, n);
 }
 function createTrackedEffect(e, t) {
   trackedEffect(e, t);
@@ -1912,8 +2198,7 @@ function createReaction(e, t) {
           dispose(t);
         },
         e.error,
-        undefined,
-        { defer: true, ...(false ? { ...t, name: t?.name ?? "effect" } : t) }
+        { ...(false ? { ...t, name: t?.name ?? "effect" } : t), user: true, defer: true }
       );
     });
   };
@@ -1933,17 +2218,18 @@ function resolve(e) {
     });
   });
 }
-function createOptimistic(e, t, n) {
+function createOptimistic(e, t) {
   if (typeof e === "function") {
-    const i = optimisticComputed(e, t, n);
-    return [accessor(i), setSignal.bind(null, i)];
+    const n = optimisticComputed(e, t);
+    n._e &= ~CONFIG_AUTO_DISPOSE;
+    return [accessor(n), setSignal.bind(null, n)];
   }
-  const i = optimisticSignal(e, t);
-  return [accessor(i), setSignal.bind(null, i)];
+  const n = optimisticSignal(e, t);
+  return [accessor(n), setSignal.bind(null, n)];
 }
 function onSettled(e) {
   const t = getOwner();
-  t && !t.Ke
+  t && !(t._e & CONFIG_CHILDREN_FORBIDDEN)
     ? createTrackedEffect(() => untrack(e), undefined)
     : globalQueue.enqueue(EFFECT_USER, () => {
         const t = e();
@@ -1953,9 +2239,9 @@ function onSettled(e) {
 function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
 }
-function getOverrideValue(e, t, n, i, r) {
-  if (r && i in r) return r[i];
-  return t && i in t ? t[i] : e[i];
+function getOverrideValue(e, t, n, i) {
+  if (i && n in i) return i[n];
+  return t && n in t ? t[n] : e[n];
 }
 function getAllKeys(e, t, n) {
   const i = getKeys(e, t);
@@ -1965,114 +2251,225 @@ function getAllKeys(e, t, n) {
 function applyState(e, t, n) {
   const i = t?.[$TARGET];
   if (!i) return;
-  const r = i[STORE_VALUE];
-  const s = i[STORE_OVERRIDE];
-  const o = i[STORE_OPTIMISTIC_OVERRIDE];
-  let u = i[STORE_NODE];
-  if (e === r && !s && !o) return;
-  (i[STORE_LOOKUP] || storeLookup).set(e, i[$PROXY]);
-  i[STORE_VALUE] = e;
-  i[STORE_OVERRIDE] = undefined;
-  if (Array.isArray(r)) {
-    let t = false;
-    const c = getOverrideValue(r, s, u, "length", o);
-    if (e.length && c && e[0] && n(e[0]) != null) {
-      let a, l, f, E, d, T, S, R;
+  if (i[STORE_OVERRIDE] || i[STORE_OPTIMISTIC_OVERRIDE]) {
+    applyStateSlow(e, i, n);
+  } else {
+    applyStateFast(e, i, n);
+  }
+}
+function applyStateFast(e, t, n) {
+  const i = t[STORE_VALUE];
+  if (e === i) return;
+  (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+  t[STORE_VALUE] = e;
+  if (Array.isArray(i)) {
+    let r = false;
+    const s = i.length;
+    if (e.length && s && e[0] && n(e[0]) != null) {
+      let o, u, l, c, a, f, E, S;
+      for (
+        l = 0, c = Math.min(s, e.length);
+        l < c && ((f = i[l]) === e[l] || (f && e[l] && n(f) === n(e[l])));
+        l++
+      ) {
+        applyState(e[l], wrap(f, t), n);
+      }
+      const T = new Array(e.length),
+        d = new Map();
+      for (
+        c = s - 1, a = e.length - 1;
+        c >= l && a >= l && ((f = i[c]) === e[a] || (f && e[a] && n(f) === n(e[a])));
+        c--, a--
+      ) {
+        T[a] = f;
+      }
+      if (l > a || l > c) {
+        for (u = l; u <= a; u++) {
+          r = true;
+          t[STORE_NODE][u] && setSignal(t[STORE_NODE][u], wrap(e[u], t));
+        }
+        for (; u < e.length; u++) {
+          r = true;
+          const i = wrap(T[u], t);
+          t[STORE_NODE][u] && setSignal(t[STORE_NODE][u], i);
+          applyState(e[u], i, n);
+        }
+        r && t[STORE_NODE][$TRACK] && setSignal(t[STORE_NODE][$TRACK], void 0);
+        s !== e.length && t[STORE_NODE].length && setSignal(t[STORE_NODE].length, e.length);
+        return;
+      }
+      E = new Array(a + 1);
+      for (u = a; u >= l; u--) {
+        f = e[u];
+        S = f ? n(f) : f;
+        o = d.get(S);
+        E[u] = o === undefined ? -1 : o;
+        d.set(S, u);
+      }
+      for (o = l; o <= c; o++) {
+        f = i[o];
+        S = f ? n(f) : f;
+        u = d.get(S);
+        if (u !== undefined && u !== -1) {
+          T[u] = f;
+          u = E[u];
+          d.set(S, u);
+        }
+      }
+      for (u = l; u < e.length; u++) {
+        if (u in T) {
+          const i = wrap(T[u], t);
+          t[STORE_NODE][u] && setSignal(t[STORE_NODE][u], i);
+          applyState(e[u], i, n);
+        } else t[STORE_NODE][u] && setSignal(t[STORE_NODE][u], wrap(e[u], t));
+      }
+      if (l < e.length) r = true;
+    } else if (e.length) {
+      for (let r = 0, s = e.length; r < s; r++) {
+        const s = i[r];
+        isWrappable(s)
+          ? applyState(e[r], wrap(s, t), n)
+          : t[STORE_NODE][r] && setSignal(t[STORE_NODE][r], e[r]);
+      }
+    }
+    if (s !== e.length) {
+      r = true;
+      t[STORE_NODE].length && setSignal(t[STORE_NODE].length, e.length);
+    }
+    r && t[STORE_NODE][$TRACK] && setSignal(t[STORE_NODE][$TRACK], void 0);
+    return;
+  }
+  let r = t[STORE_NODE];
+  if (r) {
+    const s = r[$TRACK];
+    const o = s ? getAllKeys(i, undefined, e) : Object.keys(r);
+    for (let u = 0, l = o.length; u < l; u++) {
+      const l = o[u];
+      const c = r[l];
+      const a = unwrap(i[l]);
+      let f = unwrap(e[l]);
+      if (a === f) continue;
+      if (!a || !isWrappable(a) || !isWrappable(f) || (n(a) != null && n(a) !== n(f))) {
+        s && setSignal(s, void 0);
+        c && setSignal(c, isWrappable(f) ? wrap(f, t) : f);
+      } else applyState(f, wrap(a, t), n);
+    }
+  }
+  if ((r = t[STORE_HAS])) {
+    const t = Object.keys(r);
+    for (let n = 0, i = t.length; n < i; n++) {
+      const i = t[n];
+      setSignal(r[i], i in e);
+    }
+  }
+}
+function applyStateSlow(e, t, n) {
+  const i = t[STORE_VALUE];
+  const r = t[STORE_OVERRIDE];
+  const s = t[STORE_OPTIMISTIC_OVERRIDE];
+  let o = t[STORE_NODE];
+  (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+  t[STORE_VALUE] = e;
+  t[STORE_OVERRIDE] = undefined;
+  if (Array.isArray(i)) {
+    let o = false;
+    const u = getOverrideValue(i, r, "length", s);
+    if (e.length && u && e[0] && n(e[0]) != null) {
+      let l, c, a, f, E, S, T, d;
       for (
-        f = 0, E = Math.min(c, e.length);
-        f < E &&
-        ((T = getOverrideValue(r, s, u, f, o)) === e[f] || (T && e[f] && n(T) === n(e[f])));
-        f++
+        a = 0, f = Math.min(u, e.length);
+        a < f && ((S = getOverrideValue(i, r, a, s)) === e[a] || (S && e[a] && n(S) === n(e[a])));
+        a++
       ) {
-        applyState(e[f], wrap(T, i), n);
+        applyState(e[a], wrap(S, t), n);
       }
       const O = new Array(e.length),
         _ = new Map();
       for (
-        E = c - 1, d = e.length - 1;
-        E >= f &&
-        d >= f &&
-        ((T = getOverrideValue(r, s, u, E, o)) === e[d] || (T && e[d] && n(T) === n(e[d])));
-        E--, d--
+        f = u - 1, E = e.length - 1;
+        f >= a &&
+        E >= a &&
+        ((S = getOverrideValue(i, r, f, s)) === e[E] || (S && e[E] && n(S) === n(e[E])));
+        f--, E--
       ) {
-        O[d] = T;
+        O[E] = S;
       }
-      if (f > d || f > E) {
-        for (l = f; l <= d; l++) {
-          t = true;
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
+      if (a > E || a > f) {
+        for (c = a; c <= E; c++) {
+          o = true;
+          t[STORE_NODE][c] && setSignal(t[STORE_NODE][c], wrap(e[c], t));
         }
-        for (; l < e.length; l++) {
-          t = true;
-          const r = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], r);
-          applyState(e[l], r, n);
+        for (; c < e.length; c++) {
+          o = true;
+          const i = wrap(O[c], t);
+          t[STORE_NODE][c] && setSignal(t[STORE_NODE][c], i);
+          applyState(e[c], i, n);
         }
-        t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
-        c !== e.length && i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
+        o && t[STORE_NODE][$TRACK] && setSignal(t[STORE_NODE][$TRACK], void 0);
+        u !== e.length && t[STORE_NODE].length && setSignal(t[STORE_NODE].length, e.length);
         return;
       }
-      S = new Array(d + 1);
-      for (l = d; l >= f; l--) {
-        T = e[l];
-        R = T ? n(T) : T;
-        a = _.get(R);
-        S[l] = a === undefined ? -1 : a;
-        _.set(R, l);
-      }
-      for (a = f; a <= E; a++) {
-        T = getOverrideValue(r, s, u, a, o);
-        R = T ? n(T) : T;
-        l = _.get(R);
-        if (l !== undefined && l !== -1) {
-          O[l] = T;
-          l = S[l];
-          _.set(R, l);
+      T = new Array(E + 1);
+      for (c = E; c >= a; c--) {
+        S = e[c];
+        d = S ? n(S) : S;
+        l = _.get(d);
+        T[c] = l === undefined ? -1 : l;
+        _.set(d, c);
+      }
+      for (l = a; l <= f; l++) {
+        S = getOverrideValue(i, r, l, s);
+        d = S ? n(S) : S;
+        c = _.get(d);
+        if (c !== undefined && c !== -1) {
+          O[c] = S;
+          c = T[c];
+          _.set(d, c);
         }
       }
-      for (l = f; l < e.length; l++) {
-        if (l in O) {
-          const t = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], t);
-          applyState(e[l], t, n);
-        } else i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
+      for (c = a; c < e.length; c++) {
+        if (c in O) {
+          const i = wrap(O[c], t);
+          t[STORE_NODE][c] && setSignal(t[STORE_NODE][c], i);
+          applyState(e[c], i, n);
+        } else t[STORE_NODE][c] && setSignal(t[STORE_NODE][c], wrap(e[c], t));
       }
-      if (f < e.length) t = true;
+      if (a < e.length) o = true;
     } else if (e.length) {
-      for (let t = 0, c = e.length; t < c; t++) {
-        const c = getOverrideValue(r, s, u, t, o);
-        isWrappable(c)
-          ? applyState(e[t], wrap(c, i), n)
-          : i[STORE_NODE][t] && setSignal(i[STORE_NODE][t], e[t]);
+      for (let o = 0, u = e.length; o < u; o++) {
+        const u = getOverrideValue(i, r, o, s);
+        isWrappable(u)
+          ? applyState(e[o], wrap(u, t), n)
+          : t[STORE_NODE][o] && setSignal(t[STORE_NODE][o], e[o]);
       }
     }
-    if (c !== e.length) {
-      t = true;
-      i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
+    if (u !== e.length) {
+      o = true;
+      t[STORE_NODE].length && setSignal(t[STORE_NODE].length, e.length);
     }
-    t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
+    o && t[STORE_NODE][$TRACK] && setSignal(t[STORE_NODE][$TRACK], void 0);
     return;
   }
-  if (u) {
-    const t = u[$TRACK];
-    const c = t ? getAllKeys(r, s, e) : Object.keys(u);
-    for (let a = 0, l = c.length; a < l; a++) {
-      const l = c[a];
-      const f = u[l];
-      const E = unwrap(getOverrideValue(r, s, u, l, o));
-      let d = unwrap(e[l]);
-      if (E === d) continue;
-      if (!E || !isWrappable(E) || !isWrappable(d) || (n(E) != null && n(E) !== n(d))) {
-        t && setSignal(t, void 0);
-        f && setSignal(f, isWrappable(d) ? wrap(d, i) : d);
-      } else applyState(d, wrap(E, i), n);
-    }
-  }
-  if ((u = i[STORE_HAS])) {
-    const t = Object.keys(u);
+  if (o) {
+    const u = o[$TRACK];
+    const l = u ? getAllKeys(i, r, e) : Object.keys(o);
+    for (let c = 0, a = l.length; c < a; c++) {
+      const a = l[c];
+      const f = o[a];
+      const E = unwrap(getOverrideValue(i, r, a, s));
+      let S = unwrap(e[a]);
+      if (E === S) continue;
+      if (!E || !isWrappable(E) || !isWrappable(S) || (n(E) != null && n(E) !== n(S))) {
+        u && setSignal(u, void 0);
+        f && setSignal(f, isWrappable(S) ? wrap(S, t) : S);
+      } else applyState(S, wrap(E, t), n);
+    }
+  }
+  if ((o = t[STORE_HAS])) {
+    const t = Object.keys(o);
     for (let n = 0, i = t.length; n < i; n++) {
       const i = t[n];
-      setSignal(u[i], i in e);
+      setSignal(o[i], i in e);
     }
   }
 }
@@ -2086,7 +2483,7 @@ function reconcile(e, t) {
     applyState(e, n, i);
   };
 }
-function createProjectionInternal(e, t = {}, n) {
+function createProjectionInternal(e, t, n) {
   let i;
   const r = new WeakMap();
   const wrapper = e => {
@@ -2108,28 +2505,35 @@ function createProjectionInternal(e, t = {}, n) {
   };
   const s = wrapProjection(t);
   i = computed(() => {
-    const t = getOwner();
-    let i = false;
-    let r;
-    const o = new Proxy(
-      s,
-      createWriteTraps(() => !i || t.ye === r)
-    );
-    storeSetter(o, o => {
-      r = e(o);
-      i = true;
-      const u = handleAsync(t, r, e => {
-        e !== o && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id"));
-      });
-      u !== o && u !== undefined && reconcile(u, n?.key || "id")(s);
-    });
-  });
-  i.Pe = true;
+    if (!i) i = getOwner();
+    runProjectionComputed(s, e, n?.key || "id");
+  }, undefined);
+  i._e &= ~CONFIG_AUTO_DISPOSE;
   return { store: s, node: i };
 }
-function createProjection(e, t = {}, n) {
+function createProjection(e, t, n) {
   return createProjectionInternal(e, t, n).store;
 }
+function runProjectionComputed(e, t, n, i) {
+  const r = getOwner();
+  let s = false;
+  let o;
+  const u = new Proxy(
+    e,
+    createWriteTraps(() => !s || r.ve === o)
+  );
+  storeSetter(u, u => {
+    o = t(u);
+    s = true;
+    const commit = t => {
+      if (t === u || t === undefined) return;
+      const write = () => storeSetter(e, reconcile(t, n));
+      i ? i(write) : write();
+    };
+    commit(handleAsync(r, o, commit));
+  });
+  return r;
+}
 function createWriteTraps(e) {
   const t = {
     get(e, n) {
@@ -2192,6 +2596,7 @@ const STORE_VALUE = "v",
   STORE_OPTIMISTIC_OVERRIDE = "x",
   STORE_NODE = "n",
   STORE_HAS = "h",
+  STORE_CUSTOM_PROTO = "c",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
@@ -2201,7 +2606,14 @@ function createStoreProxy(e, t = storeTraps, n) {
   if (Array.isArray(e)) {
     i = [];
     i.v = e;
-  } else i = { v: e };
+  } else {
+    i = { v: e };
+    const t = e?.[$TARGET]?.[STORE_VALUE] ?? e;
+    const n = Object.getPrototypeOf(t);
+    if (n !== null && n !== Object.prototype) {
+      i[STORE_CUSTOM_PROTO] = true;
+    }
+  }
   n && n(i);
   return (i[$PROXY] = new Proxy(i, t));
 }
@@ -2213,12 +2625,8 @@ function wrap(e, t) {
   return n;
 }
 function isWrappable(e) {
-  return (
-    e != null &&
-    typeof e === "object" &&
-    !Object.isFrozen(e) &&
-    !(typeof Node !== "undefined" && e instanceof Node)
-  );
+  if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+  return typeof Node === "undefined" || !(e instanceof Node);
 }
 let writeOverride = false;
 function setWriteOverride(e) {
@@ -2227,6 +2635,18 @@ function setWriteOverride(e) {
 function writeOnly(e) {
   return writeOverride || !!Writing?.has(e);
 }
+function unwrapStoreValue(e) {
+  return e?.[$TARGET]?.[STORE_VALUE] ?? e;
+}
+function hasInheritedAccessor(e, t) {
+  let n = Object.getPrototypeOf(e);
+  while (n && n !== Object.prototype) {
+    const e = Reflect.getOwnPropertyDescriptor(n, t);
+    if (e) return !!e.get;
+    n = Object.getPrototypeOf(n);
+  }
+  return false;
+}
 function getNodes(e, t) {
   let n = e[t];
   if (!n) e[t] = n = Object.create(null);
@@ -2239,17 +2659,17 @@ function getNode(e, t, n, i, r = isEqual, s, o) {
     {
       equals: r,
       unobserved() {
-        delete e[t];
+        if (e[t] === u) delete e[t];
       }
     },
     i
   );
   if (s) {
-    u.ee = NOT_PENDING;
+    u.K = NOT_PENDING;
   }
   if (o && t in o) {
     const e = o[t];
-    u.de = e === undefined ? NO_SNAPSHOT : e;
+    u.pe = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources?.add(u);
   }
   return (e[t] = u);
@@ -2282,8 +2702,8 @@ function getPropertyDescriptor(e, t, n) {
 function prepareStoreWrite(e, t, n) {
   if (e[STORE_OPTIMISTIC]) {
     const t = e[STORE_FIREWALL];
-    if (t?.K) {
-      globalQueue.initTransition(t.K);
+    if (t?.M) {
+      globalQueue.initTransition(t.M);
     }
   }
   const i = e[STORE_VALUE];
@@ -2291,7 +2711,7 @@ function prepareStoreWrite(e, t, n) {
   if (
     snapshotCaptureActive &&
     typeof n !== "symbol" &&
-    !((e[STORE_FIREWALL]?.Se ?? 0) & STATUS_PENDING)
+    !((e[STORE_FIREWALL]?.he ?? 0) & STATUS_PENDING)
   ) {
     if (!e[STORE_SNAPSHOT_PROPS]) {
       e[STORE_SNAPSHOT_PROPS] = Object.create(null);
@@ -2306,20 +2726,45 @@ function prepareStoreWrite(e, t, n) {
   if (s) trackOptimisticStore(t);
   return { base: r, overrideKey: o, state: i };
 }
-function notifyStoreProperty(e, t, n, i) {
-  if (e[STORE_HAS]?.[t]) setSignal(e[STORE_HAS][t], n !== "delete");
-  const r = getNodes(e, STORE_NODE);
+function upsertStoreNode(e, t, n, i, r) {
+  if (t[n]) return t[n];
+  const s = isWrappable(i) ? wrap(i, e) : i;
+  const o = getNode(t, n, s, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC], r);
+  registerTransientStoreNode(o);
+  return o;
+}
+function notifyStoreProperty(e, t, n, i, r, s) {
+  const o = projectionWriteActive || e[STORE_OPTIMISTIC];
+  const u = n !== "delete";
+  const l = e[STORE_HAS]?.[t];
+  if (l) {
+    setSignal(l, u);
+  } else if (!o && n !== "invalidate" && s !== u) {
+    const n = upsertStoreNode(e, getNodes(e, STORE_HAS), t, s);
+    setSignal(n, u);
+  }
+  const c = getNodes(e, STORE_NODE);
   if (n === "set") {
-    r[t] && setSignal(r[t], () => (isWrappable(i) ? wrap(i, e) : i));
+    if (c[t]) {
+      setSignal(c[t], () => (isWrappable(i) ? wrap(i, e) : i));
+    } else if (!o) {
+      const n = upsertStoreNode(e, c, t, r, e[STORE_SNAPSHOT_PROPS]);
+      setSignal(n, () => (isWrappable(i) ? wrap(i, e) : i));
+    }
   } else if (n === "invalidate") {
-    if (r[t]) {
-      setSignal(r[t], {});
-      delete r[t];
+    if (c[t]) {
+      setSignal(c[t], {});
+      delete c[t];
     }
   } else {
-    r[t] && setSignal(r[t], undefined);
+    if (c[t]) {
+      setSignal(c[t], undefined);
+    } else if (!o) {
+      const n = upsertStoreNode(e, c, t, r, e[STORE_SNAPSHOT_PROPS]);
+      setSignal(n, undefined);
+    }
   }
-  r[$TRACK] && setSignal(r[$TRACK], undefined);
+  c[$TRACK] && setSignal(c[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2333,26 +2778,47 @@ const storeTraps = {
     }
     const i = getNodes(e, STORE_NODE);
     const r = i[t];
-    const s = e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE];
-    const o = s || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]);
-    const u = !!e[STORE_VALUE][$TARGET];
-    const c = s
+    const s = e[STORE_VALUE];
+    if (
+      !r &&
+      !e[STORE_OVERRIDE] &&
+      !e[STORE_OPTIMISTIC_OVERRIDE] &&
+      !e[STORE_CUSTOM_PROTO] &&
+      !e[STORE_OPTIMISTIC] &&
+      !e[STORE_SNAPSHOT_PROPS] &&
+      !s[$TARGET] &&
+      !(t in s) &&
+      getObserver() &&
+      !writeOnly(n)
+    ) {
+      return read(getNode(i, t, undefined, e[STORE_FIREWALL]));
+    }
+    const o = e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE];
+    const u = o || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]);
+    const l = !!e[STORE_VALUE][$TARGET];
+    const c = o
       ? e[STORE_OPTIMISTIC_OVERRIDE]
       : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
         ? e[STORE_OVERRIDE]
         : e[STORE_VALUE];
     if (!r) {
-      const e = Object.getOwnPropertyDescriptor(c, t);
-      if (e && e.get) return e.get.call(n);
+      const i = Object.getOwnPropertyDescriptor(c, t);
+      if (i && i.get) return i.get.call(n);
+      if (!i && !u && e[STORE_CUSTOM_PROTO]) {
+        const e = unwrapStoreValue(c);
+        if (hasInheritedAccessor(e, t)) {
+          return Reflect.get(c, t, n);
+        }
+      }
     }
     if (writeOnly(n)) {
       let n =
-        r && (o || !u)
-          ? r.ee !== undefined && r.ee !== NOT_PENDING
-            ? r.ee
-            : r.X !== NOT_PENDING
-              ? r.X
-              : r.J
+        r && (u || !l)
+          ? r.K !== undefined && r.K !== NOT_PENDING
+            ? r.K
+            : r.B !== NOT_PENDING
+              ? r.B
+              : r.ue
           : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
@@ -2360,10 +2826,10 @@ const storeTraps = {
       Writing?.add(i);
       return i;
     }
-    let a = r ? (o || !u ? read(i[t]) : (read(i[t]), c[t])) : c[t];
+    let a = r ? (u || !l ? read(i[t]) : (read(i[t]), c[t])) : c[t];
     a === $DELETED && (a = undefined);
     if (!r) {
-      if (!o && typeof a === "function" && !c.hasOwnProperty(t)) {
+      if (!u && typeof a === "function" && !c.hasOwnProperty(t)) {
         let t;
         return !Array.isArray(e[STORE_VALUE]) &&
           (t = Object.getPrototypeOf(e[STORE_VALUE])) &&
@@ -2394,11 +2860,11 @@ const storeTraps = {
         : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
           ? e[STORE_OVERRIDE][t] !== $DELETED
           : t in e[STORE_VALUE];
-    if (!writeOnly(e[$PROXY])) {
-      getObserver() &&
-        read(
-          getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC])
-        );
+    if (writeOnly(e[$PROXY])) return n;
+    const i = getNodes(e, STORE_HAS);
+    if (i[t]) return read(i[t]);
+    if (getObserver()) {
+      return read(getNode(i, t, n, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC]));
     }
     return n;
   },
@@ -2413,29 +2879,39 @@ const storeTraps = {
             : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
               ? e[STORE_OVERRIDE][t]
               : r;
-        const c = n?.[$TARGET]?.[STORE_VALUE] ?? n;
+        const l =
+          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
+            ? e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED
+            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+              ? e[STORE_OVERRIDE][t] !== $DELETED
+              : t in e[STORE_VALUE];
+        const c = unwrapStoreValue(n);
         const a = Array.isArray(o) && t !== "length";
-        const l = a ? parseInt(t) + 1 : 0;
-        const f =
+        const f = a ? parseInt(t) + 1 : 0;
+        const E =
           a &&
           (e[STORE_OPTIMISTIC_OVERRIDE] && "length" in e[STORE_OPTIMISTIC_OVERRIDE]
             ? e[STORE_OPTIMISTIC_OVERRIDE].length
             : e[STORE_OVERRIDE] && "length" in e[STORE_OVERRIDE]
               ? e[STORE_OVERRIDE].length
               : o.length);
-        const E = a && l > f ? l : undefined;
-        if (u === c && E === undefined) return true;
-        if (c !== undefined && c === r && E === undefined) delete e[s]?.[t];
+        const S = a && f > E ? f : undefined;
+        if (u === c && S === undefined) return true;
+        if (c !== undefined && c === r && S === undefined) delete e[s]?.[t];
         else {
           const n = e[s] || (e[s] = Object.create(null));
           n[t] = c;
-          if (E !== undefined) n.length = E;
+          if (S !== undefined) n.length = S;
         }
-        notifyStoreProperty(e, t, "set", c);
-        if (Array.isArray(o)) {
-          const n = getNodes(e, STORE_NODE);
-          const i = t === "length" ? c : E;
-          i !== undefined && n.length && setSignal(n.length, i);
+        notifyStoreProperty(e, t, "set", c, u, l);
+        if (Array.isArray(o) && t !== "length" && S !== undefined) {
+          const t = getNodes(e, STORE_NODE);
+          if (t.length) {
+            setSignal(t.length, S);
+          } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
+            const n = upsertStoreNode(e, t, "length", E, e[STORE_SNAPSHOT_PROPS]);
+            setSignal(n, S);
+          }
         }
         if (false);
       });
@@ -2447,7 +2923,7 @@ const storeTraps = {
     if (writeOnly(i)) {
       untrack(() => {
         const { base: r, overrideKey: s } = prepareStoreWrite(e, i, t);
-        const o = "value" in n ? { ...n, value: n.value?.[$TARGET]?.[STORE_VALUE] ?? n.value } : n;
+        const o = "value" in n ? { ...n, value: unwrapStoreValue(n.value) } : n;
         Object.defineProperty(e[s] || (e[s] = Object.create(null)), t, o);
         notifyStoreProperty(e, t, "invalidate");
         if (false);
@@ -2474,7 +2950,7 @@ const storeTraps = {
         } else if (e[i] && t in e[i]) {
           delete e[i][t];
         } else return true;
-        notifyStoreProperty(e, t, "delete");
+        notifyStoreProperty(e, t, "delete", undefined, r, true);
       });
     }
     return true;
@@ -2541,12 +3017,15 @@ function storeSetter(e, t) {
 function createStore(e, t, n) {
   const i = typeof e === "function",
     r = i ? createProjectionInternal(e, t, n).store : wrap(e);
-  return [r, e => storeSetter(r, e)];
+  return [
+    r,
+    i ? e => (storeSetter(r, e), suppressComputedRecompute(r[$REFRESH])) : e => storeSetter(r, e)
+  ];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.ce ||= clearOptimisticStore;
+  GlobalQueue.de ||= clearOptimisticStore;
   const i = typeof e === "function";
-  const r = (i ? t : e) ?? {};
+  const r = i ? t : e;
   const s = i ? e : undefined;
   const { store: o } = createOptimisticProjectionInternal(s, r, n);
   return [o, e => storeSetter(o, e)];
@@ -2561,7 +3040,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].q = undefined;
+          i[e].G = 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;
@@ -2569,7 +3048,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].q = undefined;
+        i[$TRACK].G = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2578,7 +3057,7 @@ function clearOptimisticStore(e) {
   }
   delete t[STORE_OPTIMISTIC_OVERRIDE];
 }
-function createOptimisticProjectionInternal(e, t = {}, n) {
+function createOptimisticProjectionInternal(e, t, n) {
   let i;
   const r = new WeakMap();
   const wrapper = e => {
@@ -2601,38 +3080,30 @@ function createOptimisticProjectionInternal(e, t = {}, n) {
   };
   const s = wrapProjection(t);
   if (e) {
+    const wrapCommit = e => {
+      setProjectionWriteActive(true);
+      try {
+        e();
+      } finally {
+        setProjectionWriteActive(false);
+      }
+    };
     i = computed(() => {
-      const t = getOwner();
-      let i = false;
-      let r;
-      const o = new Proxy(
-        s,
-        createWriteTraps(() => !i || t.ye === r)
-      );
       setProjectionWriteActive(true);
       try {
-        storeSetter(o, o => {
-          r = e(o);
-          i = true;
-          const u = handleAsync(t, r, e => {
-            setProjectionWriteActive(true);
-            try {
-              e !== o && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id"));
-            } finally {
-              setProjectionWriteActive(false);
-            }
-          });
-          u !== o && u !== undefined && reconcile(u, n?.key || "id")(s);
-        });
+        runProjectionComputed(s, e, n?.key || "id", wrapCommit);
       } finally {
         setProjectionWriteActive(false);
       }
-    });
-    i.Pe = true;
+    }, undefined);
+    i._e &= ~CONFIG_AUTO_DISPOSE;
   }
   return { store: s, node: i };
 }
 const DELETE = Symbol(0);
+function isPrototypePollutionKey(e) {
+  return e === "__proto__" || e === "constructor" || e === "prototype";
+}
 function updatePath(e, t, n = 0) {
   let i,
     r = e;
@@ -2640,6 +3111,7 @@ function updatePath(e, t, n = 0) {
     i = t[n];
     const s = typeof i;
     const o = Array.isArray(e);
+    if (s === "string" && isPrototypePollutionKey(i)) return;
     if (Array.isArray(i)) {
       for (let r = 0; r < i.length; r++) {
         t[n] = i[r];
@@ -2683,6 +3155,7 @@ function updatePath(e, t, n = 0) {
     const n = Object.keys(s);
     for (let e = 0; e < n.length; e++) {
       const i = n[e];
+      if (isPrototypePollutionKey(i)) continue;
       const r = Object.getOwnPropertyDescriptor(s, i);
       if (r.get || r.set) Object.defineProperty(t, i, r);
       else t[i] = r.value;
@@ -2700,7 +3173,7 @@ const storePath = Object.assign(
   { DELETE: DELETE }
 );
 function snapshotImpl(e, t, n, i) {
-  let r, s, o, u, c, a;
+  let r, s, o, u, l, c;
   if (!isWrappable(e)) return e;
   if (n && n.has(e)) return n.get(e);
   if (!n) n = new Map();
@@ -2720,29 +3193,29 @@ function snapshotImpl(e, t, n, i) {
   }
   if (s) {
     const s = o?.length || e.length;
-    for (let l = 0; l < s; l++) {
-      a = o && l in o ? o[l] : e[l];
-      if (a === $DELETED) continue;
-      if (t && isWrappable(a)) wrap(a, r);
-      if ((c = snapshotImpl(a, t, n, i)) !== a || u) {
+    for (let a = 0; a < s; a++) {
+      c = o && a in o ? o[a] : e[a];
+      if (c === $DELETED) continue;
+      if (t && isWrappable(c)) wrap(c, r);
+      if ((l = snapshotImpl(c, t, n, i)) !== c || u) {
         if (!u) n.set(e, (u = [...e]));
-        u[l] = c;
+        u[a] = l;
       }
     }
   } else {
     const s = getKeys(e, o);
-    for (let l = 0, f = s.length; l < f; l++) {
-      let f = s[l];
+    for (let a = 0, f = s.length; a < f; a++) {
+      let f = s[a];
       const E = getPropertyDescriptor(e, o, f);
       if (E.get) continue;
-      a = o && f in o ? o[f] : e[f];
-      if (t && isWrappable(a)) wrap(a, r);
-      if ((c = snapshotImpl(a, t, n, i)) !== e[f] || u) {
+      c = o && f in o ? o[f] : e[f];
+      if (t && isWrappable(c)) wrap(c, r);
+      if ((l = snapshotImpl(c, t, n, i)) !== e[f] || u) {
         if (!u) {
           u = Object.create(Object.getPrototypeOf(e));
           Object.assign(u, e);
         }
-        u[f] = c;
+        u[f] = l;
       }
     }
   }
@@ -2795,8 +3268,9 @@ function merge(...e) {
     const r = e[i];
     t = t || (!!r && $PROXY in r);
     const s = !!r && r[$SOURCES];
-    if (s) n.push(...s);
-    else n.push(typeof r === "function" ? ((t = true), createMemo(r)) : r);
+    if (s) {
+      for (let e = 0; e < s.length; e++) n.push(s[e]);
+    } else n.push(typeof r === "function" ? ((t = true), createMemo(r)) : r);
   }
   if (SUPPORTS_PROXY && t) {
     return new Proxy(
@@ -2815,9 +3289,12 @@ function merge(...e) {
           return false;
         },
         keys() {
-          const e = [];
-          for (let t = 0; t < n.length; t++) e.push(...Object.keys(resolveSource(n[t])));
-          return [...new Set(e)];
+          const e = new Set();
+          for (let t = 0; t < n.length; t++) {
+            const i = Object.keys(resolveSource(n[t]));
+            for (let t = 0; t < i.length; t++) e.add(i[t]);
+          }
+          return [...e];
         }
       },
       propTraps
@@ -2856,255 +3333,262 @@ function merge(...e) {
   return o;
 }
 function omit(e, ...t) {
-  const n = new Set(t);
   if (SUPPORTS_PROXY && $PROXY in e) {
     return new Proxy(
       {
-        get(t) {
-          return n.has(t) ? undefined : e[t];
+        get(n) {
+          return t.includes(n) ? undefined : e[n];
         },
-        has(t) {
-          return !n.has(t) && t in e;
+        has(n) {
+          return !t.includes(n) && n in e;
         },
         keys() {
-          return Object.keys(e).filter(e => !n.has(e));
+          return Object.keys(e).filter(e => !t.includes(e));
         }
       },
       propTraps
     );
   }
-  const i = {};
-  for (const t of Object.getOwnPropertyNames(e)) {
-    if (!n.has(t)) {
-      const n = Object.getOwnPropertyDescriptor(e, t);
-      !n.get && !n.set && n.enumerable && n.writable && n.configurable
-        ? (i[t] = n.value)
-        : Object.defineProperty(i, t, n);
+  const n = {};
+  const i = Object.getOwnPropertyNames(e);
+  const r = t.length > 4 && i.length > t.length ? new Set(t) : undefined;
+  for (const s of i) {
+    if (r ? !r.has(s) : !t.includes(s)) {
+      const t = Object.getOwnPropertyDescriptor(e, s);
+      !t.get && !t.set && t.enumerable && t.writable && t.configurable
+        ? (n[s] = t.value)
+        : Object.defineProperty(n, s, t);
     }
   }
-  return i;
+  return n;
 }
 function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   const r = t.length > 1;
   const s = t;
-  return createMemo(
-    updateKeyedMap.bind({
-      Ye: createOwner(),
-      Ze: 0,
-      Be: e,
-      qe: [],
-      Xe: s,
-      ze: [],
-      Je: [],
-      et: i,
-      tt: i || n?.keyed === false ? [] : undefined,
-      nt: r ? [] : undefined,
-      it: n?.fallback
-    })
-  );
+  const o = {
+    Ze: createOwner(),
+    qe: 0,
+    Be: e,
+    ze: [],
+    Xe: s,
+    Je: [],
+    et: [],
+    tt: i,
+    nt: i || n?.keyed === false ? [] : undefined,
+    it: r ? [] : undefined,
+    rt: n?.fallback
+  };
+  const u = computed(updateKeyedMap.bind(o));
+  o.Ze.u = u;
+  u._e &= ~CONFIG_AUTO_DISPOSE;
+  return accessor(u);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const e = this.Be() || [],
     t = e.length;
   e[$TRACK];
-  runWithOwner(this.Ye, () => {
+  runWithOwner(this.Ze, () => {
     let n,
       i,
-      r = this.tt
+      r = this.nt
         ? () => {
-            this.tt[i] = signal(e[i], pureOptions);
-            this.nt && (this.nt[i] = signal(i, pureOptions));
-            return this.Xe(accessor(this.tt[i]), this.nt ? accessor(this.nt[i]) : undefined);
+            this.nt[i] = signal(e[i], pureOptions);
+            this.it && (this.it[i] = signal(i, pureOptions));
+            return this.Xe(accessor(this.nt[i]), this.it ? accessor(this.it[i]) : undefined);
           }
-        : this.nt
+        : this.it
           ? () => {
               const t = e[i];
-              this.nt[i] = signal(i, pureOptions);
-              return this.Xe(() => t, accessor(this.nt[i]));
+              this.it[i] = signal(i, pureOptions);
+              return this.Xe(() => t, accessor(this.it[i]));
             }
           : () => {
               const t = e[i];
               return this.Xe(() => t);
             };
     if (t === 0) {
-      if (this.Ze !== 0) {
-        this.Ye.dispose(false);
-        this.Je = [];
-        this.qe = [];
+      if (this.qe !== 0) {
+        this.Ze.dispose(false);
+        this.et = [];
         this.ze = [];
-        this.Ze = 0;
-        this.tt && (this.tt = []);
+        this.Je = [];
+        this.qe = 0;
         this.nt && (this.nt = []);
+        this.it && (this.it = []);
       }
-      if (this.it && !this.ze[0]) {
-        this.ze[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
+      if (this.rt && !this.Je[0]) {
+        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.rt);
       }
-    } else if (this.Ze === 0) {
-      if (this.Je[0]) this.Je[0].dispose();
-      this.ze = new Array(t);
+    } else if (this.qe === 0) {
+      if (this.et[0]) this.et[0].dispose();
+      this.Je = new Array(t);
       for (i = 0; i < t; i++) {
-        this.qe[i] = e[i];
-        this.ze[i] = runWithOwner((this.Je[i] = createOwner()), r);
+        this.ze[i] = e[i];
+        this.Je[i] = runWithOwner((this.et[i] = createOwner()), r);
       }
-      this.Ze = t;
+      this.qe = t;
     } else {
       let s,
         o,
         u,
+        l,
         c,
         a,
-        l,
         f,
         E = new Array(t),
-        d = new Array(t),
-        T = this.tt ? new Array(t) : undefined,
-        S = this.nt ? new Array(t) : undefined;
+        S = new Array(t),
+        T = this.nt ? new Array(t) : undefined,
+        d = this.it ? new Array(t) : undefined;
       for (
-        s = 0, o = Math.min(this.Ze, t);
-        s < o && (this.qe[s] === e[s] || (this.tt && compare(this.et, this.qe[s], e[s])));
+        s = 0, o = Math.min(this.qe, t);
+        s < o && (this.ze[s] === e[s] || (this.nt && compare(this.tt, this.ze[s], e[s])));
         s++
       ) {
-        if (this.tt) setSignal(this.tt[s], e[s]);
+        if (this.nt) setSignal(this.nt[s], e[s]);
       }
       for (
-        o = this.Ze - 1, u = t - 1;
+        o = this.qe - 1, u = t - 1;
         o >= s &&
         u >= s &&
-        (this.qe[o] === e[u] || (this.tt && compare(this.et, this.qe[o], e[u])));
+        (this.ze[o] === e[u] || (this.nt && compare(this.tt, this.ze[o], e[u])));
         o--, u--
       ) {
-        E[u] = this.ze[o];
-        d[u] = this.Je[o];
-        T && (T[u] = this.tt[o]);
-        S && (S[u] = this.nt[o]);
+        E[u] = this.Je[o];
+        S[u] = this.et[o];
+        T && (T[u] = this.nt[o]);
+        d && (d[u] = this.it[o]);
       }
-      l = new Map();
+      a = new Map();
       f = new Array(u + 1);
       for (i = u; i >= s; i--) {
-        c = e[i];
-        a = this.et ? this.et(c) : c;
-        n = l.get(a);
+        l = e[i];
+        c = this.tt ? this.tt(l) : l;
+        n = a.get(c);
         f[i] = n === undefined ? -1 : n;
-        l.set(a, i);
+        a.set(c, i);
       }
       for (n = s; n <= o; n++) {
-        c = this.qe[n];
-        a = this.et ? this.et(c) : c;
-        i = l.get(a);
+        l = this.ze[n];
+        c = this.tt ? this.tt(l) : l;
+        i = a.get(c);
         if (i !== undefined && i !== -1) {
-          E[i] = this.ze[n];
-          d[i] = this.Je[n];
-          T && (T[i] = this.tt[n]);
-          S && (S[i] = this.nt[n]);
+          E[i] = this.Je[n];
+          S[i] = this.et[n];
+          T && (T[i] = this.nt[n]);
+          d && (d[i] = this.it[n]);
           i = f[i];
-          l.set(a, i);
-        } else this.Je[n].dispose();
+          a.set(c, i);
+        } else this.et[n].dispose();
       }
       for (i = s; i < t; i++) {
         if (i in E) {
-          this.ze[i] = E[i];
-          this.Je[i] = d[i];
+          this.Je[i] = E[i];
+          this.et[i] = S[i];
           if (T) {
-            this.tt[i] = T[i];
-            setSignal(this.tt[i], e[i]);
+            this.nt[i] = T[i];
+            setSignal(this.nt[i], e[i]);
           }
-          if (S) {
-            this.nt[i] = S[i];
-            setSignal(this.nt[i], i);
+          if (d) {
+            this.it[i] = d[i];
+            setSignal(this.it[i], i);
           }
         } else {
-          this.ze[i] = runWithOwner((this.Je[i] = createOwner()), r);
+          this.Je[i] = runWithOwner((this.et[i] = createOwner()), r);
         }
       }
-      this.ze = this.ze.slice(0, (this.Ze = t));
-      this.qe = e.slice(0);
+      this.Je = this.Je.slice(0, (this.qe = t));
+      this.ze = e.slice(0);
     }
   });
-  return this.ze;
+  return this.Je;
 }
 function repeat(e, t, n) {
   const i = t;
-  return updateRepeat.bind({
-    Ye: createOwner(),
-    Ze: 0,
-    rt: 0,
-    st: e,
-    Xe: i,
-    Je: [],
-    ze: [],
-    ot: n?.from,
-    it: n?.fallback
-  });
+  const r = computed(
+    updateRepeat.bind({
+      Ze: createOwner(),
+      qe: 0,
+      st: 0,
+      ot: e,
+      Xe: i,
+      et: [],
+      Je: [],
+      ut: n?.from,
+      rt: n?.fallback
+    })
+  );
+  r._e &= ~CONFIG_AUTO_DISPOSE;
+  return accessor(r);
 }
 function updateRepeat() {
-  const e = this.st();
-  const t = this.ot?.() || 0;
-  runWithOwner(this.Ye, () => {
+  const e = this.ot();
+  const t = this.ut?.() || 0;
+  runWithOwner(this.Ze, () => {
     if (e === 0) {
-      if (this.Ze !== 0) {
-        this.Ye.dispose(false);
+      if (this.qe !== 0) {
+        this.Ze.dispose(false);
+        this.et = [];
         this.Je = [];
-        this.ze = [];
-        this.Ze = 0;
+        this.qe = 0;
       }
-      if (this.it && !this.ze[0]) {
-        this.ze[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
+      if (this.rt && !this.Je[0]) {
+        this.Je[0] = runWithOwner((this.et[0] = createOwner()), this.rt);
       }
       return;
     }
     const n = t + e;
-    const i = this.rt + this.Ze;
-    if (this.Ze === 0 && this.Je[0]) this.Je[0].dispose();
-    for (let e = n; e < i; e++) this.Je[e - this.rt].dispose();
-    if (this.rt < t) {
-      let e = this.rt;
-      while (e < t && e < this.Ze) this.Je[e++].dispose();
-      this.Je.splice(0, t - this.rt);
-      this.ze.splice(0, t - this.rt);
-    } else if (this.rt > t) {
-      let n = i - this.rt - 1;
-      let r = this.rt - t;
-      this.Je.length = this.ze.length = e;
+    const i = this.st + this.qe;
+    if (this.qe === 0 && this.et[0]) this.et[0].dispose();
+    for (let e = n; e < i; e++) this.et[e - this.st].dispose();
+    if (this.st < t) {
+      let e = this.st;
+      while (e < t && e < this.qe) this.et[e++].dispose();
+      this.et.splice(0, t - this.st);
+      this.Je.splice(0, t - this.st);
+    } else if (this.st > t) {
+      let n = i - this.st - 1;
+      let r = this.st - t;
+      this.et.length = this.Je.length = e;
       while (n >= r) {
+        this.et[n] = this.et[n - r];
         this.Je[n] = this.Je[n - r];
-        this.ze[n] = this.ze[n - r];
         n--;
       }
       for (let e = 0; e < r; e++) {
-        this.ze[e] = runWithOwner((this.Je[e] = createOwner()), () => this.Xe(e + t));
+        this.Je[e] = runWithOwner((this.et[e] = createOwner()), () => this.Xe(e + t));
       }
     }
     for (let e = i; e < n; e++) {
-      this.ze[e - t] = runWithOwner((this.Je[e - t] = createOwner()), () => this.Xe(e));
+      this.Je[e - t] = runWithOwner((this.et[e - t] = createOwner()), () => this.Xe(e));
     }
-    this.ze = this.ze.slice(0, e);
-    this.rt = t;
-    this.Ze = e;
+    this.Je = this.Je.slice(0, e);
+    this.st = t;
+    this.qe = e;
   });
-  return this.ze;
+  return this.Je;
 }
 function compare(e, t, n) {
   return e ? e(t) === e(n) : true;
 }
 function boundaryComputed(e, t) {
-  const n = computed(e, undefined, { lazy: true });
-  n.Ge = (e, t) => {
-    const i = e !== undefined ? e : n.Se;
-    const r = t !== undefined ? t : n.fe;
-    n.Se &= ~n.ut;
-    n.F.notify(n, n.ut, i, r);
+  const n = computed(e, { lazy: true });
+  n.xe = (e, t) => {
+    const i = e !== undefined ? e : n.he;
+    const r = t !== undefined ? t : n.Re;
+    n.he &= ~n.lt;
+    n.te.notify(n, n.lt, i, r);
   };
-  n.ut = t;
-  n.Pe = true;
+  n.lt = t;
+  n._e &= ~CONFIG_AUTO_DISPOSE;
   recompute(n, true);
   return n;
 }
 function createBoundChildren(e, t, n, i) {
-  const r = e.F;
-  r.addChild((e.F = n));
-  cleanup(() => r.removeChild(e.F));
+  const r = e.te;
+  r.addChild((e.te = n));
+  cleanup(() => r.removeChild(e.te));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
@@ -3114,168 +3598,215 @@ const ON_INIT = Symbol();
 const RevealControllerContext = createContext(null);
 let _revealUsed = false;
 const FALSE_ACCESSOR = () => false;
+const SEQUENTIAL_ACCESSOR = () => "sequential";
 function isRevealController(e) {
   return e instanceof RevealController;
 }
 function isSlotReady(e) {
-  return isRevealController(e) ? e.isReady() : e.ct.size === 0 && !e.lt;
+  return isRevealController(e) ? e.isReady() : e.ct.size === 0 && !e.ft;
+}
+function isSlotMinimallyReady(e) {
+  return isRevealController(e) ? e.isMinimallyReady() : isSlotReady(e);
 }
 function setSlotState(e, t, n, i) {
-  setSignal(e.ft, n);
-  setSignal(e.Et, i);
+  setSignal(e.Et, n);
+  setSignal(e.St, i);
   if (isRevealController(e)) {
-    if (!n && e.dt === t) e.dt = undefined;
+    if (!n && e.Tt === t) e.Tt = undefined;
     return e.evaluate(n, i);
   }
-  if (!n && e.Tt === t && e.St) e.Tt = undefined;
+  if (!n && e.dt === t && e.Ot) e.dt = undefined;
 }
 class RevealController {
+  _t;
   Rt;
-  Ot;
-  _t = [];
-  dt;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
-  It = true;
-  ht = false;
+  It = [];
+  Tt;
+  Et = signal(false, { ownedWrite: true, Ye: true });
+  St = signal(false, { ownedWrite: true, Ye: true });
+  ht = true;
+  Nt = true;
+  At = false;
   constructor(e, t) {
-    this.Rt = e;
-    this.Ot = t;
+    this._t = e;
+    this.Rt = t;
   }
-  At(e) {
-    for (let t = 0; t < this._t.length; t++) {
-      const n = this._t[t];
-      if ((isRevealController(n) ? n.dt : n.Tt) !== this) continue;
+  Ct(e) {
+    for (let t = 0; t < this.It.length; t++) {
+      const n = this.It[t];
+      if ((isRevealController(n) ? n.Tt : n.dt) !== this) continue;
       if (e(n) === false) return false;
     }
     return true;
   }
   isReady() {
-    return this.At(isSlotReady);
+    return this.Ct(isSlotReady);
+  }
+  isMinimallyReady() {
+    const e = untrack(this._t);
+    if (e === "together") return this.isReady();
+    if (e === "natural") {
+      let e = false;
+      let t = false;
+      this.Ct(n => {
+        e = true;
+        if (isSlotMinimallyReady(n)) {
+          t = true;
+          return false;
+        }
+      });
+      return !e || t;
+    }
+    let t = true;
+    this.Ct(e => {
+      t = isSlotMinimallyReady(e);
+      return false;
+    });
+    return t;
   }
   register(e) {
-    if (this._t.includes(e)) return;
-    this._t.push(e);
-    const t = !!untrack(this.Rt);
-    setSignal(e.ft, true), setSignal(e.Et, t ? false : !!untrack(this.Ot));
+    if (this.It.includes(e)) return;
+    this.It.push(e);
+    const t = untrack(this._t);
+    (setSignal(e.Et, true), setSignal(e.St, t === "sequential" ? !!untrack(this.Rt) : false));
     untrack(() => this.evaluate());
   }
   unregister(e) {
-    const t = this._t.indexOf(e);
-    if (t >= 0) this._t.splice(t, 1);
+    const t = this.It.indexOf(e);
+    if (t >= 0) this.It.splice(t, 1);
     untrack(() => this.evaluate());
   }
   evaluate(e, t) {
-    if (this.ht) return;
-    this.ht = true;
-    const n = this.It;
+    if (this.At) return;
+    this.At = true;
+    const n = this.ht;
+    const i = this.Nt;
     try {
-      const n = e ?? read(this.ft),
-        i = !!untrack(this.Ot),
-        r = t ?? i;
-      if (n && r) this.At(e => setSlotState(e, this, true, true));
-      else if (!!untrack(this.Rt)) {
-        const e = this.isReady();
-        this.At(t => setSlotState(t, this, !e, false));
+      const n = e ?? read(this.Et),
+        i = untrack(this._t),
+        r = i === "sequential" && !!untrack(this.Rt),
+        s = t ?? r;
+      if (n) {
+        this.Ct(e => setSlotState(e, this, true, s));
+      } else if (i === "natural") {
+        this.Ct(e => {
+          if (isRevealController(e)) {
+            setSignal(e.St, false);
+            setSignal(e.Et, false);
+            e.evaluate(false, false);
+          } else {
+            setSlotState(e, this, !isSlotReady(e), false);
+          }
+        });
+      } else if (i === "together") {
+        const e = this.Ct(isSlotMinimallyReady);
+        this.Ct(t => setSlotState(t, this, !e, false));
       } else {
         let e = false;
-        this.At(t => {
-          if (e) return setSlotState(t, this, true, i);
+        this.Ct(t => {
+          if (e) return setSlotState(t, this, true, r);
           if (isSlotReady(t)) return setSlotState(t, this, false, false);
           e = true;
-          setSlotState(t, this, true, false);
+          if (isRevealController(t)) {
+            setSignal(t.St, false);
+            setSignal(t.Et, false);
+            t.evaluate(false, false);
+          } else {
+            setSlotState(t, this, true, false);
+          }
         });
       }
     } finally {
-      this.It = this.isReady();
-      this.ht = false;
+      this.ht = this.isReady();
+      this.Nt = this.isMinimallyReady();
+      this.At = false;
     }
-    if (this.dt && n !== this.It) this.dt.evaluate();
+    if (this.Tt && (n !== this.ht || i !== this.Nt)) this.Tt.evaluate();
   }
 }
 class CollectionQueue extends Queue {
-  Nt;
-  ct = new Set();
   Pt;
-  lt = true;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
-  Tt;
-  St = false;
+  ct = new Set();
   gt;
-  Ct = ON_INIT;
+  ft = true;
+  Et = signal(false, { ownedWrite: true, Ye: true });
+  St = signal(false, { ownedWrite: true, Ye: true });
+  dt;
+  Ot = false;
+  Dt;
+  yt = ON_INIT;
   constructor(e) {
     super();
-    this.Nt = e;
+    this.Pt = e;
   }
   run(e) {
-    if (!e || (read(this.ft) && (!_revealUsed || read(this.Et)))) return;
+    if (!e || (read(this.Et) && (!_revealUsed || read(this.St)))) return;
     return super.run(e);
   }
   notify(e, t, n, i) {
-    if (!(t & this.Nt)) return super.notify(e, t, n, i);
-    if (this.St && this.gt) {
+    if (!(t & this.Pt)) return super.notify(e, t, n, i);
+    if (this.Ot && this.Dt) {
       const e = untrack(() => {
         try {
-          return this.gt();
+          return this.Dt();
         } catch {
           return ON_INIT;
         }
       });
-      if (e !== this.Ct) {
-        this.Ct = e;
-        this.St = false;
+      if (e !== this.yt) {
+        this.yt = e;
+        this.Ot = false;
         this.ct.clear();
       }
     }
-    if (this.Nt & STATUS_PENDING && this.St) return super.notify(e, t, n, i);
-    if (this.Nt & STATUS_PENDING && n & STATUS_ERROR) {
+    if (this.Pt & STATUS_PENDING && this.Ot) return super.notify(e, t, n, i);
+    if (this.Pt & STATUS_PENDING && n & STATUS_ERROR) {
       return super.notify(e, STATUS_ERROR, n, i);
     }
-    if (n & this.Nt) {
-      this.lt = true;
-      const t = i?.source || e.fe?.source;
+    if (n & this.Pt) {
+      this.ft = true;
+      const t = i?.source || e.Re?.source;
       if (t) {
         const e = this.ct.size === 0;
         this.ct.add(t);
-        if (e) setSignal(this.ft, true);
+        if (e) setSignal(this.Et, true);
       }
     }
-    t &= ~this.Nt;
+    t &= ~this.Pt;
     return t ? super.notify(e, t, n, i) : true;
   }
   checkSources() {
     for (const e of this.ct) {
       if (
-        e.O & REACTIVE_DISPOSED ||
-        (!(e.Se & this.Nt) && !(this.Nt & STATUS_ERROR && e.Se & STATUS_PENDING))
+        e._ & REACTIVE_DISPOSED ||
+        (!(e.he & this.Pt) && !(this.Pt & STATUS_ERROR && e.he & STATUS_PENDING))
       )
         this.ct.delete(e);
     }
     if (!this.ct.size) {
-      if (this.Nt & STATUS_PENDING && this.lt && !this.St && this.Pt) {
-        this.lt = !!(this.Pt.Se & this.Nt);
+      if (this.Pt & STATUS_PENDING && this.ft && !this.Ot && this.gt) {
+        this.ft = !!(this.gt.he & this.Pt);
       } else {
-        this.lt = false;
+        this.ft = false;
       }
-      if (!this.lt) {
-        setSignal(this.ft, false);
-        if (this.gt) {
+      if (!this.ft) {
+        setSignal(this.Et, false);
+        if (this.Dt) {
           try {
-            this.Ct = untrack(() => this.gt());
+            this.yt = untrack(() => this.Dt());
           } catch {}
         }
       }
     }
-    if (_revealUsed) this.Tt?.evaluate();
+    if (_revealUsed) this.dt?.evaluate();
   }
 }
 function createCollectionBoundary(e, t, n, i) {
   const r = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, r);
   const s = new CollectionQueue(e);
-  if (i) s.gt = i;
-  const o = (s.Pt = createBoundChildren(r, t, s, e));
+  if (i) s.Dt = i;
+  const o = (s.gt = createBoundChildren(r, t, s, e));
   untrack(() => {
     let t = false;
     try {
@@ -3284,23 +3815,24 @@ function createCollectionBoundary(e, t, n, i) {
       if (e instanceof NotReadyError) t = true;
       else throw e;
     }
-    s.lt = t || !!(o.Se & e) || o.fe instanceof NotReadyError;
+    s.ft = t || !!(o.he & e) || o.Re instanceof NotReadyError;
   });
   const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
   if (u) {
-    s.Tt = u;
+    s.dt = u;
     u.register(s);
     cleanup(() => u.unregister(s));
   }
-  const c = computed(() => {
-    if (!read(s.ft)) {
-      const e = read(o);
-      if (!untrack(() => read(s.ft))) return (s.St = true), e;
-    }
-    if (_revealUsed && read(s.Et)) return undefined;
-    return n(s);
-  });
-  return accessor(c);
+  return accessor(
+    computed(() => {
+      if (!read(s.Et)) {
+        const e = read(o);
+        if (!untrack(() => read(s.Et))) return ((s.Ot = true), e);
+      }
+      if (_revealUsed && read(s.St)) return undefined;
+      return n(s);
+    })
+  );
 }
 function createLoadingBoundary(e, t, n) {
   return createCollectionBoundary(STATUS_PENDING, e, () => t(), n?.on);
@@ -3308,7 +3840,7 @@ function createLoadingBoundary(e, t, n) {
 function createErrorBoundary(e, t) {
   return createCollectionBoundary(STATUS_ERROR, e, e => {
     let n = e.ct.values().next().value;
-    const i = n.fe?.cause ?? n.fe;
+    const i = n.Re?.cause ?? n.Re;
     return t(i, () => {
       for (const t of e.ct) recompute(t);
       schedule();
@@ -3319,7 +3851,7 @@ function createRevealOrder(e, t) {
   _revealUsed = true;
   const n = createOwner();
   const i = getContext(RevealControllerContext);
-  const r = t?.together || FALSE_ACCESSOR,
+  const r = t?.order || SEQUENTIAL_ACCESSOR,
     s = t?.collapsed || FALSE_ACCESSOR;
   const o = new RevealController(r, s);
   setContext(RevealControllerContext, o, n);
@@ -3331,7 +3863,7 @@ function createRevealOrder(e, t) {
       o.evaluate();
     });
     if (i) {
-      o.dt = i;
+      o.Tt = i;
       i.register(o);
       cleanup(() => i.unregister(o));
     }