@solidjs/signals 0.13.13 → 2.0.0-beta.8

package/dist/prod.js

@@ -150,16 +150,33 @@ let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(e) {
+  transientStoreNodes.add(e);
+}
+function sweepTransientStoreNodes() {
+  if (transientStoreNodes.size === 0) return;
+  for (const e of transientStoreNodes) {
+    if (e.I !== null) {
+      transientStoreNodes.delete(e);
+      continue;
+    }
+    if (e.U !== NOT_PENDING) continue;
+    if (e.k !== undefined && e.k !== NOT_PENDING) continue;
+    transientStoreNodes.delete(e);
+    e.G?.();
+  }
+}
 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.W || t.H.size > 0) continue;
+    const n = t.M[e - 1];
     if (n.length) {
-      t.G[e - 1] = [];
+      t.M[e - 1] = [];
       runQueue(n, e);
     }
   }
@@ -167,11 +184,11 @@ function runLaneEffects(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);
+    if (!e.F) continue;
+    if (e.F === EFFECT_TRACKED) {
+      if (!e.j) {
+        e.j = true;
+        e.$.enqueue(EFFECT_USER, e.K);
       }
       continue;
     }
@@ -184,66 +201,66 @@ 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.Y = e;
+  e.Z.push(...t.Z);
+  for (const n of activeLanes) if (n.B === t) n.B = e;
+  e.q.push(...t.q);
+  for (const n of t.X) e.X.add(n);
+  for (const [n, i] of t.J) {
+    let t = e.J.get(n);
+    if (!t) e.J.set(n, (t = new Set()));
     for (const e of i) t.add(e);
   }
 }
 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.ee = undefined;
+    if (n.U !== NOT_PENDING) {
+      n.te = n.U;
+      n.U = 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.te !== i) insertSubs(n, true);
+    n.B = null;
   }
   e.length = 0;
 }
 function cleanupCompletedLanes(e) {
   for (const t of activeLanes) {
-    const n = e ? t.K === e : !t.K;
+    const n = e ? t.B === e : !t.B;
     if (!n) continue;
-    if (!t.U) {
-      if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
-      if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
-    }
-    if (t.te.q === t) t.te.q = undefined;
-    t.k.clear();
-    t.G[0].length = 0;
-    t.G[1].length = 0;
+    if (!t.W) {
+      if (t.M[0].length) runQueue(t.M[0], EFFECT_RENDER);
+      if (t.M[1].length) runQueue(t.M[1], EFFECT_USER);
+    }
+    if (t.ne.ee === t) t.ne.ee = undefined;
+    t.H.clear();
+    t.M[0].length = 0;
+    t.M[1].length = 0;
     activeLanes.delete(t);
-    signalLanes.delete(t.te);
+    signalLanes.delete(t.ne);
   }
 }
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.ne && !projectionWriteActive) queueMicrotask(flush);
+  if (!globalQueue.ie && !projectionWriteActive) queueMicrotask(flush);
 }
 class Queue {
   i = null;
-  ie = [[], []];
-  re = [];
+  re = [[], []];
+  se = [];
   created = clock;
   addChild(e) {
-    this.re.push(e);
+    this.se.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.re.indexOf(e);
+    const t = this.se.indexOf(e);
     if (t >= 0) {
-      this.re.splice(t, 1);
+      this.se.splice(t, 1);
       e.i = null;
     }
   }
@@ -252,81 +269,81 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.ie[e - 1].length) {
-      const t = this.ie[e - 1];
-      this.ie[e - 1] = [];
+    if (this.re[e - 1].length) {
+      const t = this.re[e - 1];
+      this.re[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.se.length; t++) this.se[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.G[e - 1].push(t);
+        n.M[e - 1].push(t);
       } else {
-        this.ie[e - 1].push(t);
+        this.re[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.re[0].push(...this.re[0]);
+    e.re[1].push(...this.re[1]);
+    this.re = [[], []];
+    for (let t = 0; t < this.se.length; t++) {
+      let n = this.se[t];
+      let i = e.se[t];
       if (!i) {
-        i = { ie: [[], []], re: [] };
-        e.re[t] = i;
+        i = { re: [[], []], se: [] };
+        e.se[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.re[0].push(...e.re[0]);
+    this.re[1].push(...e.re[1]);
+    for (let t = 0; t < e.se.length; t++) {
+      const n = e.se[t];
+      let i = this.se[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  ne = false;
-  se = [];
-  Y = [];
-  Z = new Set();
-  static oe;
+  ie = false;
+  oe = [];
+  q = [];
+  X = new Set();
   static ue;
-  static ce = null;
+  static ce;
+  static ae = null;
   flush() {
-    if (this.ne) return;
-    this.ne = true;
+    if (this.ie) return;
+    this.ie = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.oe);
+      runHeap(dirtyQueue, GlobalQueue.ue);
       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.ue);
+          this.oe = [];
+          this.q = [];
+          this.X = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(e.ae);
+          this.stashQueues(e.le);
           clock++;
           scheduled = dirtyQueue.R >= dirtyQueue.P;
-          reassignPendingTransition(e.se);
+          reassignPendingTransition(e.oe);
           activeTransition = null;
-          if (!e.$.length && e.Y.length) {
+          if (!e.Z.length && e.q.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.q.length; t++) {
+              const n = e.q[t];
+              if (n.L || n.fe) continue;
               stashedOptimisticReads.add(n);
               queueStashedOptimisticEffects(n);
             }
@@ -338,15 +355,15 @@ class GlobalQueue extends Queue {
           }
           return;
         }
-        this.se !== activeTransition.se && this.se.push(...activeTransition.se);
-        this.restoreQueues(activeTransition.ae);
+        this.oe !== activeTransition.oe && this.oe.push(...activeTransition.oe);
+        this.restoreQueues(activeTransition.le);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.se);
+        reassignPendingTransition(this.oe);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.oe);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.ue);
         finalizePureQueue();
       }
       clock++;
@@ -357,17 +374,17 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_USER);
       if (false);
     } finally {
-      this.ne = false;
+      this.ie = 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.Ee;
         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.J.get(n);
+          if (!i) activeTransition.J.set(n, (i = new Set()));
           const r = i.size;
           i.add(e);
           if (i.size !== r) schedule();
@@ -380,17 +397,17 @@ 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.de === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        Ee: clock,
-        se: [],
-        B: new Map(),
-        Y: [],
-        Z: new Set(),
-        $: [],
-        ae: { ie: [[], []], re: [] },
-        j: false
+        de: clock,
+        oe: [],
+        J: new Map(),
+        q: [],
+        X: new Set(),
+        Z: [],
+        le: { re: [[], []], se: [] },
+        Y: false
       };
     } else if (e) {
       const t = activeTransition;
@@ -399,37 +416,37 @@ 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.de = clock;
+    if (this.oe !== activeTransition.oe) {
+      for (let e = 0; e < this.oe.length; e++) {
+        const t = this.oe[e];
+        t.B = activeTransition;
+        activeTransition.oe.push(t);
       }
-      this.se = activeTransition.se;
+      this.oe = activeTransition.oe;
     }
-    if (this.Y !== activeTransition.Y) {
-      for (let e = 0; e < this.Y.length; e++) {
-        const t = this.Y[e];
-        t.K = activeTransition;
-        activeTransition.Y.push(t);
+    if (this.q !== activeTransition.q) {
+      for (let e = 0; e < this.q.length; e++) {
+        const t = this.q[e];
+        t.B = activeTransition;
+        activeTransition.q.push(t);
       }
-      this.Y = activeTransition.Y;
+      this.q = activeTransition.q;
     }
     for (const e of activeLanes) {
-      if (!e.K) e.K = activeTransition;
+      if (!e.B) e.B = activeTransition;
     }
-    if (this.Z !== activeTransition.Z) {
-      for (const e of this.Z) activeTransition.Z.add(e);
-      this.Z = activeTransition.Z;
+    if (this.X !== activeTransition.X) {
+      for (const e of this.X) activeTransition.X.add(e);
+      this.X = activeTransition.X;
     }
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.q || currentOptimisticLane;
-  const i = e.de !== undefined;
+  const n = e.ee || currentOptimisticLane;
+  const i = e.Te !== undefined;
   for (let r = e.I; r !== null; r = r.h) {
-    if (i && r.p.Te) {
+    if (i && r.p.Se) {
       r.p.O |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
@@ -438,13 +455,13 @@ function insertSubs(e, t = false) {
       assignOrMergeLane(r.p, n);
     } else if (t) {
       r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      r.p.q = undefined;
+      r.p.ee = undefined;
     }
     const e = r.p;
-    if (e.W === EFFECT_TRACKED) {
-      if (!e.H) {
-        e.H = true;
-        e.F.enqueue(EFFECT_USER, e.M);
+    if (e.F === EFFECT_TRACKED) {
+      if (!e.j) {
+        e.j = true;
+        e.$.enqueue(EFFECT_USER, e.K);
       }
       continue;
     }
@@ -454,16 +471,16 @@ function insertSubs(e, t = false) {
   }
 }
 function commitPendingNodes() {
-  const e = globalQueue.se;
+  const e = globalQueue.oe;
   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.U !== NOT_PENDING) {
+      n.te = n.U;
+      n.U = NOT_PENDING;
+      if (n.F && n.F !== EFFECT_TRACKED) n.j = true;
     }
-    if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
-    if (n.L) GlobalQueue.ue(n, false, true);
+    if (!(n.Re & STATUS_PENDING)) n.Re &= ~STATUS_UNINITIALIZED;
+    if (n.L) GlobalQueue.ce(n, false, true);
   }
   e.length = 0;
 }
@@ -471,39 +488,40 @@ 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 (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.ue);
   if (n) {
     commitPendingNodes();
-    resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
-    const t = e ? e.Z : globalQueue.Z;
-    if (GlobalQueue.ce && t.size) {
+    resolveOptimisticNodes(e ? e.q : globalQueue.q);
+    const t = e ? e.X : globalQueue.X;
+    if (GlobalQueue.ae && t.size) {
       for (const e of t) {
-        GlobalQueue.ce(e);
+        GlobalQueue.ae(e);
       }
       t.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(e);
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.re) {
+  for (const t of e.se) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function trackOptimisticStore(e) {
-  globalQueue.Z.add(e);
+  globalQueue.X.add(e);
   schedule();
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].K = activeTransition;
+    e[t].B = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
 function flush() {
-  if (globalQueue.ne) {
+  if (globalQueue.ie) {
     return;
   }
   while (scheduled || activeTransition) {
@@ -515,21 +533,21 @@ function runQueue(e, t) {
 }
 function reporterBlocksSource(e, t) {
   if (e.O & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-  if (e.Re === t || e.Oe?.has(t)) return true;
+  if (e.Oe === t || e._e?.has(t)) return true;
   for (let n = e.C; n; n = n.D) {
     let e = n.m;
     while (e) {
       if (e === t || e.V === t) return true;
-      e = e._e;
+      e = e.Ie;
     }
   }
-  return !!(e.Se & STATUS_PENDING && e.fe instanceof NotReadyError && e.fe.source === t);
+  return !!(e.Re & STATUS_PENDING && e.Ee instanceof NotReadyError && e.Ee.source === t);
 }
 function transitionComplete(e) {
-  if (e.j) return true;
-  if (e.$.length) return false;
+  if (e.Y) return true;
+  if (e.Z.length) return false;
   let t = true;
-  for (const [n, i] of e.B) {
+  for (const [n, i] of e.J) {
     let r = false;
     for (const e of i) {
       if (reporterBlocksSource(e, n)) {
@@ -538,32 +556,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.J.delete(n);
+    else if (n.Re & STATUS_PENDING && n.Ee?.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.q.length; n++) {
+      const i = e.q[n];
       if (
         hasActiveOverride(i) &&
-        "Se" in i &&
-        i.Se & STATUS_PENDING &&
-        i.fe instanceof NotReadyError &&
-        i.fe.source !== i
+        "Re" in i &&
+        i.Re & STATUS_PENDING &&
+        i.Ee instanceof NotReadyError &&
+        i.Ee.source !== i
       ) {
         t = false;
         break;
       }
     }
   }
-  t && (e.j = true);
+  t && (e.Y = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.j && typeof e.j === "object") e = e.j;
+  while (e.Y && typeof e.Y === "object") e = e.Y;
   return e;
 }
 function setActiveTransition(e) {
@@ -585,75 +603,75 @@ function getOrCreateLane(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 };
+  const n = e.Ie;
+  const i = n?.ee ? findLane(n.ee) : null;
+  t = { ne: e, H: new Set(), M: [[], []], W: null, B: activeTransition, he: i };
   signalLanes.set(e, t);
   activeLanes.add(t);
-  e.he = false;
+  e.pe = false;
   return t;
 }
 function findLane(e) {
-  while (e.U) e = e.U;
+  while (e.W) e = e.W;
   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]);
+  t.W = e;
+  for (const n of t.H) e.H.add(n);
+  e.M[0].push(...t.M[0]);
+  e.M[1].push(...t.M[1]);
   return e;
 }
 function resolveLane(e) {
-  const t = e.q;
+  const t = e.ee;
   if (!t) return undefined;
   const n = findLane(t);
   if (activeLanes.has(n)) return n;
-  e.q = undefined;
+  e.ee = undefined;
   return undefined;
 }
 function resolveTransition(e) {
-  return resolveLane(e)?.K ?? e.K;
+  return resolveLane(e)?.B ?? e.B;
 }
 function hasActiveOverride(e) {
-  return !!(e.ee !== undefined && e.ee !== NOT_PENDING);
+  return !!(e.k !== undefined && e.k !== NOT_PENDING);
 }
 function assignOrMergeLane(e, t) {
   const n = findLane(t);
-  const i = e.q;
+  const i = e.ee;
   if (i) {
-    if (i.U) {
-      e.q = t;
+    if (i.W) {
+      e.ee = 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);
+        if (n.he && findLane(n.he) === r) {
+          e.ee = t;
+        } else if (r.he && findLane(r.he) === n);
         else mergeLanes(n, r);
       }
       return;
     }
   }
-  e.q = t;
+  e.ee = 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;
+  const r = e.Ae;
+  if (i !== null) i.Ae = r;
+  else t.Ne = r;
   if (r !== null) r.h = i;
   else {
     t.I = i;
     if (i === null) {
-      t.Ne?.();
+      t.G?.();
       t.L && !t.Pe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
     }
   }
@@ -666,6 +684,7 @@ function unobserved(e) {
     t = unlinkSubs(t);
   }
   e.C = null;
+  e.ge = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
@@ -680,9 +699,9 @@ function link(e, t) {
       return;
     }
   }
-  const s = e.Ae;
+  const s = e.Ne;
   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 });
+  const o = (t.ge = e.Ne = { m: e, p: t, D: i, Ae: s, h: null });
   if (n !== null) n.D = o;
   else t.C = o;
   if (s !== null) s.h = o;
@@ -808,7 +827,7 @@ function createOwner(e) {
     Ce: null,
     De: null,
     Ve: null,
-    F: t?.F ?? globalQueue,
+    $: t?.$ ?? globalQueue,
     Le: t?.Le || defaultContext,
     me: 0,
     we: null,
@@ -834,51 +853,51 @@ function createRoot(e, t) {
   return runWithOwner(n, () => e(n.dispose));
 }
 function addPendingSource(e, t) {
-  if (e.Re === t || e.Oe?.has(t)) return false;
-  if (!e.Re) {
-    e.Re = t;
+  if (e.Oe === t || e._e?.has(t)) return false;
+  if (!e.Oe) {
+    e.Oe = t;
     return true;
   }
-  if (!e.Oe) {
-    e.Oe = new Set([e.Re, t]);
+  if (!e._e) {
+    e._e = new Set([e.Oe, t]);
   } else {
-    e.Oe.add(t);
+    e._e.add(t);
   }
-  e.Re = undefined;
+  e.Oe = undefined;
   return true;
 }
 function removePendingSource(e, t) {
-  if (e.Re) {
-    if (e.Re !== t) return false;
-    e.Re = undefined;
+  if (e.Oe) {
+    if (e.Oe !== t) return false;
+    e.Oe = 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._e?.delete(t)) return false;
+  if (e._e.size === 1) {
+    e.Oe = e._e.values().next().value;
+    e._e = undefined;
+  } else if (e._e.size === 0) {
+    e._e = undefined;
   }
   return true;
 }
 function clearPendingSources(e) {
-  e.Re = undefined;
-  e.Oe?.clear();
   e.Oe = undefined;
+  e._e?.clear();
+  e._e = undefined;
 }
 function setPendingError(e, t, n) {
   if (!t) {
-    e.fe = null;
+    e.Ee = null;
     return;
   }
   if (n instanceof NotReadyError && n.source === t) {
-    e.fe = n;
+    e.Ee = n;
     return;
   }
-  const i = e.fe;
+  const i = e.Ee;
   if (!(i instanceof NotReadyError) || i.source !== t) {
-    e.fe = new NotReadyError(t);
+    e.Ee = new NotReadyError(t);
   }
 }
 function forEachDependent(e, t) {
@@ -893,21 +912,21 @@ 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.de = clock;
+    const r = i.Oe ?? i._e?.values().next().value;
     if (r) {
       setPendingError(i, r);
       updatePendingSignal(i);
     } else {
-      i.Se &= ~STATUS_PENDING;
+      i.Re &= ~STATUS_PENDING;
       setPendingError(i);
       updatePendingSignal(i);
       if (i.Ue) {
-        if (i.W === EFFECT_TRACKED) {
+        if (i.F === EFFECT_TRACKED) {
           const e = i;
-          if (!e.H) {
-            e.H = true;
-            e.F.enqueue(EFFECT_USER, e.M);
+          if (!e.j) {
+            e.j = true;
+            e.$.enqueue(EFFECT_USER, e.K);
           }
         } else {
           const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
@@ -937,33 +956,33 @@ function handleAsync(e, t, n) {
     if (e.ye !== t) return;
     globalQueue.initTransition(resolveTransition(e));
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.Ee = clock;
+    e.de = clock;
   };
   const asyncWrite = (i, r) => {
     if (e.ye !== t) return;
     if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(e));
-    const s = !!(e.Se & STATUS_UNINITIALIZED);
+    const s = !!(e.Re & STATUS_UNINITIALIZED);
     clearStatus(e);
     const o = resolveLane(e);
-    if (o) o.k.delete(e);
+    if (o) o.H.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.U = i;
       else {
-        e.J = i;
+        e.te = i;
         insertSubs(e);
       }
-      e.Ee = clock;
+      e.de = clock;
     } else if (o) {
-      const t = e.W;
-      const n = e.J;
+      const t = e.F;
+      const n = e.te;
       const r = e.ke;
       if ((!t && s) || !r || !r(i, n)) {
-        e.J = i;
-        e.Ee = clock;
-        if (e.xe) {
-          setSignal(e.xe, i);
+        e.te = i;
+        e.de = clock;
+        if (e.Ge) {
+          setSignal(e.Ge, i);
         }
         insertSubs(e, true);
       }
@@ -1054,27 +1073,27 @@ function handleAsync(e, t, n) {
 function clearStatus(e, t = false) {
   clearPendingSources(e);
   e.Ue = false;
-  e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
+  e.Re = t ? 0 : e.Re & STATUS_UNINITIALIZED;
   setPendingError(e);
   updatePendingSignal(e);
-  e.Ge?.();
+  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 u = t === STATUS_PENDING && e.k !== undefined && !o;
   const c = u && hasActiveOverride(e);
   if (!i) {
     if (t === STATUS_PENDING && s) {
       addPendingSource(e, s);
-      e.Se = STATUS_PENDING | (e.Se & STATUS_UNINITIALIZED);
+      e.Re = STATUS_PENDING | (e.Re & STATUS_UNINITIALIZED);
       setPendingError(e, s, n);
     } else {
       clearPendingSources(e);
-      e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
-      e.fe = n;
+      e.Re = t | (t !== STATUS_ERROR ? e.Re & STATUS_UNINITIALIZED : 0);
+      e.Ee = n;
     }
     updatePendingSignal(e);
   }
@@ -1083,24 +1102,24 @@ function notifyStatus(e, t, n, i, r) {
   }
   const a = i || c;
   const l = i || u ? undefined : r;
-  if (e.Ge) {
+  if (e.xe) {
     if (i && t === STATUS_PENDING) {
       return;
     }
     if (a) {
-      e.Ge(t, n);
+      e.xe(t, n);
     } else {
-      e.Ge();
+      e.xe();
     }
     return;
   }
   forEachDependent(e, e => {
-    e.Ee = clock;
+    e.de = 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.Oe !== s && !e._e?.has(s)) ||
+      (t !== STATUS_PENDING && (e.Ee !== n || e.Oe || e._e))
     ) {
-      if (!a && !e.K) globalQueue.se.push(e);
+      if (!a && !e.B) globalQueue.oe.push(e);
       notifyStatus(e, t, n, a, l);
     }
   });
@@ -1128,8 +1147,8 @@ function enableExternalSource(e) {
     externalSourceConfig = { factory: t, untrack: n };
   }
 }
-GlobalQueue.oe = recompute;
-GlobalQueue.ue = disposeChildren;
+GlobalQueue.ue = recompute;
+GlobalQueue.ce = disposeChildren;
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -1168,7 +1187,7 @@ function releaseSubtree(e) {
     }
     if (t.L) {
       const e = t;
-      e.Te = false;
+      e.Se = false;
       if (e.O & REACTIVE_SNAPSHOT_STALE) {
         e.O &= ~REACTIVE_SNAPSHOT_STALE;
         e.O |= REACTIVE_DIRTY;
@@ -1183,7 +1202,7 @@ function releaseSubtree(e) {
 function clearSnapshots() {
   if (snapshotSources) {
     for (const e of snapshotSources) {
-      delete e.de;
+      delete e.Te;
       delete e[STORE_SNAPSHOT_PROPS];
     }
     snapshotSources = null;
@@ -1191,13 +1210,13 @@ function clearSnapshots() {
   snapshotCaptureActive = false;
 }
 function recompute(e, t = false) {
-  const n = e.W;
+  const n = e.F;
   if (!t) {
-    if (e.K && (!n || activeTransition) && activeTransition !== e.K)
-      globalQueue.initTransition(e.K);
+    if (e.B && (!n || activeTransition) && activeTransition !== e.B)
+      globalQueue.initTransition(e.B);
     deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     e.ye = null;
-    if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
+    if (e.B || n === EFFECT_TRACKED) disposeChildren(e);
     else {
       markDisposal(e);
       e.we = e.Ve;
@@ -1208,15 +1227,15 @@ function recompute(e, t = false) {
     }
   }
   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);
+  const r = e.k !== undefined && e.k !== NOT_PENDING;
+  const s = !!(e.Re & STATUS_PENDING);
+  const o = !!(e.Re & 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;
+  e.de = clock;
+  let c = e.U === NOT_PENDING ? e.te : e.U;
   let a = e.o;
   let l = tracking;
   let f = currentOptimisticLane;
@@ -1226,20 +1245,22 @@ function recompute(e, t = false) {
     if (t) currentOptimisticLane = t;
   }
   try {
-    c = handleAsync(e, e.L(c));
+    const n = e.ye;
+    const i = e.L(c);
+    c = e.ye !== n ? i : handleAsync(e, i);
     clearStatus(e, t);
-    const n = resolveLane(e);
-    if (n) {
-      n.k.delete(e);
-      updatePendingSignal(n.te);
+    const r = resolveLane(e);
+    if (r) {
+      r.H.delete(e);
+      updatePendingSignal(r.ne);
     }
   } catch (t) {
     if (t instanceof NotReadyError && currentOptimisticLane) {
       const t = findLane(currentOptimisticLane);
-      if (t.te !== e) {
-        t.k.add(e);
-        e.q = t;
-        updatePendingSignal(t.te);
+      if (t.ne !== e) {
+        t.H.add(e);
+        e.ee = t;
+        updatePendingSignal(t.ne);
       }
     }
     if (t instanceof NotReadyError) e.Ue = true;
@@ -1248,14 +1269,14 @@ function recompute(e, t = false) {
       t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
       t,
       undefined,
-      t instanceof NotReadyError ? e.q : undefined
+      t instanceof NotReadyError ? e.ee : undefined
     );
   } finally {
     tracking = l;
     e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
     context = u;
   }
-  if (!e.fe) {
+  if (!e.Ee) {
     const u = e.ge;
     let l = u !== null ? u.D : e.C;
     if (l !== null) {
@@ -1265,21 +1286,21 @@ function recompute(e, t = false) {
       if (u !== null) u.D = null;
       else e.C = null;
     }
-    const f = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
+    const f = r ? e.k : e.U === NOT_PENDING ? e.te : e.U;
     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;
+      const o = r ? e.k : undefined;
+      if (t || (n && activeTransition !== e.B) || i) {
+        e.te = c;
         if (r && i) {
-          e.ee = c;
-          e.X = c;
+          e.k = c;
+          e.U = c;
         }
-      } 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.U = c;
+      if (r && !i && s && !e.pe) e.k = c;
+      if (!r || i || e.k !== o) insertSubs(e, i || r);
     } else if (r) {
-      e.X = c;
+      e.U = 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);
@@ -1287,8 +1308,8 @@ function recompute(e, t = false) {
     }
   }
   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));
+  (!t || e.Re & STATUS_PENDING) && !e.B && !(activeTransition && r) && globalQueue.oe.push(e);
+  e.B && n && activeTransition !== e.B && runInTransition(e.B, () => recompute(e));
 }
 function updateIfNecessary(e) {
   if (e.O & REACTIVE_CHECK) {
@@ -1303,25 +1324,25 @@ function updateIfNecessary(e) {
       }
     }
   }
-  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.fe && e.Ee < clock && !e.ye)) {
+  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.Ee && e.de < clock && !e.ye)) {
     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,
+function computed(e, t) {
+  const n = t?.transparent ?? false;
+  const i = {
+    id: t?.id ?? (n ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
+    be: n || undefined,
+    ke: t?.equals != null ? t.equals : isEqual,
+    fe: !!t?.ownedWrite,
+    G: t?.unobserved,
     Ve: null,
-    F: context?.F ?? globalQueue,
+    $: context?.$ ?? globalQueue,
     Le: context?.Le ?? defaultContext,
     me: 0,
     L: e,
-    J: t,
+    te: undefined,
     o: 0,
     A: null,
     S: undefined,
@@ -1329,82 +1350,82 @@ function computed(e, t, n) {
     C: null,
     ge: null,
     I: null,
-    Ae: null,
+    Ne: null,
     i: context,
     De: null,
     Ce: null,
-    O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    Se: STATUS_UNINITIALIZED,
-    Ee: clock,
-    X: NOT_PENDING,
+    O: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+    Re: STATUS_UNINITIALIZED,
+    de: clock,
+    U: NOT_PENDING,
     we: null,
     ve: null,
     ye: null,
-    K: null
+    B: null
   };
-  r.T = r;
-  const s = context?.t ? context.u : context;
+  i.T = i;
+  const r = context?.t ? context.u : context;
   if (context) {
     const e = context.Ce;
     if (e === null) {
-      context.Ce = r;
+      context.Ce = i;
     } else {
-      r.De = e;
-      context.Ce = r;
+      i.De = e;
+      context.Ce = i;
     }
   }
-  if (s) r.o = s.o + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.Te = true;
+  if (r) i.o = r.o + 1;
+  if (snapshotCaptureActive && ownerInSnapshotScope(context)) i.Se = true;
   if (externalSourceConfig) {
-    const e = signal(undefined, { equals: false, pureWrite: true });
-    const t = externalSourceConfig.factory(r.L, () => {
+    const e = signal(undefined, { equals: false, ownedWrite: true });
+    const t = externalSourceConfig.factory(i.L, () => {
       setSignal(e, undefined);
     });
     cleanup(() => t.dispose());
-    r.L = n => {
+    i.L = n => {
       read(e);
       return t.track(n);
     };
   }
-  !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(i, true);
+  if (snapshotCaptureActive && !t?.lazy) {
+    if (!(i.Re & STATUS_PENDING)) {
+      i.Te = i.te === undefined ? NO_SNAPSHOT : i.te;
+      snapshotSources.add(i);
     }
   }
-  return r;
+  return i;
 }
 function signal(e, t, n = null) {
   const i = {
     ke: t?.equals != null ? t.equals : isEqual,
-    le: !!t?.pureWrite,
+    fe: !!t?.ownedWrite,
     He: !!t?.He,
-    Ne: t?.unobserved,
-    J: e,
+    G: t?.unobserved,
+    te: e,
     I: null,
-    Ae: null,
-    Ee: clock,
+    Ne: null,
+    de: clock,
     V: n,
     N: n?.A || null,
-    X: NOT_PENDING
+    U: NOT_PENDING
   };
   n && (n.A = i);
-  if (snapshotCaptureActive && !i.He && !((n?.Se ?? 0) & STATUS_PENDING)) {
-    i.de = e === undefined ? NO_SNAPSHOT : e;
+  if (snapshotCaptureActive && !i.He && !((n?.Re ?? 0) & STATUS_PENDING)) {
+    i.Te = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources.add(i);
   }
   return i;
 }
 function optimisticSignal(e, t) {
   const n = signal(e, t);
-  n.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 +1446,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.te;
     let r;
     try {
       r = read(t);
@@ -1435,11 +1456,11 @@ 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.Re & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.ee) {
+      const e = findLane(t.ee);
       const n = findLane(currentOptimisticLane);
-      if (e !== n && e.k.size > 0) {
+      if (e !== n && e.H.size > 0) {
         return i;
       }
     }
@@ -1449,8 +1470,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.ye || !!(t.Re & STATUS_PENDING))) {
         foundPending = true;
       }
       let n = context;
@@ -1463,86 +1484,104 @@ function read(e) {
       if (t && read(getPendingSignal(t))) foundPending = true;
     }
     pendingCheckActive = n;
-    return e.J;
+    return e.te;
   }
   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.V || e;
+  const n = e;
+  if (typeof n.L === "function") {
+    const t = e;
+    if (refreshing && !(t.O & REACTIVE_DISPOSED)) recompute(t);
+    if (t.O & REACTIVE_LAZY) {
+      t.O &= ~REACTIVE_LAZY;
+      recompute(t, true);
+    } else if (t.O & REACTIVE_DISPOSED) {
+      recompute(t, true);
+    }
+  }
+  const i = 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.O & REACTIVE_ZOMBIE;
+      if (i.o >= (n ? zombieQueue.P : dirtyQueue.P)) {
         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.Re & STATUS_PENDING) {
+    if (t && !(stale && i.B && activeTransition !== i.B)) {
       if (currentOptimisticLane) {
-        const i = n.q;
+        const n = i.ee;
         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.Ee;
         }
       } else {
         if (!tracking && e !== t) link(e, t);
-        throw n.fe;
+        throw i.Ee;
       }
-    } else if (t && n !== e && n.Se & STATUS_UNINITIALIZED) {
+    } else if (t && i !== e && i.Re & STATUS_UNINITIALIZED) {
       if (!tracking && e !== t) link(e, t);
-      throw n.fe;
-    } else if (!t && n.Se & STATUS_UNINITIALIZED) {
-      throw n.fe;
+      throw i.Ee;
+    } else if (!t && i.Re & STATUS_UNINITIALIZED) {
+      throw i.Ee;
     }
   }
-  if (e.L && e.Se & STATUS_ERROR) {
-    if (e.Ee < clock) {
+  if (e.L && e.Re & STATUS_ERROR) {
+    if (e.de < clock) {
       recompute(e);
       return read(e);
-    } else throw e.fe;
+    } else throw e.Ee;
   }
-  if (snapshotCaptureActive && t && t.Te) {
-    const n = e.de;
+  if (snapshotCaptureActive && t && t.Se) {
+    const n = e.Te;
     if (n !== undefined) {
       const i = n === NO_SNAPSHOT ? undefined : n;
-      const r = e.X !== NOT_PENDING ? e.X : e.J;
+      const r = e.U !== NOT_PENDING ? e.U : e.te;
       if (r !== i) t.O |= 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.te;
+    return e.k;
   }
-  return !t ||
+  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.ee || (i === e && stale) || !!(i.Re & STATUS_PENDING))) ||
+    e.U === NOT_PENDING ||
+    (stale && e.B && activeTransition !== e.B)
+      ? e.te
+      : e.U;
+  if (
+    !t &&
+    i === e &&
+    typeof n.L === "function" &&
+    !n.Pe &&
+    !(i.Re & STATUS_PENDING) &&
+    !n.i &&
+    !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.B && activeTransition !== e.B) globalQueue.initTransition(e.B);
+  const n = e.k !== undefined && !projectionWriteActive;
+  const i = e.k !== undefined && e.k !== NOT_PENDING;
+  const r = n ? (i ? e.k : e.te) : e.U === NOT_PENDING ? e.te : e.U;
   if (typeof t === "function") t = t(r);
-  const s = !e.ke || !e.ke(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
+  const s = !e.ke || !e.ke(r, t) || !!(e.Re & STATUS_UNINITIALIZED);
   if (!s) {
     if (n && i && e.L) {
       insertSubs(e, true);
@@ -1551,25 +1590,25 @@ 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.U = e.te;
+      globalQueue.q.push(e);
     }
-    e.he = true;
+    e.pe = true;
     const i = getOrCreateLane(e);
-    e.q = i;
-    e.ee = t;
+    e.ee = i;
+    e.k = t;
   } else {
-    if (e.X === NOT_PENDING) globalQueue.se.push(e);
-    e.X = t;
+    if (e.U === NOT_PENDING) globalQueue.oe.push(e);
+    e.U = t;
   }
   updatePendingSignal(e);
-  if (e.xe) {
-    setSignal(e.xe, t);
+  if (e.Ge) {
+    setSignal(e.Ge, t);
   }
-  e.Ee = clock;
+  e.de = clock;
   insertSubs(e, n);
   schedule();
   return t;
@@ -1587,68 +1626,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.Me) {
+    e.Me = optimisticSignal(false, { ownedWrite: true });
+    if (e.Ie) {
+      e.Me.Ie = e;
     }
-    if (computePendingState(e)) setSignal(e.Fe, true);
+    if (computePendingState(e)) setSignal(e.Me, true);
   }
-  return e.Fe;
+  return e.Me;
 }
 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.U !== NOT_PENDING) {
+    return !n.ye && !(n.Re & 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;
-      return !!(t && t.k.size > 0);
+  if (e.k !== undefined && e.k !== NOT_PENDING) {
+    if (t.Re & STATUS_PENDING && !(t.Re & STATUS_UNINITIALIZED)) return true;
+    if (e.Ie) {
+      const t = e.ee ? findLane(e.ee) : null;
+      return !!(t && t.H.size > 0);
     }
     return true;
   }
-  if (e.ee !== undefined && e.ee === NOT_PENDING && !e._e) {
+  if (e.k !== undefined && e.k === NOT_PENDING && !e.Ie) {
     return false;
   }
-  if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
+  if (e.U !== NOT_PENDING && !(t.Re & STATUS_UNINITIALIZED)) return true;
+  return !!(t.Re & STATUS_PENDING && !(t.Re & STATUS_UNINITIALIZED));
 }
 function updatePendingSignal(e) {
-  if (e.Fe) {
+  if (e.Me) {
     const t = computePendingState(e);
-    const n = e.Fe;
+    const n = e.Me;
     setSignal(n, t);
-    if (!t && n.q) {
+    if (!t && n.ee) {
       const t = resolveLane(e);
-      if (t && t.k.size > 0) {
-        const e = findLane(n.q);
+      if (t && t.H.size > 0) {
+        const e = findLane(n.ee);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
       signalLanes.delete(n);
-      n.q = undefined;
+      n.ee = undefined;
     }
   }
 }
 function getLatestValueComputed(e) {
-  if (!e.xe) {
+  if (!e.Ge) {
     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.Ge = optimisticComputed(() => read(e));
+    e.Ge.Ie = e;
     context = i;
     pendingCheckActive = n;
     latestReadActive = t;
   }
-  return e.xe;
+  return e.Ge;
 }
 function staleValues(e, t = true) {
   const n = stale;
@@ -1727,29 +1766,30 @@ function hasContext(e, t) {
 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,
+function effect(e, t, n, i) {
+  let r = false;
+  const s = !!i?.user;
+  const o = computed(s ? e : t => staleValues(() => e(t)), {
+    ...i,
     equals: () => {
-      o.H = !o.fe;
-      if (s) o.F.enqueue(o.W, runEffect.bind(o));
+      o.j = !o.Ee;
+      if (r) o.$.enqueue(o.F, runEffect.bind(o));
       return false;
     },
     lazy: true
   });
-  o.Qe = i;
-  o.Me = t;
+  o.Qe = undefined;
+  o.Fe = 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;
+  o.F = s ? EFFECT_USER : EFFECT_RENDER;
+  o.xe = (e, t) => {
+    const n = e !== undefined ? e : o.Re;
+    const i = t !== undefined ? t : o.Ee;
     if (n & STATUS_ERROR) {
       let e = i;
-      o.F.notify(o, STATUS_PENDING, 0);
-      if (o.W === EFFECT_USER) {
+      o.$.notify(o, STATUS_PENDING, 0);
+      if (o.F === EFFECT_USER) {
         try {
           return o.je
             ? o.je(e, () => {
@@ -1761,38 +1801,39 @@ function effect(e, t, n, i, r) {
           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);
+      if (!o.$.notify(o, STATUS_ERROR, STATUS_ERROR)) throw e;
+    } else if (o.F === EFFECT_RENDER) {
+      o.$.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;
+  !i?.defer &&
+    (o.F === EFFECT_USER || i?.schedule ? o.$.enqueue(o.F, runEffect.bind(o)) : runEffect.call(o));
+  r = true;
   cleanup(() => o.$e?.());
 }
 function runEffect() {
-  if (!this.H || this.O & REACTIVE_DISPOSED) return;
+  if (!this.j || this.O & REACTIVE_DISPOSED) return;
   this.$e?.();
   this.$e = undefined;
   try {
-    const e = this.Me(this.J, this.Qe);
+    const e = this.Fe(this.te, 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;
+    this.Ee = new StatusError(this, e);
+    this.Re |= STATUS_ERROR;
+    if (!this.$.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.Qe = this.J;
-    this.H = false;
+    this.Qe = this.te;
+    this.j = false;
   }
 }
 function trackedEffect(e, t) {
   const run = () => {
-    if (!n.H || n.O & REACTIVE_DISPOSED) return;
+    if (!n.j || n.O & REACTIVE_DISPOSED) return;
     try {
-      n.H = false;
+      n.j = false;
       recompute(n);
     } finally {
     }
@@ -1804,23 +1845,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.j = true;
+  n.F = EFFECT_TRACKED;
+  n.xe = (e, t) => {
+    const i = e !== undefined ? e : n.Re;
     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.$.notify(n, STATUS_PENDING, 0);
+      const e = t !== undefined ? t : n.Ee;
+      if (!n.$.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
     }
   };
-  n.M = run;
-  n.F.enqueue(EFFECT_USER, run);
+  n.K = run;
+  n.$.enqueue(EFFECT_USER, run);
   cleanup(() => n.$e?.());
 }
 function restoreTransition(e, t) {
@@ -1835,11 +1875,11 @@ function action(e) {
       const r = e(...t);
       globalQueue.initTransition();
       let s = activeTransition;
-      s.$.push(r);
+      s.Z.push(r);
       const done = (e, t) => {
         s = currentTransition(s);
-        const o = s.$.indexOf(r);
-        if (o >= 0) s.$.splice(o, 1);
+        const o = s.Z.indexOf(r);
+        if (o >= 0) s.Z.splice(o, 1);
         setActiveTransition(s);
         schedule();
         t ? i(t) : n(e);
@@ -1875,23 +1915,24 @@ function accessor(e) {
   t.$r = true;
   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.Pe = true;
+    return [accessor(n), setSignal.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) {
+  let n = computed(e, t);
+  return accessor(n);
 }
-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 +1953,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,13 +1973,14 @@ 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.Pe = true;
+    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();
@@ -2086,7 +2127,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 +2149,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);
-    });
-  });
+    if (!i) i = getOwner();
+    runProjectionComputed(s, e, n?.key || "id");
+  }, undefined);
   i.Pe = true;
   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.ye === 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) {
@@ -2239,17 +2287,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.Te = e === undefined ? NO_SNAPSHOT : e;
     snapshotSources?.add(u);
   }
   return (e[t] = u);
@@ -2282,8 +2330,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?.B) {
+      globalQueue.initTransition(t.B);
     }
   }
   const i = e[STORE_VALUE];
@@ -2291,7 +2339,7 @@ function prepareStoreWrite(e, t, n) {
   if (
     snapshotCaptureActive &&
     typeof n !== "symbol" &&
-    !((e[STORE_FIREWALL]?.Se ?? 0) & STATUS_PENDING)
+    !((e[STORE_FIREWALL]?.Re ?? 0) & STATUS_PENDING)
   ) {
     if (!e[STORE_SNAPSHOT_PROPS]) {
       e[STORE_SNAPSHOT_PROPS] = Object.create(null);
@@ -2306,20 +2354,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 c = e[STORE_HAS]?.[t];
+  if (c) {
+    setSignal(c, u);
+  } else if (!o && n !== "invalidate" && s !== u) {
+    const n = upsertStoreNode(e, getNodes(e, STORE_HAS), t, s);
+    setSignal(n, u);
+  }
+  const a = getNodes(e, STORE_NODE);
   if (n === "set") {
-    r[t] && setSignal(r[t], () => (isWrappable(i) ? wrap(i, e) : i));
+    if (a[t]) {
+      setSignal(a[t], () => (isWrappable(i) ? wrap(i, e) : i));
+    } else if (!o) {
+      const n = upsertStoreNode(e, a, 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 (a[t]) {
+      setSignal(a[t], {});
+      delete a[t];
     }
   } else {
-    r[t] && setSignal(r[t], undefined);
+    if (a[t]) {
+      setSignal(a[t], undefined);
+    } else if (!o) {
+      const n = upsertStoreNode(e, a, t, r, e[STORE_SNAPSHOT_PROPS]);
+      setSignal(n, undefined);
+    }
   }
-  r[$TRACK] && setSignal(r[$TRACK], undefined);
+  a[$TRACK] && setSignal(a[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2348,11 +2421,11 @@ const storeTraps = {
     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.k !== undefined && r.k !== NOT_PENDING
+            ? r.k
+            : r.U !== NOT_PENDING
+              ? r.U
+              : r.te
           : c[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
@@ -2394,11 +2467,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 +2486,39 @@ const storeTraps = {
             : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
               ? e[STORE_OVERRIDE][t]
               : r;
-        const c = n?.[$TARGET]?.[STORE_VALUE] ?? n;
-        const a = Array.isArray(o) && t !== "length";
-        const l = a ? parseInt(t) + 1 : 0;
-        const f =
-          a &&
+        const c =
+          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 a = n?.[$TARGET]?.[STORE_VALUE] ?? n;
+        const l = Array.isArray(o) && t !== "length";
+        const f = l ? parseInt(t) + 1 : 0;
+        const E =
+          l &&
           (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 d = l && f > E ? f : undefined;
+        if (u === a && d === undefined) return true;
+        if (a !== undefined && a === r && d === undefined) delete e[s]?.[t];
         else {
           const n = e[s] || (e[s] = Object.create(null));
-          n[t] = c;
-          if (E !== undefined) n.length = E;
+          n[t] = a;
+          if (d !== undefined) n.length = d;
         }
-        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", a, u, c);
+        if (Array.isArray(o) && t !== "length" && d !== undefined) {
+          const t = getNodes(e, STORE_NODE);
+          if (t.length) {
+            setSignal(t.length, d);
+          } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
+            const n = upsertStoreNode(e, t, "length", E, e[STORE_SNAPSHOT_PROPS]);
+            setSignal(n, d);
+          }
         }
         if (false);
       });
@@ -2474,7 +2557,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;
@@ -2544,9 +2627,9 @@ function createStore(e, t, n) {
   return [r, e => storeSetter(r, e)];
 }
 function createOptimisticStore(e, t, n) {
-  GlobalQueue.ce ||= clearOptimisticStore;
+  GlobalQueue.ae ||= 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 +2644,7 @@ function clearOptimisticStore(e) {
     if (i) {
       for (const e of Reflect.ownKeys(n)) {
         if (i[e]) {
-          i[e].q = undefined;
+          i[e].ee = 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 +2652,7 @@ function clearOptimisticStore(e) {
         }
       }
       if (i[$TRACK]) {
-        i[$TRACK].q = undefined;
+        i[$TRACK].ee = undefined;
         setSignal(i[$TRACK], undefined);
       }
     }
@@ -2578,7 +2661,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,33 +2684,22 @@ 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);
       }
-    });
+    }, undefined);
     i.Pe = true;
   }
   return { store: s, node: i };
@@ -2888,7 +2960,7 @@ function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   const r = t.length > 1;
   const s = t;
-  return createMemo(
+  const o = computed(
     updateKeyedMap.bind({
       Ye: createOwner(),
       Ze: 0,
@@ -2903,8 +2975,10 @@ function mapArray(e, t, n) {
       it: n?.fallback
     })
   );
+  o.Pe = true;
+  return accessor(o);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const e = this.Be() || [],
     t = e.length;
@@ -3026,17 +3100,21 @@ function updateKeyedMap() {
 }
 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({
+      Ye: createOwner(),
+      Ze: 0,
+      rt: 0,
+      st: e,
+      Xe: i,
+      Je: [],
+      ze: [],
+      ot: n?.from,
+      it: n?.fallback
+    })
+  );
+  r.Pe = true;
+  return accessor(r);
 }
 function updateRepeat() {
   const e = this.st();
@@ -3089,12 +3167,12 @@ 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.Re;
+    const r = t !== undefined ? t : n.Ee;
+    n.Re &= ~n.ut;
+    n.$.notify(n, n.ut, i, r);
   };
   n.ut = t;
   n.Pe = true;
@@ -3102,9 +3180,9 @@ function boundaryComputed(e, t) {
   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.$;
+  r.addChild((e.$ = n));
+  cleanup(() => r.removeChild(e.$));
   return runWithOwner(e, () => {
     const e = computed(t);
     return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
@@ -3114,12 +3192,16 @@ 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;
 }
+function isSlotMinimallyReady(e) {
+  return isRevealController(e) ? e.isMinimallyReady() : isSlotReady(e);
+}
 function setSlotState(e, t, n, i) {
   setSignal(e.ft, n);
   setSignal(e.Et, i);
@@ -3134,15 +3216,16 @@ class RevealController {
   Ot;
   _t = [];
   dt;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
+  ft = signal(false, { ownedWrite: true, He: true });
+  Et = signal(false, { ownedWrite: true, He: true });
   It = true;
-  ht = false;
+  ht = true;
+  At = false;
   constructor(e, t) {
     this.Rt = e;
     this.Ot = t;
   }
-  At(e) {
+  Nt(e) {
     for (let t = 0; t < this._t.length; t++) {
       const n = this._t[t];
       if ((isRevealController(n) ? n.dt : n.Tt) !== this) continue;
@@ -3151,13 +3234,35 @@ class RevealController {
     return true;
   }
   isReady() {
-    return this.At(isSlotReady);
+    return this.Nt(isSlotReady);
+  }
+  isMinimallyReady() {
+    const e = untrack(this.Rt);
+    if (e === "together") return this.isReady();
+    if (e === "natural") {
+      let e = false;
+      let t = false;
+      this.Nt(n => {
+        e = true;
+        if (isSlotMinimallyReady(n)) {
+          t = true;
+          return false;
+        }
+      });
+      return !e || t;
+    }
+    let t = true;
+    this.Nt(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));
+    const t = untrack(this.Rt);
+    (setSignal(e.ft, true), setSignal(e.Et, t === "sequential" ? !!untrack(this.Ot) : false));
     untrack(() => this.evaluate());
   }
   unregister(e) {
@@ -3166,103 +3271,123 @@ class RevealController {
     untrack(() => this.evaluate());
   }
   evaluate(e, t) {
-    if (this.ht) return;
-    this.ht = true;
+    if (this.At) return;
+    this.At = true;
     const n = this.It;
+    const i = this.ht;
     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));
+        i = untrack(this.Rt),
+        r = i === "sequential" && !!untrack(this.Ot),
+        s = t ?? r;
+      if (n) {
+        this.Nt(e => setSlotState(e, this, true, s));
+      } else if (i === "natural") {
+        this.Nt(e => {
+          if (isRevealController(e)) {
+            setSignal(e.Et, false);
+            setSignal(e.ft, false);
+            e.evaluate(false, false);
+          } else {
+            setSlotState(e, this, !isSlotReady(e), false);
+          }
+        });
+      } else if (i === "together") {
+        const e = this.Nt(isSlotMinimallyReady);
+        this.Nt(t => setSlotState(t, this, !e, false));
       } else {
         let e = false;
-        this.At(t => {
-          if (e) return setSlotState(t, this, true, i);
+        this.Nt(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.Et, false);
+            setSignal(t.ft, false);
+            t.evaluate(false, false);
+          } else {
+            setSlotState(t, this, true, false);
+          }
         });
       }
     } finally {
       this.It = this.isReady();
-      this.ht = false;
+      this.ht = this.isMinimallyReady();
+      this.At = false;
     }
-    if (this.dt && n !== this.It) this.dt.evaluate();
+    if (this.dt && (n !== this.It || i !== this.ht)) this.dt.evaluate();
   }
 }
 class CollectionQueue extends Queue {
-  Nt;
-  ct = new Set();
   Pt;
+  ct = new Set();
+  gt;
   lt = true;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
+  ft = signal(false, { ownedWrite: true, He: true });
+  Et = signal(false, { ownedWrite: true, He: true });
   Tt;
   St = false;
-  gt;
-  Ct = ON_INIT;
+  Ct;
+  Dt = ON_INIT;
   constructor(e) {
     super();
-    this.Nt = e;
+    this.Pt = e;
   }
   run(e) {
     if (!e || (read(this.ft) && (!_revealUsed || read(this.Et)))) 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.St && this.Ct) {
       const e = untrack(() => {
         try {
-          return this.gt();
+          return this.Ct();
         } catch {
           return ON_INIT;
         }
       });
-      if (e !== this.Ct) {
-        this.Ct = e;
+      if (e !== this.Dt) {
+        this.Dt = e;
         this.St = 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.St) 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) {
+    if (n & this.Pt) {
       this.lt = true;
-      const t = i?.source || e.fe?.source;
+      const t = i?.source || e.Ee?.source;
       if (t) {
         const e = this.ct.size === 0;
         this.ct.add(t);
         if (e) setSignal(this.ft, 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.Re & this.Pt) && !(this.Pt & STATUS_ERROR && e.Re & 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.lt && !this.St && this.gt) {
+        this.lt = !!(this.gt.Re & this.Pt);
       } else {
         this.lt = false;
       }
       if (!this.lt) {
         setSignal(this.ft, false);
-        if (this.gt) {
+        if (this.Ct) {
           try {
-            this.Ct = untrack(() => this.gt());
+            this.Dt = untrack(() => this.Ct());
           } catch {}
         }
       }
@@ -3274,8 +3399,8 @@ 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.Ct = i;
+  const o = (s.gt = createBoundChildren(r, t, s, e));
   untrack(() => {
     let t = false;
     try {
@@ -3284,7 +3409,7 @@ 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.lt = t || !!(o.Re & e) || o.Ee instanceof NotReadyError;
   });
   const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
   if (u) {
@@ -3295,7 +3420,7 @@ function createCollectionBoundary(e, t, n, i) {
   const c = computed(() => {
     if (!read(s.ft)) {
       const e = read(o);
-      if (!untrack(() => read(s.ft))) return (s.St = true), e;
+      if (!untrack(() => read(s.ft))) return ((s.St = true), e);
     }
     if (_revealUsed && read(s.Et)) return undefined;
     return n(s);
@@ -3308,7 +3433,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.Ee?.cause ?? n.Ee;
     return t(i, () => {
       for (const t of e.ct) recompute(t);
       schedule();
@@ -3319,7 +3444,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);