@solidjs/signals 0.7.0 → 0.7.2

package/dist/prod.js

@@ -45,7 +45,7 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.B)
+  if (!globalQueue.C)
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
@@ -59,14 +59,14 @@ function notifyUnobserved() {
 var pureQueue = [];
 var Queue = class {
   k = null;
-  B = false;
-  g = [[], []];
-  f = [];
+  C = false;
+  f = [[], []];
+  g = [];
   created = clock;
   enqueue(type, fn) {
     pureQueue.push(fn);
     if (type)
-      this.g[type - 1].push(fn);
+      this.f[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -74,19 +74,19 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.g[type - 1].length) {
-      const effects = this.g[type - 1];
-      this.g[type - 1] = [];
+    } else if (this.f[type - 1].length) {
+      const effects = this.f[type - 1];
+      this.f[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.f.length; i++) {
-      this.f[i].run(type);
+    for (let i = 0; i < this.g.length; i++) {
+      this.g[i].run(type);
     }
   }
   flush() {
-    if (this.B)
+    if (this.C)
       return;
-    this.B = true;
+    this.C = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -94,22 +94,22 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.B = false;
+      this.C = false;
       Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
-    if (ActiveTransition && ActiveTransition.G.has(this))
-      return ActiveTransition.G.get(this).addChild(child);
-    this.f.push(child);
+    if (ActiveTransition && ActiveTransition.J.has(this))
+      return ActiveTransition.J.get(this).addChild(child);
+    this.g.push(child);
     child.k = this;
   }
   removeChild(child) {
-    if (ActiveTransition && ActiveTransition.G.has(this))
-      return ActiveTransition.G.get(this).removeChild(child);
-    const index = this.f.indexOf(child);
+    if (ActiveTransition && ActiveTransition.J.has(this))
+      return ActiveTransition.J.get(this).removeChild(child);
+    const index = this.g.indexOf(child);
     if (index >= 0) {
-      this.f.splice(index, 1);
+      this.g.splice(index, 1);
       child.k = null;
     }
   }
@@ -119,14 +119,14 @@ var Queue = class {
     return false;
   }
   merge(queue) {
-    this.g[0].push.apply(this.g[0], queue.g[0]);
-    this.g[1].push.apply(this.g[1], queue.g[1]);
-    for (let i = 0; i < queue.f.length; i++) {
-      const og = this.f.find((c) => c.d === queue.f[i].d);
+    this.f[0].push.apply(this.f[0], queue.f[0]);
+    this.f[1].push.apply(this.f[1], queue.f[1]);
+    for (let i = 0; i < queue.g.length; i++) {
+      const og = this.g.find((c) => c.d === queue.g[i].d);
       if (og)
-        og.merge(queue.f[i]);
+        og.merge(queue.g[i]);
       else
-        this.addChild(queue.f[i]);
+        this.addChild(queue.g[i]);
     }
   }
 };
@@ -157,49 +157,49 @@ function runQueue(queue, type) {
 }
 var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
-  s = /* @__PURE__ */ new Set();
-  H = /* @__PURE__ */ new Set();
-  I = /* @__PURE__ */ new Set();
+  t = /* @__PURE__ */ new Set();
+  K = /* @__PURE__ */ new Set();
+  r = /* @__PURE__ */ new Set();
   D = false;
-  g = [[], []];
-  G = /* @__PURE__ */ new Map();
-  J = [];
-  f = [];
+  f = [[], []];
+  J = /* @__PURE__ */ new Map();
+  G = [];
+  g = [];
   k = null;
-  B = false;
+  C = false;
   Y = false;
   d = globalQueue;
   created = clock;
   constructor() {
-    this.G.set(globalQueue, this);
-    for (const child of globalQueue.f) {
+    this.J.set(globalQueue, this);
+    for (const child of globalQueue.g) {
       cloneQueue(child, this, this);
     }
   }
   enqueue(type, fn) {
-    this.J.push(fn);
+    this.G.push(fn);
     if (type)
-      this.g[type - 1].push(fn);
+      this.f[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
     if (type === EFFECT_PURE) {
-      this.J.length && runQueue(this.J, type);
-      this.J = [];
+      this.G.length && runQueue(this.G, type);
+      this.G = [];
       return;
-    } else if (this.g[type - 1].length) {
-      const effects = this.g[type - 1];
-      this.g[type - 1] = [];
+    } else if (this.f[type - 1].length) {
+      const effects = this.f[type - 1];
+      this.f[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.f.length; i++) {
-      this.f[i].run(type);
+    for (let i = 0; i < this.g.length; i++) {
+      this.g[i].run(type);
     }
   }
   flush() {
-    if (this.B)
+    if (this.C || this.D)
       return;
-    this.B = true;
+    this.C = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
     try {
@@ -209,46 +209,49 @@ var Transition = class _Transition {
       ActiveTransition = currentTransition;
       finishTransition(this);
     } finally {
-      this.B = false;
+      this.C = false;
       ActiveTransition = currentTransition;
     }
   }
   addChild(child) {
-    this.f.push(child);
+    this.g.push(child);
     child.k = this;
   }
   removeChild(child) {
-    const index = this.f.indexOf(child);
+    const index = this.g.indexOf(child);
     if (index >= 0)
-      this.f.splice(index, 1);
+      this.g.splice(index, 1);
   }
   notify(node, type, flags) {
     if (!(type & LOADING_BIT))
       return false;
     if (flags & LOADING_BIT) {
-      this.s.add(node);
+      this.t.add(node);
     } else {
-      this.s.delete(node);
+      this.t.delete(node);
     }
     return true;
   }
   merge(queue) {
-    this.g[0].push.apply(this.g[0], queue.g[0]);
-    this.g[1].push.apply(this.g[1], queue.g[1]);
-    this.J.push.apply(this.J, queue.J);
-    for (let i = 0; i < queue.f.length; i++) {
-      const og = this.f.find((c) => c.d === queue.f[i].d);
+    this.f[0].push.apply(this.f[0], queue.f[0]);
+    this.f[1].push.apply(this.f[1], queue.f[1]);
+    this.G.push.apply(this.G, queue.G);
+    queue.f[0].length = 0;
+    queue.f[1].length = 0;
+    queue.G.length = 0;
+    for (let i = 0; i < queue.g.length; i++) {
+      const og = this.g.find((c) => c.d === queue.g[i].d);
       if (og)
-        og.merge(queue.f[i]);
+        og.merge(queue.g[i]);
       else
-        this.addChild(queue.f[i]);
+        this.addChild(queue.g[i]);
     }
   }
   schedule() {
     if (this.Y)
       return;
     this.Y = true;
-    if (!this.B)
+    if (!this.C)
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
@@ -268,13 +271,14 @@ var Transition = class _Transition {
         (async function() {
           let temp, value;
           while (!(temp = result.next(value)).done) {
+            transition2 = ActiveTransition;
             if (temp.value instanceof Promise) {
-              transition2.H.add(temp.value);
+              transition2.K.add(temp.value);
               try {
                 value = await temp.value;
               } finally {
                 transition2 = latestTransition(transition2);
-                transition2.H.delete(temp.value);
+                transition2.K.delete(temp.value);
               }
               ActiveTransition = transition2;
             } else
@@ -285,10 +289,10 @@ var Transition = class _Transition {
         })();
       }
       if (result instanceof Promise) {
-        transition2.H.add(result);
+        transition2.K.add(result);
         result.finally(() => {
           transition2 = latestTransition(transition2);
-          transition2.H.delete(result);
+          transition2.K.delete(result);
           ActiveTransition = null;
           finishTransition(transition2);
         });
@@ -306,14 +310,16 @@ var Transition = class _Transition {
       return;
     }
     fn.j = this;
-    this.I.add(fn);
+    this.r.add(fn);
   }
 };
 function transition(fn) {
   let t = new Transition();
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
-function cloneGraph(node, optimistic) {
+function cloneGraph(node) {
+  if (node.r)
+    return node;
   if (node.j) {
     if (node.j !== ActiveTransition) {
       mergeTransitions(node.j, ActiveTransition);
@@ -327,20 +333,19 @@ function cloneGraph(node, optimistic) {
     m: null,
     c: null,
     a: node.a ? [...node.a] : null,
-    d: node,
-    I: !!optimistic
+    d: node
   });
   delete clone.T;
   ActiveTransition.a.set(node, clone);
   node.j = ActiveTransition;
-  if (!optimistic && node.a) {
+  if (node.a) {
     for (let i = 0; i < node.a.length; i++)
       node.a[i].c.push(clone);
   }
   if (node.c) {
     clone.c = [];
     for (let i = 0, length = node.c.length; i < length; i++) {
-      !node.c[i].d && clone.c.push(cloneGraph(node.c[i], optimistic));
+      !node.c[i].d && clone.c.push(cloneGraph(node.c[i]));
     }
   }
   return clone;
@@ -368,14 +373,14 @@ function cloneQueue(queue, parent, transition2) {
   Object.assign(clone, queue, {
     d: queue,
     k: parent,
-    f: [],
+    g: [],
     enqueue(type, fn) {
       transition2 = latestTransition(transition2);
       transition2.enqueue(type, fn);
     },
     notify(node, type, flags) {
       node = node.d || node;
-      if (!clone.K || type & LOADING_BIT) {
+      if (!clone.L || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
         transition2 = latestTransition(transition2);
         transition2.notify(node, LOADING_BIT, flags);
@@ -385,9 +390,9 @@ function cloneQueue(queue, parent, transition2) {
       return queue.notify.call(this, node, type, flags);
     }
   });
-  parent.f.push(clone);
-  transition2.G.set(queue, clone);
-  for (const child of queue.f) {
+  parent.g.push(clone);
+  transition2.J.set(queue, clone);
+  for (const child of queue.g) {
     cloneQueue(child, clone, transition2);
   }
 }
@@ -395,11 +400,11 @@ function resolveQueues(children) {
   for (const child of children) {
     const og = child.d;
     if (og) {
-      const clonedChildren = child.f;
+      const clonedChildren = child.g;
       delete child.enqueue;
       delete child.notify;
       delete child.k;
-      delete child.f;
+      delete child.g;
       Object.assign(og, child);
       delete og.d;
       resolveQueues(clonedChildren);
@@ -413,12 +418,12 @@ function mergeTransitions(t1, t2) {
     key.j = t1;
     t1.a.set(key, value);
   });
-  t2.I.forEach((c) => {
+  t2.r.forEach((c) => {
     c.j = t1;
-    t1.I.add(c);
+    t1.r.add(c);
   });
-  t2.H.forEach((p) => t1.H.add(p));
-  t2.s.forEach((n) => t1.s.add(n));
+  t2.K.forEach((p) => t1.K.add(p));
+  t2.t.forEach((n) => t1.t.add(n));
   t1.merge(t2);
   t2.D = t1;
 }
@@ -427,7 +432,7 @@ function getTransitionSource(input) {
 }
 function getQueue(node) {
   const transition2 = ActiveTransition || node.d?.j;
-  return transition2 && transition2.G.get(node.C) || node.C;
+  return transition2 && transition2.J.get(node.E) || node.E;
 }
 function initialDispose(node) {
   let current = node.m;
@@ -440,11 +445,11 @@ function initialDispose(node) {
   }
 }
 function finishTransition(transition2) {
-  if (transition2.D || transition2.Y || transition2.H.size || transition2.s.size)
+  if (transition2.D || transition2.Y || transition2.K.size || transition2.t.size)
     return;
-  globalQueue.g[0].push.apply(globalQueue.g[0], transition2.g[0]);
-  globalQueue.g[1].push.apply(globalQueue.g[1], transition2.g[1]);
-  resolveQueues(transition2.f);
+  globalQueue.f[0].push.apply(globalQueue.f[0], transition2.f[0]);
+  globalQueue.f[1].push.apply(globalQueue.f[1], transition2.f[1]);
+  resolveQueues(transition2.g);
   for (const [source, clone] of transition2.a) {
     if (source === clone || source.j !== transition2) {
       delete source.j;
@@ -452,12 +457,6 @@ function finishTransition(transition2) {
     }
     if (clone.a)
       replaceSourceObservers(clone, transition2);
-    if (clone.I) {
-      clone.dispose();
-      clone.emptyDisposal();
-      delete source.j;
-      continue;
-    }
     if (clone.Z || clone.b === STATE_DISPOSED) {
       source.dispose(clone.b === STATE_DISPOSED);
       source.emptyDisposal();
@@ -469,8 +468,8 @@ function finishTransition(transition2) {
     Object.assign(source, clone);
     delete source.d;
     let current = clone.m;
-    if (current?.y === clone)
-      current.y = source;
+    if (current?.z === clone)
+      current.z = source;
     while (current?.k === clone) {
       current.k = source;
       current = current.m;
@@ -478,7 +477,7 @@ function finishTransition(transition2) {
     delete source.j;
   }
   transition2.D = true;
-  for (const reset of transition2.I) {
+  for (const reset of transition2.r) {
     delete reset.j;
     reset();
   }
@@ -502,11 +501,11 @@ var Owner = class {
   // See comment at the top of the file for an example of the _nextSibling traversal
   k = null;
   m = null;
-  y = null;
+  z = null;
   b = STATE_CLEAN;
   n = null;
-  z = defaultContext;
-  C = globalQueue;
+  A = defaultContext;
+  E = globalQueue;
   fa = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
@@ -517,23 +516,23 @@ var Owner = class {
   }
   append(child) {
     child.k = this;
-    child.y = this;
+    child.z = this;
     if (this.m)
-      this.m.y = child;
+      this.m.z = child;
     child.m = this.m;
     this.m = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
-    if (child.z !== this.z) {
-      child.z = { ...this.z, ...child.z };
+    if (child.A !== this.A) {
+      child.A = { ...this.A, ...child.A };
     }
-    if (this.C)
-      child.C = this.C;
+    if (this.E)
+      child.E = this.E;
   }
   dispose(self = true) {
     if (this.b === STATE_DISPOSED)
       return;
-    let head = self ? this.y || this.k : this, current = this.m, next = null;
+    let head = self ? this.z || this.k : this, current = this.m, next = null;
     while (current && current.k === this) {
       current.dispose(true);
       next = current.m;
@@ -542,18 +541,18 @@ var Owner = class {
     }
     this.fa = 0;
     if (self)
-      this.L();
+      this.M();
     if (current)
-      current.y = !self ? this : this.y;
+      current.z = !self ? this : this.z;
     if (head)
       head.m = current;
   }
-  L() {
-    if (this.y)
-      this.y.m = null;
+  M() {
+    if (this.z)
+      this.z.m = null;
     this.k = null;
-    this.y = null;
-    this.z = defaultContext;
+    this.z = null;
+    this.A = defaultContext;
     this.b = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -583,7 +582,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.z[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.A[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -593,13 +592,13 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.z = {
-    ...owner.z,
+  owner.A = {
+    ...owner.A,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.z[context.id]);
+  return !isUndefined(owner?.A[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
@@ -649,19 +648,19 @@ var Computation = class extends Owner {
   ea;
   ha = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  i = 0;
+  h = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   ba = DEFAULT_FLAGS;
   Q = -1;
-  E = false;
+  H = false;
   j;
   d;
-  I = false;
+  r = false;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this.P = compute2;
     this.b = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.i = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.l = initialValue;
     if (options?.equals !== void 0)
       this.aa = options.equals;
@@ -674,8 +673,8 @@ var Computation = class extends Owner {
   }
   ga() {
     track(this);
-    newFlags |= this.i & ~currentMask;
-    if (this.i & ERROR_BIT) {
+    newFlags |= this.h & ~currentMask;
+    if (this.h & ERROR_BIT) {
       throw this.O;
     } else {
       return this.l;
@@ -686,16 +685,16 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.i & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
     if (this.P) {
-      if (this.i & ERROR_BIT && this.Q <= clock)
+      if (this.h & ERROR_BIT && this.Q <= clock)
         update(this);
       else
-        this.M();
+        this.F();
     }
     return this.ga();
   }
@@ -707,22 +706,22 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.i & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
     if (this.P) {
-      if (this.i & ERROR_BIT && this.Q <= clock)
+      if (this.h & ERROR_BIT && this.Q <= clock)
         update(this);
       else
-        this.M();
+        this.F();
     }
-    if ((notStale || this.i & UNINITIALIZED_BIT) && this.i & LOADING_BIT) {
+    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
       track(this);
       throw new NotReadyError();
     }
-    if (staleCheck && this.i & LOADING_BIT) {
+    if (staleCheck && this.h & LOADING_BIT) {
       staleCheck.l = true;
     }
     return this.ga();
@@ -735,19 +734,19 @@ var Computation = class extends Owner {
         return clone.write(value, flags, raw);
     }
     const newValue = !raw && typeof value === "function" ? value(this.l) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.i & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    const valueChanged = newValue !== UNCHANGED && (!!(this.h & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
     this.aa === false || !this.aa(this.l, newValue));
     if (valueChanged) {
       this.l = newValue;
       this.O = void 0;
     }
-    const changedFlagsMask = this.i ^ flags, changedFlags = changedFlagsMask & flags;
-    this.i = flags;
+    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
+    this.h = flags;
     this.Q = clock + 1;
-    if (this.c) {
+    if (this.c && !(this.r && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
-          this.c[i].t(STATE_DIRTY);
+          this.c[i].u(STATE_DIRTY);
         } else if (changedFlagsMask) {
           this.c[i]._(changedFlagsMask, changedFlags);
         }
@@ -758,14 +757,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  t(state, skipQueue) {
-    if (this.b >= state && !this.E)
+  u(state, skipQueue) {
+    if (this.b >= state && !this.H)
       return;
-    this.E = !!skipQueue;
+    this.H = !!skipQueue;
     this.b = state;
-    if (this.c) {
+    if (this.c && !(this.r && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
-        this.c[i].t(STATE_CHECK, skipQueue);
+        this.c[i].u(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -778,18 +777,18 @@ var Computation = class extends Owner {
   _(mask, newFlags2) {
     if (this.b >= STATE_DIRTY)
       return;
-    if (mask & this.ba) {
-      this.t(STATE_DIRTY);
+    if (mask & this.ba || this.r && ActiveTransition) {
+      this.u(STATE_DIRTY);
       return;
     }
-    if (this.b >= STATE_CHECK && !this.E)
+    if (this.b >= STATE_CHECK && !this.H)
       return;
-    const prevFlags = this.i & mask;
+    const prevFlags = this.h & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.t(STATE_CHECK);
+      this.u(STATE_CHECK);
     } else {
-      this.i ^= deltaFlags;
+      this.h ^= deltaFlags;
       if (this.c) {
         for (let i = 0; i < this.c.length; i++) {
           this.c[i]._(mask, newFlags2);
@@ -804,7 +803,7 @@ var Computation = class extends Owner {
         return clone.N(error);
     }
     this.O = error;
-    this.write(UNCHANGED, this.i & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -813,7 +812,7 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  M() {
+  F() {
     if (!this.P) {
       return;
     }
@@ -827,8 +826,8 @@ var Computation = class extends Owner {
     if (this.b === STATE_CHECK) {
       for (let i = 0; i < this.a.length; i++) {
         const source = getTransitionSource(this.a[i]);
-        source.M();
-        observerFlags |= source.i & ~UNINITIALIZED_BIT;
+        source.F();
+        observerFlags |= source.h & ~UNINITIALIZED_BIT;
         if (this.b === STATE_DIRTY) {
           break;
         }
@@ -844,12 +843,12 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  L() {
+  M() {
     if (this.b === STATE_DISPOSED)
       return;
     if (this.a)
       removeSourceObservers(this, 0);
-    super.L();
+    super.M();
   }
 };
 function track(computation) {
@@ -884,7 +883,7 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.i & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
     } else {
       node.N(error);
     }
@@ -995,29 +994,29 @@ function compute(owner, fn, observer) {
 var Effect = class extends Computation {
   ca;
   $;
-  u;
+  w;
   da = false;
   T;
-  r;
+  s;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.ca = effect;
     this.$ = error;
     this.T = initialValue;
-    this.r = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.r === EFFECT_RENDER) {
+    this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.s === EFFECT_RENDER) {
       this.P = function(p) {
-        return !this.d && clock > this.C.created && !(this.i & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+        return !this.d && clock > this.E.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
-    this.M();
-    !options?.defer && (this.r === EFFECT_USER ? getQueue(this).enqueue(this.r, this.w.bind(this)) : this.w(this.r));
+    this.F();
+    !options?.defer && (this.s === EFFECT_USER ? getQueue(this).enqueue(this.s, this.x.bind(this)) : this.x(this.s));
   }
   write(value, flags = 0) {
     if (this.b == STATE_DIRTY) {
-      this.i = flags;
-      if (this.r === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.i);
+      this.h = flags;
+      if (this.s === EFFECT_RENDER) {
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
       }
     }
     if (value === UNCHANGED)
@@ -1027,11 +1026,11 @@ var Effect = class extends Computation {
     this.O = void 0;
     return value;
   }
-  t(state, skipQueue) {
+  u(state, skipQueue) {
     if (this.b >= state || skipQueue)
       return;
     if (this.b === STATE_CLEAN || this.d && !ActiveTransition)
-      getQueue(this).enqueue(this.r, this.w.bind(this));
+      getQueue(this).enqueue(this.s, this.x.bind(this));
     this.b = state;
   }
   _(mask, newFlags2) {
@@ -1039,7 +1038,7 @@ var Effect = class extends Computation {
       if (this.b >= STATE_DIRTY)
         return;
       if (mask & 3) {
-        this.t(STATE_DIRTY);
+        this.u(STATE_DIRTY);
         return;
       }
     }
@@ -1048,12 +1047,12 @@ var Effect = class extends Computation {
   N(error) {
     this.O = error;
     getQueue(this).notify(this, LOADING_BIT, 0);
-    this.i = ERROR_BIT;
-    if (this.r === EFFECT_USER) {
+    this.h = ERROR_BIT;
+    if (this.s === EFFECT_USER) {
       try {
         return this.$ ? this.$(error, () => {
-          this.u?.();
-          this.u = void 0;
+          this.w?.();
+          this.w = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
@@ -1062,24 +1061,24 @@ var Effect = class extends Computation {
     if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  L() {
+  M() {
     if (this.b === STATE_DISPOSED)
       return;
     this.ca = void 0;
     this.T = void 0;
     this.$ = void 0;
-    this.u?.();
-    this.u = void 0;
+    this.w?.();
+    this.w = void 0;
     getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.L();
+    super.M();
   }
-  w(type) {
+  x(type) {
     if (type) {
       const effect = this.d || this;
       if (effect.da && effect.b !== STATE_DISPOSED) {
-        effect.u?.();
+        effect.w?.();
         try {
-          effect.u = effect.ca(effect.l, effect.T);
+          effect.w = effect.ca(effect.l, effect.T);
         } catch (e) {
           if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
@@ -1093,32 +1092,32 @@ var Effect = class extends Computation {
   }
 };
 var TrackedEffect = class extends Computation {
-  r = EFFECT_USER;
-  u;
+  s = EFFECT_USER;
+  w;
   constructor(compute2, options) {
     super(void 0, () => {
-      this.u?.();
-      this.u = latest(compute2);
+      this.w?.();
+      this.w = latest(compute2);
       return void 0;
     }, options);
-    getQueue(this).enqueue(this.r, this.w.bind(this));
+    getQueue(this).enqueue(this.s, this.x.bind(this));
   }
-  t(state, skipQueue) {
+  u(state, skipQueue) {
     if (this.b >= state || skipQueue)
       return;
     if (this.b === STATE_CLEAN || this.d && !ActiveTransition)
-      getQueue(this).enqueue(this.r, this.w.bind(this));
+      getQueue(this).enqueue(this.s, this.x.bind(this));
     this.b = state;
   }
-  L() {
+  M() {
     if (this.b === STATE_DISPOSED)
       return;
-    this.u?.();
-    this.u = void 0;
+    this.w?.();
+    this.w = void 0;
     getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.L();
+    super.M();
   }
-  w(type) {
+  x(type) {
     if (type)
       this.b !== STATE_CLEAN && runTop(this);
   }
@@ -1126,16 +1125,16 @@ var TrackedEffect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.M();
+    !options?.defer && this.F();
   }
-  t(state, skipQueue) {
-    if (this.b >= state && !this.E)
+  u(state, skipQueue) {
+    if (this.b >= state && !this.H)
       return;
-    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.E))
-      getQueue(this).enqueue(EFFECT_PURE, this.w.bind(this));
-    super.t(state, skipQueue);
+    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.H))
+      getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
+    super.u(state, skipQueue);
   }
-  w() {
+  x() {
     this.b !== STATE_CLEAN && runTop(this);
   }
 };
@@ -1144,16 +1143,19 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  t(state, skipQueue) {
-    if (this.b >= state && !this.E)
+  u(state, skipQueue) {
+    if (this.b >= state && !this.H)
       return;
-    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.E))
-      getQueue(this).enqueue(EFFECT_PURE, this.w.bind(this));
-    super.t(state, true);
-    this.E = !!skipQueue;
+    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.H))
+      getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
+    super.u(state, true);
+    this.H = !!skipQueue;
   }
-  w() {
+  x() {
+    const prevFlags = this.h;
     this.b !== STATE_CLEAN && runTop(this);
+    if (ActiveTransition && this.r && this.h !== prevFlags)
+      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
   }
 };
 function runTop(node) {
@@ -1167,7 +1169,7 @@ function runTop(node) {
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].b !== STATE_DISPOSED)
-      ancestors[i].M();
+      ancestors[i].F();
   }
 }
 
@@ -1175,7 +1177,10 @@ function runTop(node) {
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node2 = new Computation(second, first, third);
-    return [node2.read.bind(node2), node2.write.bind(node2)];
+    return [node2.read.bind(node2), (v) => {
+      node2.F();
+      return node2.write(v);
+    }];
   }
   const o = getOwner();
   const needsId = o?.id != null;
@@ -1200,7 +1205,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.a?.length && node.m?.k !== node && !(node.i & UNINITIALIZED_BIT)) {
+      if (!node.a?.length && node.m?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1279,7 +1284,7 @@ function createAsync(compute2, value, options) {
     }
     n.b = STATE_DIRTY;
     refreshing = true;
-    n.M();
+    n.F();
   };
   return read;
 }
@@ -1345,14 +1350,24 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
+  const node = typeof first === "function" ? new Computation(second, (prev) => {
+    const res = first(prev);
+    if (reset.j)
+      return prev;
+    return res;
+  }, third) : new Computation(first, null, second);
+  node.r = true;
   const reset = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    cloneGraph(node, true);
-    queueMicrotask(() => reset.j && node.write(v));
+    queueMicrotask(() => {
+      if (reset.j) {
+        node.F();
+        node.write(v);
+      }
+    });
   }
   return [node.read.bind(node), write];
 }
@@ -1825,8 +1840,14 @@ function deep(store) {
 // src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
   const derived = typeof first === "function";
-  const { store, node } = derived ? createProjectionInternal(first, second, options) : createProjectionInternal(() => {
+  const { store, node } = derived ? createProjectionInternal((draft) => {
+    const res = first(draft);
+    if (reset.j)
+      return draft;
+    return res;
+  }, second, options) : createProjectionInternal(() => {
   }, first);
+  node.r = true;
   const reset = () => storeSetter(
     store,
     reconcile(
@@ -1839,7 +1860,6 @@ function createOptimisticStore(first, second, options) {
     if (!ActiveTransition)
       throw new Error("createOptimisticStore can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    cloneGraph(node, true);
     queueMicrotask(() => reset.j && storeSetter(store, v));
   };
   return [store, write];
@@ -2052,9 +2072,9 @@ function mapArray(list, map, options) {
     U: new Owner(),
     o: 0,
     ia: list,
-    F: [],
+    I: [],
     R: map,
-    h: [],
+    i: [],
     e: [],
     S: keyFn,
     p: keyFn || options?.keyed === false ? [] : void 0,
@@ -2086,14 +2106,14 @@ function updateKeyedMap() {
       if (this.o !== 0) {
         this.U.dispose(false);
         this.e = [];
-        this.F = [];
-        this.h = [];
+        this.I = [];
+        this.i = [];
         this.o = 0;
         this.p && (this.p = []);
         this.q && (this.q = []);
       }
-      if (this.V && !this.h[0]) {
-        this.h[0] = compute(
+      if (this.V && !this.i[0]) {
+        this.i[0] = compute(
           this.e[0] = new Owner(),
           this.V,
           null
@@ -2102,20 +2122,20 @@ function updateKeyedMap() {
     } else if (this.o === 0) {
       if (this.e[0])
         this.e[0].dispose();
-      this.h = new Array(newLen);
+      this.i = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.F[j] = newItems[j];
-        this.h[j] = compute(this.e[j] = new Owner(), mapper, null);
+        this.I[j] = newItems[j];
+        this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
       }
       this.o = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.p ? new Array(newLen) : void 0, tempIndexes = this.q ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.o, newLen); start < end && (this.F[start] === newItems[start] || this.p && compare(this.S, this.F[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.o, newLen); start < end && (this.I[start] === newItems[start] || this.p && compare(this.S, this.I[start], newItems[start])); start++) {
         if (this.p)
           this.p[start].write(newItems[start]);
       }
-      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.p && compare(this.S, this.F[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.h[end];
+      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.p && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.i[end];
         tempNodes[newEnd] = this.e[end];
         tempRows && (tempRows[newEnd] = this.p[end]);
         tempIndexes && (tempIndexes[newEnd] = this.q[end]);
@@ -2130,11 +2150,11 @@ function updateKeyedMap() {
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.F[i];
+        item = this.I[i];
         key = this.S ? this.S(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.h[i];
+          temp[j] = this.i[i];
           tempNodes[j] = this.e[i];
           tempRows && (tempRows[j] = this.p[i]);
           tempIndexes && (tempIndexes[j] = this.q[i]);
@@ -2145,7 +2165,7 @@ function updateKeyedMap() {
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.h[j] = temp[j];
+          this.i[j] = temp[j];
           this.e[j] = tempNodes[j];
           if (tempRows) {
             this.p[j] = tempRows[j];
@@ -2156,24 +2176,24 @@ function updateKeyedMap() {
             this.q[j].write(j);
           }
         } else {
-          this.h[j] = compute(this.e[j] = new Owner(), mapper, null);
+          this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
         }
       }
-      this.h = this.h.slice(0, this.o = newLen);
-      this.F = newItems.slice(0);
+      this.i = this.i.slice(0, this.o = newLen);
+      this.I = newItems.slice(0);
     }
   });
-  return this.h;
+  return this.i;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
     U: new Owner(),
     o: 0,
-    A: 0,
+    B: 0,
     ja: count,
     R: map,
     e: [],
-    h: [],
+    i: [],
     ka: options?.from,
     V: options?.fallback
   });
@@ -2186,11 +2206,11 @@ function updateRepeat() {
       if (this.o !== 0) {
         this.U.dispose(false);
         this.e = [];
-        this.h = [];
+        this.i = [];
         this.o = 0;
       }
-      if (this.V && !this.h[0]) {
-        this.h[0] = compute(
+      if (this.V && !this.i[0]) {
+        this.i[0] = compute(
           this.e[0] = new Owner(),
           this.V,
           null
@@ -2199,28 +2219,28 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.A + this.o;
+    const prevTo = this.B + this.o;
     if (this.o === 0 && this.e[0])
       this.e[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.e[i - this.A].dispose();
-    if (this.A < from) {
-      let i = this.A;
+      this.e[i - this.B].dispose();
+    if (this.B < from) {
+      let i = this.B;
       while (i < from && i < this.o)
         this.e[i++].dispose();
-      this.e.splice(0, from - this.A);
-      this.h.splice(0, from - this.A);
-    } else if (this.A > from) {
-      let i = prevTo - this.A - 1;
-      let difference = this.A - from;
-      this.e.length = this.h.length = newLen;
+      this.e.splice(0, from - this.B);
+      this.i.splice(0, from - this.B);
+    } else if (this.B > from) {
+      let i = prevTo - this.B - 1;
+      let difference = this.B - from;
+      this.e.length = this.i.length = newLen;
       while (i >= difference) {
         this.e[i] = this.e[i - difference];
-        this.h[i] = this.h[i - difference];
+        this.i[i] = this.i[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.h[i2] = compute(
+        this.i[i2] = compute(
           this.e[i2] = new Owner(),
           () => this.R(i2 + from),
           null
@@ -2228,17 +2248,17 @@ function updateRepeat() {
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.h[i - from] = compute(
+      this.i[i - from] = compute(
         this.e[i - from] = new Owner(),
         () => this.R(i),
         null
       );
     }
-    this.h = this.h.slice(0, newLen);
-    this.A = from;
+    this.i = this.i.slice(0, newLen);
+    this.B = from;
     this.o = newLen;
   });
-  return this.h;
+  return this.i;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
@@ -2253,7 +2273,7 @@ var BoundaryComputation = class extends EagerComputation {
   }
   write(value, flags) {
     super.write(value, flags & ~this.W);
-    if (this.W & LOADING_BIT && !(this.i & UNINITIALIZED_BIT || ActiveTransition)) {
+    if (this.W & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
     getQueue(this).notify(this, this.W, flags);
@@ -2261,9 +2281,9 @@ var BoundaryComputation = class extends EagerComputation {
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.C;
-  parentQueue.addChild(owner.C = queue);
-  onCleanup(() => parentQueue.removeChild(owner.C));
+  const parentQueue = owner.E;
+  parentQueue.addChild(owner.E = queue);
+  onCleanup(() => parentQueue.removeChild(owner.E));
   return compute(
     owner,
     () => {
@@ -2274,25 +2294,25 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  x;
+  y;
   X = /* @__PURE__ */ new Set();
-  s = /* @__PURE__ */ new Set();
+  t = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.x = disabled;
+    this.y = disabled;
   }
   run(type) {
-    if (!type || this.x.read())
+    if (!type || this.y.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (this.x.read()) {
+    if (this.y.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
-          this.s.add(node);
+          this.t.add(node);
           type &= ~LOADING_BIT;
-        } else if (this.s.delete(node))
+        } else if (this.t.delete(node))
           type &= ~LOADING_BIT;
       }
       if (type & ERROR_BIT) {
@@ -2306,41 +2326,41 @@ var ConditionalQueue = class extends Queue {
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.s.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
+    queue.t.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
     queue.X.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
     super.merge(queue);
   }
 };
 var CollectionQueue = class extends Queue {
-  K;
+  L;
   e = /* @__PURE__ */ new Set();
-  x = new Computation(false, null, { pureWrite: true });
+  y = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.K = type;
+    this.L = type;
   }
   run(type) {
-    if (!type || this.x.read())
+    if (!type || this.y.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this.K))
+    if (!(type & this.L))
       return super.notify(node, type, flags);
-    if (flags & this.K) {
+    if (flags & this.L) {
       this.e.add(node);
       if (this.e.size === 1)
-        this.x.write(true);
+        this.y.write(true);
     } else if (this.e.size > 0) {
       this.e.delete(node);
       if (this.e.size === 0)
-        this.x.write(false);
+        this.y.write(false);
     }
-    type &= ~this.K;
+    type &= ~this.L;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.e.forEach((n) => this.notify(n, this.K, this.K));
+    queue.e.forEach((n) => this.notify(n, this.L, this.L));
     super.merge(queue);
   }
 };
@@ -2351,25 +2371,25 @@ function createBoundary(fn, condition) {
   );
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.x.read();
+    const disabled = queue.y.read();
     tree.W = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
-      queue.s.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.t.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
       queue.X.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.s.clear();
+      queue.t.clear();
       queue.X.clear();
     }
   });
-  return () => queue.x.read() ? void 0 : tree.read();
+  return () => queue.y.read() ? void 0 : tree.read();
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = new Owner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = new Computation(void 0, () => {
-    if (!queue.x.read()) {
+    if (!queue.y.read()) {
       const resolved = tree.read();
-      if (!untrack(() => queue.x.read()))
+      if (!untrack(() => queue.y.read()))
         return resolved;
     }
     return fallback(queue);
@@ -2388,7 +2408,7 @@ function createErrorBoundary(fn, fallback) {
         if (ActiveTransition && !node2.d)
           node2 = cloneGraph(node2);
         node2.b = STATE_DIRTY;
-        getQueue(node2).enqueue(node2.r, node2.w.bind(node2));
+        getQueue(node2).enqueue(node2.s, node2.x.bind(node2));
       }
     });
   });